{{data.title}}
\n{{data.message}}
\n\n\n\n \n \n\n\n\n
\n\n\n\n \n\n
","import { Component, OnInit, ViewChild, AfterViewInit, ElementRef } from '@angular/core';\nimport { ActivatedRoute } from '@angular/router';\nimport { tap, merge, debounceTime, distinctUntilChanged, fromEvent } from 'rxjs';\n//import { Location } from '@angular/common';\nimport { MatPaginator } from '@angular/material/paginator';\nimport { MatSort, Sort, SortDirection } from '@angular/material/sort';\nimport { AppConstants } from 'src/app/app.constants';\nimport { MessageService } from 'src/app/services/message/message.service';\nimport { ErrorRsp, Handler, Package } from 'src/app/api/models';\nimport { PkgdashService } from 'src/app/api/services';\nimport { HandlersDataSource } from 'src/app/datasources/handlers';\n\n@Component({\n selector: 'app-package',\n templateUrl: './package.component.html',\n styleUrls: ['./package.component.scss'],\n providers: [PkgdashService],\n})\n\nexport class PackageComponent implements OnInit, AfterViewInit {\n @ViewChild(MatPaginator) paginator!: MatPaginator;\n @ViewChild(MatSort) sort!: MatSort;\n @ViewChild('input') input!: ElementRef;\n\n package!: Package;\n\n public itemsCount = 10;\n sortField = 'name';\n sortOrder: SortDirection = 'asc';\n\n displayedColumns: string[] = ['name', 'coverage'];\n\n dataSource: HandlersDataSource;\n selectedRowIndex: any;\n\n constructor(\n private route: ActivatedRoute,\n //private location: Location,\n private pkgdashService: PkgdashService,\n private messageService: MessageService,\n ) {\n this.dataSource = new HandlersDataSource(this.pkgdashService);\n }\n\n highlight(row: Handler) {\n this.selectedRowIndex = row.id;\n }\n\n ngAfterViewInit() {\n\n fromEvent(this.input.nativeElement, 'keyup')\n .pipe(\n debounceTime(AppConstants.SEARCH_DEBOUNCE),\n distinctUntilChanged(),\n tap(() => {\n this.paginator.pageIndex = 0;\n this.loadHandlers();\n })\n )\n .subscribe();\n\n this.sort.sortChange.subscribe(() => this.paginator.pageIndex = 0);\n\n merge(this.sort.sortChange, this.paginator.page)\n .pipe(\n tap(() => this.loadHandlers())\n )\n .subscribe();\n }\n\n public sortHandlers(event: Sort): void {\n this.loadHandlers()\n }\n\n private loadHandlers(): void {\n this.dataSource.list(\n this.package.id!,\n '',\n this.sort.active,\n this.sort.direction,\n this.paginator.pageIndex,\n this.paginator.pageSize);\n }\n\n\n ngOnInit(): void {\n this.package = this.route.snapshot.data['package'];\n this.dataSource.list(this.package.id!, '', this.sortField, this.sortOrder, 0, this.itemsCount);\n this.selectedRowIndex = 1;\n }\n\n}\n","\n
\n\n| Name | \n{{package.name}} {{package.description}} | \n URL | \n{{package.url}} | \nIssues | \n{{package.issues ? package.issues : 0}} | \nModules | \n{{package.modules ? package.modules : 0}} | \nComments | \n{{package.comments ? package.comments : 0}} | \nCoverage | \n{{package.coverage ? package.coverage : 0}} | \nHandlers | \n{{package.handlers ? package.handlers : 0}} | \nActions | \n\n \n | \n
|---|
modules
\n\n\n\n\n\n
\n\n\n\n \n\n
","import { DataSource } from \"@angular/cdk/collections\";\nimport { Handler } from \"../api/models/handler\"\nimport { BehaviorSubject, Observable, retry, map, catchError, of, finalize } from \"rxjs\";\nimport { PkgdashService } from \"../api/services\";\n\nexport class HandlersDataSource extends DataSource| Name | \n{{handler.name}} | \nCoverage | \n{{handler.coverage}} | \n
|---|
[AnimationBuilder.build](api/animations/AnimationBuilder#build)() method
+ * to create a programmatic animation. The method returns an `AnimationFactory` instance.
+ *
+ * 2. Use the factory object to create an `AnimationPlayer` and attach it to a DOM element.
+ *
+ * 3. Use the player object to control the animation programmatically.
+ *
+ * For example:
+ *
+ * ```ts
+ * // import the service from BrowserAnimationsModule
+ * import {AnimationBuilder} from '@angular/animations';
+ * // require the service as a dependency
+ * class MyCmp {
+ * constructor(private _builder: AnimationBuilder) {}
+ *
+ * makeAnimation(element: any) {
+ * // first define a reusable animation
+ * const myAnimation = this._builder.build([
+ * style({ width: 0 }),
+ * animate(1000, style({ width: '100px' }))
+ * ]);
+ *
+ * // use the returned factory object to create a player
+ * const player = myAnimation.create(element);
+ *
+ * player.play();
+ * }
+ * }
+ * ```
+ *
+ * @publicApi
+ */
+class AnimationBuilder {}
+/**
+ * A factory object returned from the
+ * [AnimationBuilder.build](api/animations/AnimationBuilder#build)()
+ * method.
+ *
+ * @publicApi
+ */
+
+
+class AnimationFactory {}
+/**
+ * @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.io/license
+ */
+
+/**
+ * Specifies automatic styling.
+ *
+ * @publicApi
+ */
+
+
+const AUTO_STYLE = '*';
+/**
+ * Creates a named animation trigger, containing a list of [`state()`](api/animations/state)
+ * and `transition()` entries to be evaluated when the expression
+ * bound to the trigger changes.
+ *
+ * @param name An identifying string.
+ * @param definitions An animation definition object, containing an array of
+ * [`state()`](api/animations/state) and `transition()` declarations.
+ *
+ * @return An object that encapsulates the trigger data.
+ *
+ * @usageNotes
+ * Define an animation trigger in the `animations` section of `@Component` metadata.
+ * In the template, reference the trigger by name and bind it to a trigger expression that
+ * evaluates to a defined animation state, using the following format:
+ *
+ * `[@triggerName]="expression"`
+ *
+ * Animation trigger bindings convert all values to strings, and then match the
+ * previous and current values against any linked transitions.
+ * Booleans can be specified as `1` or `true` and `0` or `false`.
+ *
+ * ### Usage Example
+ *
+ * The following example creates an animation trigger reference based on the provided
+ * name value.
+ * The provided animation value is expected to be an array consisting of state and
+ * transition declarations.
+ *
+ * ```typescript
+ * @Component({
+ * selector: "my-component",
+ * templateUrl: "my-component-tpl.html",
+ * animations: [
+ * trigger("myAnimationTrigger", [
+ * state(...),
+ * state(...),
+ * transition(...),
+ * transition(...)
+ * ])
+ * ]
+ * })
+ * class MyComponent {
+ * myStatusExp = "something";
+ * }
+ * ```
+ *
+ * The template associated with this component makes use of the defined trigger
+ * by binding to an element within its template code.
+ *
+ * ```html
+ *
+ * ...
+ * ```
+ *
+ * ### Using an inline function
+ * The `transition` animation method also supports reading an inline function which can decide
+ * if its associated animation should be run.
+ *
+ * ```typescript
+ * // this method is run each time the `myAnimationTrigger` trigger value changes.
+ * function myInlineMatcherFn(fromState: string, toState: string, element: any, params: {[key:
+ string]: any}): boolean {
+ * // notice that `element` and `params` are also available here
+ * return toState == 'yes-please-animate';
+ * }
+ *
+ * @Component({
+ * selector: 'my-component',
+ * templateUrl: 'my-component-tpl.html',
+ * animations: [
+ * trigger('myAnimationTrigger', [
+ * transition(myInlineMatcherFn, [
+ * // the animation sequence code
+ * ]),
+ * ])
+ * ]
+ * })
+ * class MyComponent {
+ * myStatusExp = "yes-please-animate";
+ * }
+ * ```
+ *
+ * ### Disabling Animations
+ * When true, the special animation control binding `@.disabled` binding prevents
+ * all animations from rendering.
+ * Place the `@.disabled` binding on an element to disable
+ * animations on the element itself, as well as any inner animation triggers
+ * within the element.
+ *
+ * The following example shows how to use this feature:
+ *
+ * ```typescript
+ * @Component({
+ * selector: 'my-component',
+ * template: `
+ *
+ *
+ *
+ * `,
+ * animations: [
+ * trigger("childAnimation", [
+ * // ...
+ * ])
+ * ]
+ * })
+ * class MyComponent {
+ * isDisabled = true;
+ * exp = '...';
+ * }
+ * ```
+ *
+ * When `@.disabled` is true, it prevents the `@childAnimation` trigger from animating,
+ * along with any inner animations.
+ *
+ * ### Disable animations application-wide
+ * When an area of the template is set to have animations disabled,
+ * **all** inner components have their animations disabled as well.
+ * This means that you can disable all animations for an app
+ * by placing a host binding set on `@.disabled` on the topmost Angular component.
+ *
+ * ```typescript
+ * import {Component, HostBinding} from '@angular/core';
+ *
+ * @Component({
+ * selector: 'app-component',
+ * templateUrl: 'app.component.html',
+ * })
+ * class AppComponent {
+ * @HostBinding('@.disabled')
+ * public animationsDisabled = true;
+ * }
+ * ```
+ *
+ * ### Overriding disablement of inner animations
+ * Despite inner animations being disabled, a parent animation can `query()`
+ * for inner elements located in disabled areas of the template and still animate
+ * them if needed. This is also the case for when a sub animation is
+ * queried by a parent and then later animated using `animateChild()`.
+ *
+ * ### Detecting when an animation is disabled
+ * If a region of the DOM (or the entire application) has its animations disabled, the animation
+ * trigger callbacks still fire, but for zero seconds. When the callback fires, it provides
+ * an instance of an `AnimationEvent`. If animations are disabled,
+ * the `.disabled` flag on the event is true.
+ *
+ * @publicApi
+ */
+
+function trigger(name, definitions) {
+ return {
+ type: 7
+ /* AnimationMetadataType.Trigger */
+ ,
+ name,
+ definitions,
+ options: {}
+ };
+}
+/**
+ * Defines an animation step that combines styling information with timing information.
+ *
+ * @param timings Sets `AnimateTimings` for the parent animation.
+ * A string in the format "duration [delay] [easing]".
+ * - Duration and delay are expressed as a number and optional time unit,
+ * such as "1s" or "10ms" for one second and 10 milliseconds, respectively.
+ * The default unit is milliseconds.
+ * - The easing value controls how the animation accelerates and decelerates
+ * during its runtime. Value is one of `ease`, `ease-in`, `ease-out`,
+ * `ease-in-out`, or a `cubic-bezier()` function call.
+ * If not supplied, no easing is applied.
+ *
+ * For example, the string "1s 100ms ease-out" specifies a duration of
+ * 1000 milliseconds, and delay of 100 ms, and the "ease-out" easing style,
+ * which decelerates near the end of the duration.
+ * @param styles Sets AnimationStyles for the parent animation.
+ * A function call to either `style()` or `keyframes()`
+ * that returns a collection of CSS style entries to be applied to the parent animation.
+ * When null, uses the styles from the destination state.
+ * This is useful when describing an animation step that will complete an animation;
+ * see "Animating to the final state" in `transitions()`.
+ * @returns An object that encapsulates the animation step.
+ *
+ * @usageNotes
+ * Call within an animation `sequence()`, `{@link animations/group group()}`, or
+ * `transition()` call to specify an animation step
+ * that applies given style data to the parent animation for a given amount of time.
+ *
+ * ### Syntax Examples
+ * **Timing examples**
+ *
+ * The following examples show various `timings` specifications.
+ * - `animate(500)` : Duration is 500 milliseconds.
+ * - `animate("1s")` : Duration is 1000 milliseconds.
+ * - `animate("100ms 0.5s")` : Duration is 100 milliseconds, delay is 500 milliseconds.
+ * - `animate("5s ease-in")` : Duration is 5000 milliseconds, easing in.
+ * - `animate("5s 10ms cubic-bezier(.17,.67,.88,.1)")` : Duration is 5000 milliseconds, delay is 10
+ * milliseconds, easing according to a bezier curve.
+ *
+ * **Style examples**
+ *
+ * The following example calls `style()` to set a single CSS style.
+ * ```typescript
+ * animate(500, style({ background: "red" }))
+ * ```
+ * The following example calls `keyframes()` to set a CSS style
+ * to different values for successive keyframes.
+ * ```typescript
+ * animate(500, keyframes(
+ * [
+ * style({ background: "blue" }),
+ * style({ background: "red" })
+ * ])
+ * ```
+ *
+ * @publicApi
+ */
+
+
+function animate(timings, styles = null) {
+ return {
+ type: 4
+ /* AnimationMetadataType.Animate */
+ ,
+ styles,
+ timings
+ };
+}
+/**
+ * @description Defines a list of animation steps to be run in parallel.
+ *
+ * @param steps An array of animation step objects.
+ * - When steps are defined by `style()` or `animate()`
+ * function calls, each call within the group is executed instantly.
+ * - To specify offset styles to be applied at a later time, define steps with
+ * `keyframes()`, or use `animate()` calls with a delay value.
+ * For example:
+ *
+ * ```typescript
+ * group([
+ * animate("1s", style({ background: "black" })),
+ * animate("2s", style({ color: "white" }))
+ * ])
+ * ```
+ *
+ * @param options An options object containing a delay and
+ * developer-defined parameters that provide styling defaults and
+ * can be overridden on invocation.
+ *
+ * @return An object that encapsulates the group data.
+ *
+ * @usageNotes
+ * Grouped animations are useful when a series of styles must be
+ * animated at different starting times and closed off at different ending times.
+ *
+ * When called within a `sequence()` or a
+ * `transition()` call, does not continue to the next
+ * instruction until all of the inner animation steps have completed.
+ *
+ * @publicApi
+ */
+
+
+function group(steps, options = null) {
+ return {
+ type: 3
+ /* AnimationMetadataType.Group */
+ ,
+ steps,
+ options
+ };
+}
+/**
+ * Defines a list of animation steps to be run sequentially, one by one.
+ *
+ * @param steps An array of animation step objects.
+ * - Steps defined by `style()` calls apply the styling data immediately.
+ * - Steps defined by `animate()` calls apply the styling data over time
+ * as specified by the timing data.
+ *
+ * ```typescript
+ * sequence([
+ * style({ opacity: 0 }),
+ * animate("1s", style({ opacity: 1 }))
+ * ])
+ * ```
+ *
+ * @param options An options object containing a delay and
+ * developer-defined parameters that provide styling defaults and
+ * can be overridden on invocation.
+ *
+ * @return An object that encapsulates the sequence data.
+ *
+ * @usageNotes
+ * When you pass an array of steps to a
+ * `transition()` call, the steps run sequentially by default.
+ * Compare this to the `{@link animations/group group()}` call, which runs animation steps in
+ *parallel.
+ *
+ * When a sequence is used within a `{@link animations/group group()}` or a `transition()` call,
+ * execution continues to the next instruction only after each of the inner animation
+ * steps have completed.
+ *
+ * @publicApi
+ **/
+
+
+function sequence(steps, options = null) {
+ return {
+ type: 2
+ /* AnimationMetadataType.Sequence */
+ ,
+ steps,
+ options
+ };
+}
+/**
+ * Declares a key/value object containing CSS properties/styles that
+ * can then be used for an animation [`state`](api/animations/state), within an animation
+ *`sequence`, or as styling data for calls to `animate()` and `keyframes()`.
+ *
+ * @param tokens A set of CSS styles or HTML styles associated with an animation state.
+ * The value can be any of the following:
+ * - A key-value style pair associating a CSS property with a value.
+ * - An array of key-value style pairs.
+ * - An asterisk (*), to use auto-styling, where styles are derived from the element
+ * being animated and applied to the animation when it starts.
+ *
+ * Auto-styling can be used to define a state that depends on layout or other
+ * environmental factors.
+ *
+ * @return An object that encapsulates the style data.
+ *
+ * @usageNotes
+ * The following examples create animation styles that collect a set of
+ * CSS property values:
+ *
+ * ```typescript
+ * // string values for CSS properties
+ * style({ background: "red", color: "blue" })
+ *
+ * // numerical pixel values
+ * style({ width: 100, height: 0 })
+ * ```
+ *
+ * The following example uses auto-styling to allow an element to animate from
+ * a height of 0 up to its full height:
+ *
+ * ```
+ * style({ height: 0 }),
+ * animate("1s", style({ height: "*" }))
+ * ```
+ *
+ * @publicApi
+ **/
+
+
+function style(tokens) {
+ return {
+ type: 6
+ /* AnimationMetadataType.Style */
+ ,
+ styles: tokens,
+ offset: null
+ };
+}
+/**
+ * Declares an animation state within a trigger attached to an element.
+ *
+ * @param name One or more names for the defined state in a comma-separated string.
+ * The following reserved state names can be supplied to define a style for specific use
+ * cases:
+ *
+ * - `void` You can associate styles with this name to be used when
+ * the element is detached from the application. For example, when an `ngIf` evaluates
+ * to false, the state of the associated element is void.
+ * - `*` (asterisk) Indicates the default state. You can associate styles with this name
+ * to be used as the fallback when the state that is being animated is not declared
+ * within the trigger.
+ *
+ * @param styles A set of CSS styles associated with this state, created using the
+ * `style()` function.
+ * This set of styles persists on the element once the state has been reached.
+ * @param options Parameters that can be passed to the state when it is invoked.
+ * 0 or more key-value pairs.
+ * @return An object that encapsulates the new state data.
+ *
+ * @usageNotes
+ * Use the `trigger()` function to register states to an animation trigger.
+ * Use the `transition()` function to animate between states.
+ * When a state is active within a component, its associated styles persist on the element,
+ * even when the animation ends.
+ *
+ * @publicApi
+ **/
+
+
+function state(name, styles, options) {
+ return {
+ type: 0
+ /* AnimationMetadataType.State */
+ ,
+ name,
+ styles,
+ options
+ };
+}
+/**
+ * Defines a set of animation styles, associating each style with an optional `offset` value.
+ *
+ * @param steps A set of animation styles with optional offset data.
+ * The optional `offset` value for a style specifies a percentage of the total animation
+ * time at which that style is applied.
+ * @returns An object that encapsulates the keyframes data.
+ *
+ * @usageNotes
+ * Use with the `animate()` call. Instead of applying animations
+ * from the current state
+ * to the destination state, keyframes describe how each style entry is applied and at what point
+ * within the animation arc.
+ * Compare [CSS Keyframe Animations](https://www.w3schools.com/css/css3_animations.asp).
+ *
+ * ### Usage
+ *
+ * In the following example, the offset values describe
+ * when each `backgroundColor` value is applied. The color is red at the start, and changes to
+ * blue when 20% of the total time has elapsed.
+ *
+ * ```typescript
+ * // the provided offset values
+ * animate("5s", keyframes([
+ * style({ backgroundColor: "red", offset: 0 }),
+ * style({ backgroundColor: "blue", offset: 0.2 }),
+ * style({ backgroundColor: "orange", offset: 0.3 }),
+ * style({ backgroundColor: "black", offset: 1 })
+ * ]))
+ * ```
+ *
+ * If there are no `offset` values specified in the style entries, the offsets
+ * are calculated automatically.
+ *
+ * ```typescript
+ * animate("5s", keyframes([
+ * style({ backgroundColor: "red" }) // offset = 0
+ * style({ backgroundColor: "blue" }) // offset = 0.33
+ * style({ backgroundColor: "orange" }) // offset = 0.66
+ * style({ backgroundColor: "black" }) // offset = 1
+ * ]))
+ *```
+
+ * @publicApi
+ */
+
+
+function keyframes(steps) {
+ return {
+ type: 5
+ /* AnimationMetadataType.Keyframes */
+ ,
+ steps
+ };
+}
+/**
+ * Declares an animation transition which is played when a certain specified condition is met.
+ *
+ * @param stateChangeExpr A string with a specific format or a function that specifies when the
+ * animation transition should occur (see [State Change Expression](#state-change-expression)).
+ *
+ * @param steps One or more animation objects that represent the animation's instructions.
+ *
+ * @param options An options object that can be used to specify a delay for the animation or provide
+ * custom parameters for it.
+ *
+ * @returns An object that encapsulates the transition data.
+ *
+ * @usageNotes
+ *
+ * ### State Change Expression
+ *
+ * The State Change Expression instructs Angular when to run the transition's animations, it can
+ *either be
+ * - a string with a specific syntax
+ * - or a function that compares the previous and current state (value of the expression bound to
+ * the element's trigger) and returns `true` if the transition should occur or `false` otherwise
+ *
+ * The string format can be:
+ * - `fromState => toState`, which indicates that the transition's animations should occur then the
+ * expression bound to the trigger's element goes from `fromState` to `toState`
+ *
+ * _Example:_
+ * ```typescript
+ * transition('open => closed', animate('.5s ease-out', style({ height: 0 }) ))
+ * ```
+ *
+ * - `fromState <=> toState`, which indicates that the transition's animations should occur then
+ * the expression bound to the trigger's element goes from `fromState` to `toState` or vice versa
+ *
+ * _Example:_
+ * ```typescript
+ * transition('enabled <=> disabled', animate('1s cubic-bezier(0.8,0.3,0,1)'))
+ * ```
+ *
+ * - `:enter`/`:leave`, which indicates that the transition's animations should occur when the
+ * element enters or exists the DOM
+ *
+ * _Example:_
+ * ```typescript
+ * transition(':enter', [
+ * style({ opacity: 0 }),
+ * animate('500ms', style({ opacity: 1 }))
+ * ])
+ * ```
+ *
+ * - `:increment`/`:decrement`, which indicates that the transition's animations should occur when
+ * the numerical expression bound to the trigger's element has increased in value or decreased
+ *
+ * _Example:_
+ * ```typescript
+ * transition(':increment', query('@counter', animateChild()))
+ * ```
+ *
+ * - a sequence of any of the above divided by commas, which indicates that transition's animations
+ * should occur whenever one of the state change expressions matches
+ *
+ * _Example:_
+ * ```typescript
+ * transition(':increment, * => enabled, :enter', animate('1s ease', keyframes([
+ * style({ transform: 'scale(1)', offset: 0}),
+ * style({ transform: 'scale(1.1)', offset: 0.7}),
+ * style({ transform: 'scale(1)', offset: 1})
+ * ]))),
+ * ```
+ *
+ * Also note that in such context:
+ * - `void` can be used to indicate the absence of the element
+ * - asterisks can be used as wildcards that match any state
+ * - (as a consequence of the above, `void => *` is equivalent to `:enter` and `* => void` is
+ * equivalent to `:leave`)
+ * - `true` and `false` also match expression values of `1` and `0` respectively (but do not match
+ * _truthy_ and _falsy_ values)
+ *
+ *
+ *
+ * Be careful about entering end leaving elements as their transitions present a common
+ * pitfall for developers.
+ *
+ * Note that when an element with a trigger enters the DOM its `:enter` transition always
+ * gets executed, but its `:leave` transition will not be executed if the element is removed
+ * alongside its parent (as it will be removed "without warning" before its transition has
+ * a chance to be executed, the only way that such transition can occur is if the element
+ * is exiting the DOM on its own).
+ *
+ *
+ *
+ *
+ * ### Animating to a Final State
+ *
+ * If the final step in a transition is a call to `animate()` that uses a timing value
+ * with no `style` data, that step is automatically considered the final animation arc,
+ * for the element to reach the final state, in such case Angular automatically adds or removes
+ * CSS styles to ensure that the element is in the correct final state.
+ *
+ *
+ * ### Usage Examples
+ *
+ * - Transition animations applied based on
+ * the trigger's expression value
+ *
+ * ```HTML
+ *
+ * ...
+ *
+ * ```
+ *
+ * ```typescript
+ * trigger("myAnimationTrigger", [
+ * ..., // states
+ * transition("on => off, open => closed", animate(500)),
+ * transition("* <=> error", query('.indicator', animateChild()))
+ * ])
+ * ```
+ *
+ * - Transition animations applied based on custom logic dependent
+ * on the trigger's expression value and provided parameters
+ *
+ * ```HTML
+ *
+ * ...
+ *
+ * ```
+ *
+ * ```typescript
+ * trigger("myAnimationTrigger", [
+ * ..., // states
+ * transition(
+ * (fromState, toState, _element, params) =>
+ * ['firststep', 'laststep'].includes(fromState.toLowerCase())
+ * && toState === params?.['target'],
+ * animate('1s')
+ * )
+ * ])
+ * ```
+ *
+ * @publicApi
+ **/
+
+
+function transition(stateChangeExpr, steps, options = null) {
+ return {
+ type: 1
+ /* AnimationMetadataType.Transition */
+ ,
+ expr: stateChangeExpr,
+ animation: steps,
+ options
+ };
+}
+/**
+ * Produces a reusable animation that can be invoked in another animation or sequence,
+ * by calling the `useAnimation()` function.
+ *
+ * @param steps One or more animation objects, as returned by the `animate()`
+ * or `sequence()` function, that form a transformation from one state to another.
+ * A sequence is used by default when you pass an array.
+ * @param options An options object that can contain a delay value for the start of the
+ * animation, and additional developer-defined parameters.
+ * Provided values for additional parameters are used as defaults,
+ * and override values can be passed to the caller on invocation.
+ * @returns An object that encapsulates the animation data.
+ *
+ * @usageNotes
+ * The following example defines a reusable animation, providing some default parameter
+ * values.
+ *
+ * ```typescript
+ * var fadeAnimation = animation([
+ * style({ opacity: '{{ start }}' }),
+ * animate('{{ time }}',
+ * style({ opacity: '{{ end }}'}))
+ * ],
+ * { params: { time: '1000ms', start: 0, end: 1 }});
+ * ```
+ *
+ * The following invokes the defined animation with a call to `useAnimation()`,
+ * passing in override parameter values.
+ *
+ * ```js
+ * useAnimation(fadeAnimation, {
+ * params: {
+ * time: '2s',
+ * start: 1,
+ * end: 0
+ * }
+ * })
+ * ```
+ *
+ * If any of the passed-in parameter values are missing from this call,
+ * the default values are used. If one or more parameter values are missing before a step is
+ * animated, `useAnimation()` throws an error.
+ *
+ * @publicApi
+ */
+
+
+function animation(steps, options = null) {
+ return {
+ type: 8
+ /* AnimationMetadataType.Reference */
+ ,
+ animation: steps,
+ options
+ };
+}
+/**
+ * Executes a queried inner animation element within an animation sequence.
+ *
+ * @param options An options object that can contain a delay value for the start of the
+ * animation, and additional override values for developer-defined parameters.
+ * @return An object that encapsulates the child animation data.
+ *
+ * @usageNotes
+ * Each time an animation is triggered in Angular, the parent animation
+ * has priority and any child animations are blocked. In order
+ * for a child animation to run, the parent animation must query each of the elements
+ * containing child animations, and run them using this function.
+ *
+ * Note that this feature is designed to be used with `query()` and it will only work
+ * with animations that are assigned using the Angular animation library. CSS keyframes
+ * and transitions are not handled by this API.
+ *
+ * @publicApi
+ */
+
+
+function animateChild(options = null) {
+ return {
+ type: 9
+ /* AnimationMetadataType.AnimateChild */
+ ,
+ options
+ };
+}
+/**
+ * Starts a reusable animation that is created using the `animation()` function.
+ *
+ * @param animation The reusable animation to start.
+ * @param options An options object that can contain a delay value for the start of
+ * the animation, and additional override values for developer-defined parameters.
+ * @return An object that contains the animation parameters.
+ *
+ * @publicApi
+ */
+
+
+function useAnimation(animation, options = null) {
+ return {
+ type: 10
+ /* AnimationMetadataType.AnimateRef */
+ ,
+ animation,
+ options
+ };
+}
+/**
+ * Finds one or more inner elements within the current element that is
+ * being animated within a sequence. Use with `animate()`.
+ *
+ * @param selector The element to query, or a set of elements that contain Angular-specific
+ * characteristics, specified with one or more of the following tokens.
+ * - `query(":enter")` or `query(":leave")` : Query for newly inserted/removed elements (not
+ * all elements can be queried via these tokens, see
+ * [Entering and Leaving Elements](#entering-and-leaving-elements))
+ * - `query(":animating")` : Query all currently animating elements.
+ * - `query("@triggerName")` : Query elements that contain an animation trigger.
+ * - `query("@*")` : Query all elements that contain an animation triggers.
+ * - `query(":self")` : Include the current element into the animation sequence.
+ *
+ * @param animation One or more animation steps to apply to the queried element or elements.
+ * An array is treated as an animation sequence.
+ * @param options An options object. Use the 'limit' field to limit the total number of
+ * items to collect.
+ * @return An object that encapsulates the query data.
+ *
+ * @usageNotes
+ *
+ * ### Multiple Tokens
+ *
+ * Tokens can be merged into a combined query selector string. For example:
+ *
+ * ```typescript
+ * query(':self, .record:enter, .record:leave, @subTrigger', [...])
+ * ```
+ *
+ * The `query()` function collects multiple elements and works internally by using
+ * `element.querySelectorAll`. Use the `limit` field of an options object to limit
+ * the total number of items to be collected. For example:
+ *
+ * ```js
+ * query('div', [
+ * animate(...),
+ * animate(...)
+ * ], { limit: 1 })
+ * ```
+ *
+ * By default, throws an error when zero items are found. Set the
+ * `optional` flag to ignore this error. For example:
+ *
+ * ```js
+ * query('.some-element-that-may-not-be-there', [
+ * animate(...),
+ * animate(...)
+ * ], { optional: true })
+ * ```
+ *
+ * ### Entering and Leaving Elements
+ *
+ * Not all elements can be queried via the `:enter` and `:leave` tokens, the only ones
+ * that can are those that Angular assumes can enter/leave based on their own logic
+ * (if their insertion/removal is simply a consequence of that of their parent they
+ * should be queried via a different token in their parent's `:enter`/`:leave` transitions).
+ *
+ * The only elements Angular assumes can enter/leave based on their own logic (thus the only
+ * ones that can be queried via the `:enter` and `:leave` tokens) are:
+ * - Those inserted dynamically (via `ViewContainerRef`)
+ * - Those that have a structural directive (which, under the hood, are a subset of the above ones)
+ *
+ *
+ *
+ * Note that elements will be successfully queried via `:enter`/`:leave` even if their
+ * insertion/removal is not done manually via `ViewContainerRef`or caused by their structural
+ * directive (e.g. they enter/exit alongside their parent).
+ *
+ *
+ *
+ *
+ *
+ * There is an exception to what previously mentioned, besides elements entering/leaving based on
+ * their own logic, elements with an animation trigger can always be queried via `:leave` when
+ * their parent is also leaving.
+ *
+ *
+ *
+ * ### Usage Example
+ *
+ * The following example queries for inner elements and animates them
+ * individually using `animate()`.
+ *
+ * ```typescript
+ * @Component({
+ * selector: 'inner',
+ * template: `
+ *
+ *
+ * `,
+ * animations: [
+ * trigger('queryAnimation', [
+ * transition('* => goAnimate', [
+ * // hide the inner elements
+ * query('h1', style({ opacity: 0 })),
+ * query('.content', style({ opacity: 0 })),
+ *
+ * // animate the inner elements in, one by one
+ * query('h1', animate(1000, style({ opacity: 1 }))),
+ * query('.content', animate(1000, style({ opacity: 1 }))),
+ * ])
+ * ])
+ * ]
+ * })
+ * class Cmp {
+ * exp = '';
+ *
+ * goAnimate() {
+ * this.exp = 'goAnimate';
+ * }
+ * }
+ * ```
+ *
+ * @publicApi
+ */
+
+
+function query(selector, animation, options = null) {
+ return {
+ type: 11
+ /* AnimationMetadataType.Query */
+ ,
+ selector,
+ animation,
+ options
+ };
+}
+/**
+ * Use within an animation `query()` call to issue a timing gap after
+ * each queried item is animated.
+ *
+ * @param timings A delay value.
+ * @param animation One ore more animation steps.
+ * @returns An object that encapsulates the stagger data.
+ *
+ * @usageNotes
+ * In the following example, a container element wraps a list of items stamped out
+ * by an `ngFor`. The container element contains an animation trigger that will later be set
+ * to query for each of the inner items.
+ *
+ * Each time items are added, the opacity fade-in animation runs,
+ * and each removed item is faded out.
+ * When either of these animations occur, the stagger effect is
+ * applied after each item's animation is started.
+ *
+ * ```html
+ *
+ *
+ * Title
+ *
+ * Blah blah blah
+ *
+ * + *
+ *
+ * ```
+ *
+ * Here is the component code:
+ *
+ * ```typescript
+ * import {trigger, transition, style, animate, query, stagger} from '@angular/animations';
+ * @Component({
+ * templateUrl: 'list.component.html',
+ * animations: [
+ * trigger('listAnimation', [
+ * ...
+ * ])
+ * ]
+ * })
+ * class ListComponent {
+ * items = [];
+ *
+ * showItems() {
+ * this.items = [0,1,2,3,4];
+ * }
+ *
+ * hideItems() {
+ * this.items = [];
+ * }
+ *
+ * toggle() {
+ * this.items.length ? this.hideItems() : this.showItems();
+ * }
+ * }
+ * ```
+ *
+ * Here is the animation trigger code:
+ *
+ * ```typescript
+ * trigger('listAnimation', [
+ * transition('* => *', [ // each time the binding value changes
+ * query(':leave', [
+ * stagger(100, [
+ * animate('0.5s', style({ opacity: 0 }))
+ * ])
+ * ]),
+ * query(':enter', [
+ * style({ opacity: 0 }),
+ * stagger(100, [
+ * animate('0.5s', style({ opacity: 1 }))
+ * ])
+ * ])
+ * ])
+ * ])
+ * ```
+ *
+ * @publicApi
+ */
+
+
+function stagger(timings, animation) {
+ return {
+ type: 12
+ /* AnimationMetadataType.Stagger */
+ ,
+ timings,
+ animation
+ };
+}
+/**
+ * @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.io/license
+ */
+
+
+function scheduleMicroTask(cb) {
+ Promise.resolve().then(cb);
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * An empty programmatic controller for reusable animations.
+ * Used internally when animations are disabled, to avoid
+ * checking for the null case when an animation player is expected.
+ *
+ * @see `animate()`
+ * @see `AnimationPlayer`
+ * @see `GroupPlayer`
+ *
+ * @publicApi
+ */
+
+
+class NoopAnimationPlayer {
+ constructor(duration = 0, delay = 0) {
+ this._onDoneFns = [];
+ this._onStartFns = [];
+ this._onDestroyFns = [];
+ this._originalOnDoneFns = [];
+ this._originalOnStartFns = [];
+ this._started = false;
+ this._destroyed = false;
+ this._finished = false;
+ this._position = 0;
+ this.parentPlayer = null;
+ this.totalTime = duration + delay;
+ }
+
+ _onFinish() {
+ if (!this._finished) {
+ this._finished = true;
+
+ this._onDoneFns.forEach(fn => fn());
+
+ this._onDoneFns = [];
+ }
+ }
+
+ onStart(fn) {
+ this._originalOnStartFns.push(fn);
+
+ this._onStartFns.push(fn);
+ }
+
+ onDone(fn) {
+ this._originalOnDoneFns.push(fn);
+
+ this._onDoneFns.push(fn);
+ }
+
+ onDestroy(fn) {
+ this._onDestroyFns.push(fn);
+ }
+
+ hasStarted() {
+ return this._started;
+ }
+
+ init() {}
+
+ play() {
+ if (!this.hasStarted()) {
+ this._onStart();
+
+ this.triggerMicrotask();
+ }
+
+ this._started = true;
+ }
+ /** @internal */
+
+
+ triggerMicrotask() {
+ scheduleMicroTask(() => this._onFinish());
+ }
+
+ _onStart() {
+ this._onStartFns.forEach(fn => fn());
+
+ this._onStartFns = [];
+ }
+
+ pause() {}
+
+ restart() {}
+
+ finish() {
+ this._onFinish();
+ }
+
+ destroy() {
+ if (!this._destroyed) {
+ this._destroyed = true;
+
+ if (!this.hasStarted()) {
+ this._onStart();
+ }
+
+ this.finish();
+
+ this._onDestroyFns.forEach(fn => fn());
+
+ this._onDestroyFns = [];
+ }
+ }
+
+ reset() {
+ this._started = false;
+ this._finished = false;
+ this._onStartFns = this._originalOnStartFns;
+ this._onDoneFns = this._originalOnDoneFns;
+ }
+
+ setPosition(position) {
+ this._position = this.totalTime ? position * this.totalTime : 1;
+ }
+
+ getPosition() {
+ return this.totalTime ? this._position / this.totalTime : 1;
+ }
+ /** @internal */
+
+
+ triggerCallback(phaseName) {
+ const methods = phaseName == 'start' ? this._onStartFns : this._onDoneFns;
+ methods.forEach(fn => fn());
+ methods.length = 0;
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * A programmatic controller for a group of reusable animations.
+ * Used internally to control animations.
+ *
+ * @see `AnimationPlayer`
+ * @see `{@link animations/group group()}`
+ *
+ */
+
+
+class AnimationGroupPlayer {
+ constructor(_players) {
+ this._onDoneFns = [];
+ this._onStartFns = [];
+ this._finished = false;
+ this._started = false;
+ this._destroyed = false;
+ this._onDestroyFns = [];
+ this.parentPlayer = null;
+ this.totalTime = 0;
+ this.players = _players;
+ let doneCount = 0;
+ let destroyCount = 0;
+ let startCount = 0;
+ const total = this.players.length;
+
+ if (total == 0) {
+ scheduleMicroTask(() => this._onFinish());
+ } else {
+ this.players.forEach(player => {
+ player.onDone(() => {
+ if (++doneCount == total) {
+ this._onFinish();
+ }
+ });
+ player.onDestroy(() => {
+ if (++destroyCount == total) {
+ this._onDestroy();
+ }
+ });
+ player.onStart(() => {
+ if (++startCount == total) {
+ this._onStart();
+ }
+ });
+ });
+ }
+
+ this.totalTime = this.players.reduce((time, player) => Math.max(time, player.totalTime), 0);
+ }
+
+ _onFinish() {
+ if (!this._finished) {
+ this._finished = true;
+
+ this._onDoneFns.forEach(fn => fn());
+
+ this._onDoneFns = [];
+ }
+ }
+
+ init() {
+ this.players.forEach(player => player.init());
+ }
+
+ onStart(fn) {
+ this._onStartFns.push(fn);
+ }
+
+ _onStart() {
+ if (!this.hasStarted()) {
+ this._started = true;
+
+ this._onStartFns.forEach(fn => fn());
+
+ this._onStartFns = [];
+ }
+ }
+
+ onDone(fn) {
+ this._onDoneFns.push(fn);
+ }
+
+ onDestroy(fn) {
+ this._onDestroyFns.push(fn);
+ }
+
+ hasStarted() {
+ return this._started;
+ }
+
+ play() {
+ if (!this.parentPlayer) {
+ this.init();
+ }
+
+ this._onStart();
+
+ this.players.forEach(player => player.play());
+ }
+
+ pause() {
+ this.players.forEach(player => player.pause());
+ }
+
+ restart() {
+ this.players.forEach(player => player.restart());
+ }
+
+ finish() {
+ this._onFinish();
+
+ this.players.forEach(player => player.finish());
+ }
+
+ destroy() {
+ this._onDestroy();
+ }
+
+ _onDestroy() {
+ if (!this._destroyed) {
+ this._destroyed = true;
+
+ this._onFinish();
+
+ this.players.forEach(player => player.destroy());
+
+ this._onDestroyFns.forEach(fn => fn());
+
+ this._onDestroyFns = [];
+ }
+ }
+
+ reset() {
+ this.players.forEach(player => player.reset());
+ this._destroyed = false;
+ this._finished = false;
+ this._started = false;
+ }
+
+ setPosition(p) {
+ const timeAtPosition = p * this.totalTime;
+ this.players.forEach(player => {
+ const position = player.totalTime ? Math.min(1, timeAtPosition / player.totalTime) : 1;
+ player.setPosition(position);
+ });
+ }
+
+ getPosition() {
+ const longestPlayer = this.players.reduce((longestSoFar, player) => {
+ const newPlayerIsLongest = longestSoFar === null || player.totalTime > longestSoFar.totalTime;
+ return newPlayerIsLongest ? player : longestSoFar;
+ }, null);
+ return longestPlayer != null ? longestPlayer.getPosition() : 0;
+ }
+
+ beforeDestroy() {
+ this.players.forEach(player => {
+ if (player.beforeDestroy) {
+ player.beforeDestroy();
+ }
+ });
+ }
+ /** @internal */
+
+
+ triggerCallback(phaseName) {
+ const methods = phaseName == 'start' ? this._onStartFns : this._onDoneFns;
+ methods.forEach(fn => fn());
+ methods.length = 0;
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+
+const ɵPRE_STYLE = '!';
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+
+
+/***/ }),
+
+/***/ 5787:
+/*!***************************************************************!*\
+ !*** ./node_modules/@angular/animations/fesm2020/browser.mjs ***!
+ \***************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "AnimationDriver": () => (/* binding */ AnimationDriver),
+/* harmony export */ "ɵAnimation": () => (/* binding */ Animation),
+/* harmony export */ "ɵAnimationEngine": () => (/* binding */ AnimationEngine),
+/* harmony export */ "ɵAnimationStyleNormalizer": () => (/* binding */ AnimationStyleNormalizer),
+/* harmony export */ "ɵNoopAnimationDriver": () => (/* binding */ NoopAnimationDriver),
+/* harmony export */ "ɵNoopAnimationStyleNormalizer": () => (/* binding */ NoopAnimationStyleNormalizer),
+/* harmony export */ "ɵWebAnimationsDriver": () => (/* binding */ WebAnimationsDriver),
+/* harmony export */ "ɵWebAnimationsPlayer": () => (/* binding */ WebAnimationsPlayer),
+/* harmony export */ "ɵWebAnimationsStyleNormalizer": () => (/* binding */ WebAnimationsStyleNormalizer),
+/* harmony export */ "ɵallowPreviousPlayerStylesMerge": () => (/* binding */ allowPreviousPlayerStylesMerge),
+/* harmony export */ "ɵcontainsElement": () => (/* binding */ containsElement),
+/* harmony export */ "ɵgetParentElement": () => (/* binding */ getParentElement),
+/* harmony export */ "ɵinvokeQuery": () => (/* binding */ invokeQuery),
+/* harmony export */ "ɵnormalizeKeyframes": () => (/* binding */ normalizeKeyframes),
+/* harmony export */ "ɵvalidateStyleProperty": () => (/* binding */ validateStyleProperty)
+/* harmony export */ });
+/* harmony import */ var _angular_animations__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @angular/animations */ 4851);
+/* harmony import */ var _angular_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @angular/core */ 2560);
+/**
+ * @license Angular v14.3.0
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+
+
+/**
+ * @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.io/license
+ */
+
+const LINE_START = '\n - ';
+
+function invalidTimingValue(exp) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3000
+ /* RuntimeErrorCode.INVALID_TIMING_VALUE */
+ , ngDevMode && `The provided timing value "${exp}" is invalid.`);
+}
+
+function negativeStepValue() {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3100
+ /* RuntimeErrorCode.NEGATIVE_STEP_VALUE */
+ , ngDevMode && 'Duration values below 0 are not allowed for this animation step.');
+}
+
+function negativeDelayValue() {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3101
+ /* RuntimeErrorCode.NEGATIVE_DELAY_VALUE */
+ , ngDevMode && 'Delay values below 0 are not allowed for this animation step.');
+}
+
+function invalidStyleParams(varName) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3001
+ /* RuntimeErrorCode.INVALID_STYLE_PARAMS */
+ , ngDevMode && `Unable to resolve the local animation param ${varName} in the given list of values`);
+}
+
+function invalidParamValue(varName) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3003
+ /* RuntimeErrorCode.INVALID_PARAM_VALUE */
+ , ngDevMode && `Please provide a value for the animation param ${varName}`);
+}
+
+function invalidNodeType(nodeType) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3004
+ /* RuntimeErrorCode.INVALID_NODE_TYPE */
+ , ngDevMode && `Unable to resolve animation metadata node #${nodeType}`);
+}
+
+function invalidCssUnitValue(userProvidedProperty, value) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3005
+ /* RuntimeErrorCode.INVALID_CSS_UNIT_VALUE */
+ , ngDevMode && `Please provide a CSS unit value for ${userProvidedProperty}:${value}`);
+}
+
+function invalidTrigger() {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3006
+ /* RuntimeErrorCode.INVALID_TRIGGER */
+ , ngDevMode && 'animation triggers cannot be prefixed with an `@` sign (e.g. trigger(\'@foo\', [...]))');
+}
+
+function invalidDefinition() {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3007
+ /* RuntimeErrorCode.INVALID_DEFINITION */
+ , ngDevMode && 'only state() and transition() definitions can sit inside of a trigger()');
+}
+
+function invalidState(metadataName, missingSubs) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3008
+ /* RuntimeErrorCode.INVALID_STATE */
+ , ngDevMode && `state("${metadataName}", ...) must define default values for all the following style substitutions: ${missingSubs.join(', ')}`);
+}
+
+function invalidStyleValue(value) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3002
+ /* RuntimeErrorCode.INVALID_STYLE_VALUE */
+ , ngDevMode && `The provided style string value ${value} is not allowed.`);
+}
+
+function invalidProperty(prop) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3009
+ /* RuntimeErrorCode.INVALID_PROPERTY */
+ , ngDevMode && `The provided animation property "${prop}" is not a supported CSS property for animations`);
+}
+
+function invalidParallelAnimation(prop, firstStart, firstEnd, secondStart, secondEnd) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3010
+ /* RuntimeErrorCode.INVALID_PARALLEL_ANIMATION */
+ , ngDevMode && `The CSS property "${prop}" that exists between the times of "${firstStart}ms" and "${firstEnd}ms" is also being animated in a parallel animation between the times of "${secondStart}ms" and "${secondEnd}ms"`);
+}
+
+function invalidKeyframes() {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3011
+ /* RuntimeErrorCode.INVALID_KEYFRAMES */
+ , ngDevMode && `keyframes() must be placed inside of a call to animate()`);
+}
+
+function invalidOffset() {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3012
+ /* RuntimeErrorCode.INVALID_OFFSET */
+ , ngDevMode && `Please ensure that all keyframe offsets are between 0 and 1`);
+}
+
+function keyframeOffsetsOutOfOrder() {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3200
+ /* RuntimeErrorCode.KEYFRAME_OFFSETS_OUT_OF_ORDER */
+ , ngDevMode && `Please ensure that all keyframe offsets are in order`);
+}
+
+function keyframesMissingOffsets() {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3202
+ /* RuntimeErrorCode.KEYFRAMES_MISSING_OFFSETS */
+ , ngDevMode && `Not all style() steps within the declared keyframes() contain offsets`);
+}
+
+function invalidStagger() {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3013
+ /* RuntimeErrorCode.INVALID_STAGGER */
+ , ngDevMode && `stagger() can only be used inside of query()`);
+}
+
+function invalidQuery(selector) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3014
+ /* RuntimeErrorCode.INVALID_QUERY */
+ , ngDevMode && `\`query("${selector}")\` returned zero elements. (Use \`query("${selector}", { optional: true })\` if you wish to allow this.)`);
+}
+
+function invalidExpression(expr) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3015
+ /* RuntimeErrorCode.INVALID_EXPRESSION */
+ , ngDevMode && `The provided transition expression "${expr}" is not supported`);
+}
+
+function invalidTransitionAlias(alias) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3016
+ /* RuntimeErrorCode.INVALID_TRANSITION_ALIAS */
+ , ngDevMode && `The transition alias value "${alias}" is not supported`);
+}
+
+function validationFailed(errors) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3500
+ /* RuntimeErrorCode.VALIDATION_FAILED */
+ , ngDevMode && `animation validation failed:\n${errors.map(err => err.message).join('\n')}`);
+}
+
+function buildingFailed(errors) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3501
+ /* RuntimeErrorCode.BUILDING_FAILED */
+ , ngDevMode && `animation building failed:\n${errors.map(err => err.message).join('\n')}`);
+}
+
+function triggerBuildFailed(name, errors) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3404
+ /* RuntimeErrorCode.TRIGGER_BUILD_FAILED */
+ , ngDevMode && `The animation trigger "${name}" has failed to build due to the following errors:\n - ${errors.map(err => err.message).join('\n - ')}`);
+}
+
+function animationFailed(errors) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3502
+ /* RuntimeErrorCode.ANIMATION_FAILED */
+ , ngDevMode && `Unable to animate due to the following errors:${LINE_START}${errors.map(err => err.message).join(LINE_START)}`);
+}
+
+function registerFailed(errors) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3503
+ /* RuntimeErrorCode.REGISTRATION_FAILED */
+ , ngDevMode && `Unable to build the animation due to the following errors: ${errors.map(err => err.message).join('\n')}`);
+}
+
+function missingOrDestroyedAnimation() {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3300
+ /* RuntimeErrorCode.MISSING_OR_DESTROYED_ANIMATION */
+ , ngDevMode && 'The requested animation doesn\'t exist or has already been destroyed');
+}
+
+function createAnimationFailed(errors) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3504
+ /* RuntimeErrorCode.CREATE_ANIMATION_FAILED */
+ , ngDevMode && `Unable to create the animation due to the following errors:${errors.map(err => err.message).join('\n')}`);
+}
+
+function missingPlayer(id) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3301
+ /* RuntimeErrorCode.MISSING_PLAYER */
+ , ngDevMode && `Unable to find the timeline player referenced by ${id}`);
+}
+
+function missingTrigger(phase, name) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3302
+ /* RuntimeErrorCode.MISSING_TRIGGER */
+ , ngDevMode && `Unable to listen on the animation trigger event "${phase}" because the animation trigger "${name}" doesn\'t exist!`);
+}
+
+function missingEvent(name) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3303
+ /* RuntimeErrorCode.MISSING_EVENT */
+ , ngDevMode && `Unable to listen on the animation trigger "${name}" because the provided event is undefined!`);
+}
+
+function unsupportedTriggerEvent(phase, name) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3400
+ /* RuntimeErrorCode.UNSUPPORTED_TRIGGER_EVENT */
+ , ngDevMode && `The provided animation trigger event "${phase}" for the animation trigger "${name}" is not supported!`);
+}
+
+function unregisteredTrigger(name) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3401
+ /* RuntimeErrorCode.UNREGISTERED_TRIGGER */
+ , ngDevMode && `The provided animation trigger "${name}" has not been registered!`);
+}
+
+function triggerTransitionsFailed(errors) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3402
+ /* RuntimeErrorCode.TRIGGER_TRANSITIONS_FAILED */
+ , ngDevMode && `Unable to process animations due to the following failed trigger transitions\n ${errors.map(err => err.message).join('\n')}`);
+}
+
+function triggerParsingFailed(name, errors) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3403
+ /* RuntimeErrorCode.TRIGGER_PARSING_FAILED */
+ , ngDevMode && `Animation parsing for the ${name} trigger have failed:${LINE_START}${errors.map(err => err.message).join(LINE_START)}`);
+}
+
+function transitionFailed(name, errors) {
+ return new _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵRuntimeError"](3505
+ /* RuntimeErrorCode.TRANSITION_FAILED */
+ , ngDevMode && `@${name} has failed due to:\n ${errors.map(err => err.message).join('\n- ')}`);
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * Set of all animatable CSS properties
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_animated_properties
+ */
+
+
+const ANIMATABLE_PROP_SET = new Set(['-moz-outline-radius', '-moz-outline-radius-bottomleft', '-moz-outline-radius-bottomright', '-moz-outline-radius-topleft', '-moz-outline-radius-topright', '-ms-grid-columns', '-ms-grid-rows', '-webkit-line-clamp', '-webkit-text-fill-color', '-webkit-text-stroke', '-webkit-text-stroke-color', 'accent-color', 'all', 'backdrop-filter', 'background', 'background-color', 'background-position', 'background-size', 'block-size', 'border', 'border-block-end', 'border-block-end-color', 'border-block-end-width', 'border-block-start', 'border-block-start-color', 'border-block-start-width', 'border-bottom', 'border-bottom-color', 'border-bottom-left-radius', 'border-bottom-right-radius', 'border-bottom-width', 'border-color', 'border-end-end-radius', 'border-end-start-radius', 'border-image-outset', 'border-image-slice', 'border-image-width', 'border-inline-end', 'border-inline-end-color', 'border-inline-end-width', 'border-inline-start', 'border-inline-start-color', 'border-inline-start-width', 'border-left', 'border-left-color', 'border-left-width', 'border-radius', 'border-right', 'border-right-color', 'border-right-width', 'border-start-end-radius', 'border-start-start-radius', 'border-top', 'border-top-color', 'border-top-left-radius', 'border-top-right-radius', 'border-top-width', 'border-width', 'bottom', 'box-shadow', 'caret-color', 'clip', 'clip-path', 'color', 'column-count', 'column-gap', 'column-rule', 'column-rule-color', 'column-rule-width', 'column-width', 'columns', 'filter', 'flex', 'flex-basis', 'flex-grow', 'flex-shrink', 'font', 'font-size', 'font-size-adjust', 'font-stretch', 'font-variation-settings', 'font-weight', 'gap', 'grid-column-gap', 'grid-gap', 'grid-row-gap', 'grid-template-columns', 'grid-template-rows', 'height', 'inline-size', 'input-security', 'inset', 'inset-block', 'inset-block-end', 'inset-block-start', 'inset-inline', 'inset-inline-end', 'inset-inline-start', 'left', 'letter-spacing', 'line-clamp', 'line-height', 'margin', 'margin-block-end', 'margin-block-start', 'margin-bottom', 'margin-inline-end', 'margin-inline-start', 'margin-left', 'margin-right', 'margin-top', 'mask', 'mask-border', 'mask-position', 'mask-size', 'max-block-size', 'max-height', 'max-inline-size', 'max-lines', 'max-width', 'min-block-size', 'min-height', 'min-inline-size', 'min-width', 'object-position', 'offset', 'offset-anchor', 'offset-distance', 'offset-path', 'offset-position', 'offset-rotate', 'opacity', 'order', 'outline', 'outline-color', 'outline-offset', 'outline-width', 'padding', 'padding-block-end', 'padding-block-start', 'padding-bottom', 'padding-inline-end', 'padding-inline-start', 'padding-left', 'padding-right', 'padding-top', 'perspective', 'perspective-origin', 'right', 'rotate', 'row-gap', 'scale', 'scroll-margin', 'scroll-margin-block', 'scroll-margin-block-end', 'scroll-margin-block-start', 'scroll-margin-bottom', 'scroll-margin-inline', 'scroll-margin-inline-end', 'scroll-margin-inline-start', 'scroll-margin-left', 'scroll-margin-right', 'scroll-margin-top', 'scroll-padding', 'scroll-padding-block', 'scroll-padding-block-end', 'scroll-padding-block-start', 'scroll-padding-bottom', 'scroll-padding-inline', 'scroll-padding-inline-end', 'scroll-padding-inline-start', 'scroll-padding-left', 'scroll-padding-right', 'scroll-padding-top', 'scroll-snap-coordinate', 'scroll-snap-destination', 'scrollbar-color', 'shape-image-threshold', 'shape-margin', 'shape-outside', 'tab-size', 'text-decoration', 'text-decoration-color', 'text-decoration-thickness', 'text-emphasis', 'text-emphasis-color', 'text-indent', 'text-shadow', 'text-underline-offset', 'top', 'transform', 'transform-origin', 'translate', 'vertical-align', 'visibility', 'width', 'word-spacing', 'z-index', 'zoom']);
+/**
+ * @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.io/license
+ */
+
+function isBrowser() {
+ return typeof window !== 'undefined' && typeof window.document !== 'undefined';
+}
+
+function isNode() {
+ // Checking only for `process` isn't enough to identify whether or not we're in a Node
+ // environment, because Webpack by default will polyfill the `process`. While we can discern
+ // that Webpack polyfilled it by looking at `process.browser`, it's very Webpack-specific and
+ // might not be future-proof. Instead we look at the stringified version of `process` which
+ // is `[object process]` in Node and `[object Object]` when polyfilled.
+ return typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
+}
+
+function optimizeGroupPlayer(players) {
+ switch (players.length) {
+ case 0:
+ return new _angular_animations__WEBPACK_IMPORTED_MODULE_1__.NoopAnimationPlayer();
+
+ case 1:
+ return players[0];
+
+ default:
+ return new _angular_animations__WEBPACK_IMPORTED_MODULE_1__["ɵAnimationGroupPlayer"](players);
+ }
+}
+
+function normalizeKeyframes$1(driver, normalizer, element, keyframes, preStyles = new Map(), postStyles = new Map()) {
+ const errors = [];
+ const normalizedKeyframes = [];
+ let previousOffset = -1;
+ let previousKeyframe = null;
+ keyframes.forEach(kf => {
+ const offset = kf.get('offset');
+ const isSameOffset = offset == previousOffset;
+ const normalizedKeyframe = isSameOffset && previousKeyframe || new Map();
+ kf.forEach((val, prop) => {
+ let normalizedProp = prop;
+ let normalizedValue = val;
+
+ if (prop !== 'offset') {
+ normalizedProp = normalizer.normalizePropertyName(normalizedProp, errors);
+
+ switch (normalizedValue) {
+ case _angular_animations__WEBPACK_IMPORTED_MODULE_1__["ɵPRE_STYLE"]:
+ normalizedValue = preStyles.get(prop);
+ break;
+
+ case _angular_animations__WEBPACK_IMPORTED_MODULE_1__.AUTO_STYLE:
+ normalizedValue = postStyles.get(prop);
+ break;
+
+ default:
+ normalizedValue = normalizer.normalizeStyleValue(prop, normalizedProp, normalizedValue, errors);
+ break;
+ }
+ }
+
+ normalizedKeyframe.set(normalizedProp, normalizedValue);
+ });
+
+ if (!isSameOffset) {
+ normalizedKeyframes.push(normalizedKeyframe);
+ }
+
+ previousKeyframe = normalizedKeyframe;
+ previousOffset = offset;
+ });
+
+ if (errors.length) {
+ throw animationFailed(errors);
+ }
+
+ return normalizedKeyframes;
+}
+
+function listenOnPlayer(player, eventName, event, callback) {
+ switch (eventName) {
+ case 'start':
+ player.onStart(() => callback(event && copyAnimationEvent(event, 'start', player)));
+ break;
+
+ case 'done':
+ player.onDone(() => callback(event && copyAnimationEvent(event, 'done', player)));
+ break;
+
+ case 'destroy':
+ player.onDestroy(() => callback(event && copyAnimationEvent(event, 'destroy', player)));
+ break;
+ }
+}
+
+function copyAnimationEvent(e, phaseName, player) {
+ const totalTime = player.totalTime;
+ const disabled = player.disabled ? true : false;
+ const event = makeAnimationEvent(e.element, e.triggerName, e.fromState, e.toState, phaseName || e.phaseName, totalTime == undefined ? e.totalTime : totalTime, disabled);
+ const data = e['_data'];
+
+ if (data != null) {
+ event['_data'] = data;
+ }
+
+ return event;
+}
+
+function makeAnimationEvent(element, triggerName, fromState, toState, phaseName = '', totalTime = 0, disabled) {
+ return {
+ element,
+ triggerName,
+ fromState,
+ toState,
+ phaseName,
+ totalTime,
+ disabled: !!disabled
+ };
+}
+
+function getOrSetDefaultValue(map, key, defaultValue) {
+ let value = map.get(key);
+
+ if (!value) {
+ map.set(key, value = defaultValue);
+ }
+
+ return value;
+}
+
+function parseTimelineCommand(command) {
+ const separatorPos = command.indexOf(':');
+ const id = command.substring(1, separatorPos);
+ const action = command.slice(separatorPos + 1);
+ return [id, action];
+}
+
+let _contains = (elm1, elm2) => false;
+
+let _query = (element, selector, multi) => {
+ return [];
+};
+
+let _documentElement = null;
+
+function getParentElement(element) {
+ const parent = element.parentNode || element.host; // consider host to support shadow DOM
+
+ if (parent === _documentElement) {
+ return null;
+ }
+
+ return parent;
+} // Define utility methods for browsers and platform-server(domino) where Element
+// and utility methods exist.
+
+
+const _isNode = isNode();
+
+if (_isNode || typeof Element !== 'undefined') {
+ if (!isBrowser()) {
+ _contains = (elm1, elm2) => elm1.contains(elm2);
+ } else {
+ // Read the document element in an IIFE that's been marked pure to avoid a top-level property
+ // read that may prevent tree-shaking.
+ _documentElement = /* @__PURE__ */(() => document.documentElement)();
+
+ _contains = (elm1, elm2) => {
+ while (elm2) {
+ if (elm2 === elm1) {
+ return true;
+ }
+
+ elm2 = getParentElement(elm2);
+ }
+
+ return false;
+ };
+ }
+
+ _query = (element, selector, multi) => {
+ if (multi) {
+ return Array.from(element.querySelectorAll(selector));
+ }
+
+ const elem = element.querySelector(selector);
+ return elem ? [elem] : [];
+ };
+}
+
+function containsVendorPrefix(prop) {
+ // Webkit is the only real popular vendor prefix nowadays
+ // cc: http://shouldiprefix.com/
+ return prop.substring(1, 6) == 'ebkit'; // webkit or Webkit
+}
+
+let _CACHED_BODY = null;
+let _IS_WEBKIT = false;
+
+function validateStyleProperty(prop) {
+ if (!_CACHED_BODY) {
+ _CACHED_BODY = getBodyNode() || {};
+ _IS_WEBKIT = _CACHED_BODY.style ? 'WebkitAppearance' in _CACHED_BODY.style : false;
+ }
+
+ let result = true;
+
+ if (_CACHED_BODY.style && !containsVendorPrefix(prop)) {
+ result = prop in _CACHED_BODY.style;
+
+ if (!result && _IS_WEBKIT) {
+ const camelProp = 'Webkit' + prop.charAt(0).toUpperCase() + prop.slice(1);
+ result = camelProp in _CACHED_BODY.style;
+ }
+ }
+
+ return result;
+}
+
+function validateWebAnimatableStyleProperty(prop) {
+ return ANIMATABLE_PROP_SET.has(prop);
+}
+
+function getBodyNode() {
+ if (typeof document != 'undefined') {
+ return document.body;
+ }
+
+ return null;
+}
+
+const containsElement = _contains;
+const invokeQuery = _query;
+
+function hypenatePropsKeys(original) {
+ const newMap = new Map();
+ original.forEach((val, prop) => {
+ const newProp = prop.replace(/([a-z])([A-Z])/g, '$1-$2');
+ newMap.set(newProp, val);
+ });
+ return newMap;
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * @publicApi
+ */
+
+
+class NoopAnimationDriver {
+ validateStyleProperty(prop) {
+ return validateStyleProperty(prop);
+ }
+
+ matchesElement(_element, _selector) {
+ // This method is deprecated and no longer in use so we return false.
+ return false;
+ }
+
+ containsElement(elm1, elm2) {
+ return containsElement(elm1, elm2);
+ }
+
+ getParentElement(element) {
+ return getParentElement(element);
+ }
+
+ query(element, selector, multi) {
+ return invokeQuery(element, selector, multi);
+ }
+
+ computeStyle(element, prop, defaultValue) {
+ return defaultValue || '';
+ }
+
+ animate(element, keyframes, duration, delay, easing, previousPlayers = [], scrubberAccessRequested) {
+ return new _angular_animations__WEBPACK_IMPORTED_MODULE_1__.NoopAnimationPlayer(duration, delay);
+ }
+
+}
+
+NoopAnimationDriver.ɵfac = function NoopAnimationDriver_Factory(t) {
+ return new (t || NoopAnimationDriver)();
+};
+
+NoopAnimationDriver.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjectable"]({
+ token: NoopAnimationDriver,
+ factory: NoopAnimationDriver.ɵfac
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](NoopAnimationDriver, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Injectable
+ }], null, null);
+})();
+/**
+ * @publicApi
+ */
+
+
+class AnimationDriver {}
+
+AnimationDriver.NOOP = /* @__PURE__ */new NoopAnimationDriver();
+/**
+ * @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.io/license
+ */
+
+const ONE_SECOND = 1000;
+const SUBSTITUTION_EXPR_START = '{{';
+const SUBSTITUTION_EXPR_END = '}}';
+const ENTER_CLASSNAME = 'ng-enter';
+const LEAVE_CLASSNAME = 'ng-leave';
+const NG_TRIGGER_CLASSNAME = 'ng-trigger';
+const NG_TRIGGER_SELECTOR = '.ng-trigger';
+const NG_ANIMATING_CLASSNAME = 'ng-animating';
+const NG_ANIMATING_SELECTOR = '.ng-animating';
+
+function resolveTimingValue(value) {
+ if (typeof value == 'number') return value;
+ const matches = value.match(/^(-?[\.\d]+)(m?s)/);
+ if (!matches || matches.length < 2) return 0;
+ return _convertTimeValueToMS(parseFloat(matches[1]), matches[2]);
+}
+
+function _convertTimeValueToMS(value, unit) {
+ switch (unit) {
+ case 's':
+ return value * ONE_SECOND;
+
+ default:
+ // ms or something else
+ return value;
+ }
+}
+
+function resolveTiming(timings, errors, allowNegativeValues) {
+ return timings.hasOwnProperty('duration') ? timings : parseTimeExpression(timings, errors, allowNegativeValues);
+}
+
+function parseTimeExpression(exp, errors, allowNegativeValues) {
+ const regex = /^(-?[\.\d]+)(m?s)(?:\s+(-?[\.\d]+)(m?s))?(?:\s+([-a-z]+(?:\(.+?\))?))?$/i;
+ let duration;
+ let delay = 0;
+ let easing = '';
+
+ if (typeof exp === 'string') {
+ const matches = exp.match(regex);
+
+ if (matches === null) {
+ errors.push(invalidTimingValue(exp));
+ return {
+ duration: 0,
+ delay: 0,
+ easing: ''
+ };
+ }
+
+ duration = _convertTimeValueToMS(parseFloat(matches[1]), matches[2]);
+ const delayMatch = matches[3];
+
+ if (delayMatch != null) {
+ delay = _convertTimeValueToMS(parseFloat(delayMatch), matches[4]);
+ }
+
+ const easingVal = matches[5];
+
+ if (easingVal) {
+ easing = easingVal;
+ }
+ } else {
+ duration = exp;
+ }
+
+ if (!allowNegativeValues) {
+ let containsErrors = false;
+ let startIndex = errors.length;
+
+ if (duration < 0) {
+ errors.push(negativeStepValue());
+ containsErrors = true;
+ }
+
+ if (delay < 0) {
+ errors.push(negativeDelayValue());
+ containsErrors = true;
+ }
+
+ if (containsErrors) {
+ errors.splice(startIndex, 0, invalidTimingValue(exp));
+ }
+ }
+
+ return {
+ duration,
+ delay,
+ easing
+ };
+}
+
+function copyObj(obj, destination = {}) {
+ Object.keys(obj).forEach(prop => {
+ destination[prop] = obj[prop];
+ });
+ return destination;
+}
+
+function convertToMap(obj) {
+ const styleMap = new Map();
+ Object.keys(obj).forEach(prop => {
+ const val = obj[prop];
+ styleMap.set(prop, val);
+ });
+ return styleMap;
+}
+
+function normalizeKeyframes(keyframes) {
+ if (!keyframes.length) {
+ return [];
+ }
+
+ if (keyframes[0] instanceof Map) {
+ return keyframes;
+ }
+
+ return keyframes.map(kf => convertToMap(kf));
+}
+
+function normalizeStyles(styles) {
+ const normalizedStyles = new Map();
+
+ if (Array.isArray(styles)) {
+ styles.forEach(data => copyStyles(data, normalizedStyles));
+ } else {
+ copyStyles(styles, normalizedStyles);
+ }
+
+ return normalizedStyles;
+}
+
+function copyStyles(styles, destination = new Map(), backfill) {
+ if (backfill) {
+ for (let [prop, val] of backfill) {
+ destination.set(prop, val);
+ }
+ }
+
+ for (let [prop, val] of styles) {
+ destination.set(prop, val);
+ }
+
+ return destination;
+}
+
+function getStyleAttributeString(element, key, value) {
+ // Return the key-value pair string to be added to the style attribute for the
+ // given CSS style key.
+ if (value) {
+ return key + ':' + value + ';';
+ } else {
+ return '';
+ }
+}
+
+function writeStyleAttribute(element) {
+ // Read the style property of the element and manually reflect it to the
+ // style attribute. This is needed because Domino on platform-server doesn't
+ // understand the full set of allowed CSS properties and doesn't reflect some
+ // of them automatically.
+ let styleAttrValue = '';
+
+ for (let i = 0; i < element.style.length; i++) {
+ const key = element.style.item(i);
+ styleAttrValue += getStyleAttributeString(element, key, element.style.getPropertyValue(key));
+ }
+
+ for (const key in element.style) {
+ // Skip internal Domino properties that don't need to be reflected.
+ if (!element.style.hasOwnProperty(key) || key.startsWith('_')) {
+ continue;
+ }
+
+ const dashKey = camelCaseToDashCase(key);
+ styleAttrValue += getStyleAttributeString(element, dashKey, element.style[key]);
+ }
+
+ element.setAttribute('style', styleAttrValue);
+}
+
+function setStyles(element, styles, formerStyles) {
+ if (element['style']) {
+ styles.forEach((val, prop) => {
+ const camelProp = dashCaseToCamelCase(prop);
+
+ if (formerStyles && !formerStyles.has(prop)) {
+ formerStyles.set(prop, element.style[camelProp]);
+ }
+
+ element.style[camelProp] = val;
+ }); // On the server set the 'style' attribute since it's not automatically reflected.
+
+ if (isNode()) {
+ writeStyleAttribute(element);
+ }
+ }
+}
+
+function eraseStyles(element, styles) {
+ if (element['style']) {
+ styles.forEach((_, prop) => {
+ const camelProp = dashCaseToCamelCase(prop);
+ element.style[camelProp] = '';
+ }); // On the server set the 'style' attribute since it's not automatically reflected.
+
+ if (isNode()) {
+ writeStyleAttribute(element);
+ }
+ }
+}
+
+function normalizeAnimationEntry(steps) {
+ if (Array.isArray(steps)) {
+ if (steps.length == 1) return steps[0];
+ return (0,_angular_animations__WEBPACK_IMPORTED_MODULE_1__.sequence)(steps);
+ }
+
+ return steps;
+}
+
+function validateStyleParams(value, options, errors) {
+ const params = options.params || {};
+ const matches = extractStyleParams(value);
+
+ if (matches.length) {
+ matches.forEach(varName => {
+ if (!params.hasOwnProperty(varName)) {
+ errors.push(invalidStyleParams(varName));
+ }
+ });
+ }
+}
+
+const PARAM_REGEX = new RegExp(`${SUBSTITUTION_EXPR_START}\\s*(.+?)\\s*${SUBSTITUTION_EXPR_END}`, 'g');
+
+function extractStyleParams(value) {
+ let params = [];
+
+ if (typeof value === 'string') {
+ let match;
+
+ while (match = PARAM_REGEX.exec(value)) {
+ params.push(match[1]);
+ }
+
+ PARAM_REGEX.lastIndex = 0;
+ }
+
+ return params;
+}
+
+function interpolateParams(value, params, errors) {
+ const original = value.toString();
+ const str = original.replace(PARAM_REGEX, (_, varName) => {
+ let localVal = params[varName]; // this means that the value was never overridden by the data passed in by the user
+
+ if (localVal == null) {
+ errors.push(invalidParamValue(varName));
+ localVal = '';
+ }
+
+ return localVal.toString();
+ }); // we do this to assert that numeric values stay as they are
+
+ return str == original ? value : str;
+}
+
+function iteratorToArray(iterator) {
+ const arr = [];
+ let item = iterator.next();
+
+ while (!item.done) {
+ arr.push(item.value);
+ item = iterator.next();
+ }
+
+ return arr;
+}
+
+const DASH_CASE_REGEXP = /-+([a-z0-9])/g;
+
+function dashCaseToCamelCase(input) {
+ return input.replace(DASH_CASE_REGEXP, (...m) => m[1].toUpperCase());
+}
+
+function camelCaseToDashCase(input) {
+ return input.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}
+
+function allowPreviousPlayerStylesMerge(duration, delay) {
+ return duration === 0 || delay === 0;
+}
+
+function balancePreviousStylesIntoKeyframes(element, keyframes, previousStyles) {
+ if (previousStyles.size && keyframes.length) {
+ let startingKeyframe = keyframes[0];
+ let missingStyleProps = [];
+ previousStyles.forEach((val, prop) => {
+ if (!startingKeyframe.has(prop)) {
+ missingStyleProps.push(prop);
+ }
+
+ startingKeyframe.set(prop, val);
+ });
+
+ if (missingStyleProps.length) {
+ for (let i = 1; i < keyframes.length; i++) {
+ let kf = keyframes[i];
+ missingStyleProps.forEach(prop => kf.set(prop, computeStyle(element, prop)));
+ }
+ }
+ }
+
+ return keyframes;
+}
+
+function visitDslNode(visitor, node, context) {
+ switch (node.type) {
+ case 7
+ /* AnimationMetadataType.Trigger */
+ :
+ return visitor.visitTrigger(node, context);
+
+ case 0
+ /* AnimationMetadataType.State */
+ :
+ return visitor.visitState(node, context);
+
+ case 1
+ /* AnimationMetadataType.Transition */
+ :
+ return visitor.visitTransition(node, context);
+
+ case 2
+ /* AnimationMetadataType.Sequence */
+ :
+ return visitor.visitSequence(node, context);
+
+ case 3
+ /* AnimationMetadataType.Group */
+ :
+ return visitor.visitGroup(node, context);
+
+ case 4
+ /* AnimationMetadataType.Animate */
+ :
+ return visitor.visitAnimate(node, context);
+
+ case 5
+ /* AnimationMetadataType.Keyframes */
+ :
+ return visitor.visitKeyframes(node, context);
+
+ case 6
+ /* AnimationMetadataType.Style */
+ :
+ return visitor.visitStyle(node, context);
+
+ case 8
+ /* AnimationMetadataType.Reference */
+ :
+ return visitor.visitReference(node, context);
+
+ case 9
+ /* AnimationMetadataType.AnimateChild */
+ :
+ return visitor.visitAnimateChild(node, context);
+
+ case 10
+ /* AnimationMetadataType.AnimateRef */
+ :
+ return visitor.visitAnimateRef(node, context);
+
+ case 11
+ /* AnimationMetadataType.Query */
+ :
+ return visitor.visitQuery(node, context);
+
+ case 12
+ /* AnimationMetadataType.Stagger */
+ :
+ return visitor.visitStagger(node, context);
+
+ default:
+ throw invalidNodeType(node.type);
+ }
+}
+
+function computeStyle(element, prop) {
+ return window.getComputedStyle(element)[prop];
+}
+/**
+ * @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.io/license
+ */
+
+
+const NG_DEV_MODE = typeof ngDevMode === 'undefined' || !!ngDevMode;
+
+function createListOfWarnings(warnings) {
+ const LINE_START = '\n - ';
+ return `${LINE_START}${warnings.filter(Boolean).map(warning => warning).join(LINE_START)}`;
+}
+
+function warnValidation(warnings) {
+ NG_DEV_MODE && console.warn(`animation validation warnings:${createListOfWarnings(warnings)}`);
+}
+
+function warnTriggerBuild(name, warnings) {
+ NG_DEV_MODE && console.warn(`The animation trigger "${name}" has built with the following warnings:${createListOfWarnings(warnings)}`);
+}
+
+function warnRegister(warnings) {
+ NG_DEV_MODE && console.warn(`Animation built with the following warnings:${createListOfWarnings(warnings)}`);
+}
+
+function triggerParsingWarnings(name, warnings) {
+ NG_DEV_MODE && console.warn(`Animation parsing for the ${name} trigger presents the following warnings:${createListOfWarnings(warnings)}`);
+}
+
+function pushUnrecognizedPropertiesWarning(warnings, props) {
+ if (props.length) {
+ warnings.push(`The following provided properties are not recognized: ${props.join(', ')}`);
+ }
+}
+/**
+ * @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.io/license
+ */
+
+
+const ANY_STATE = '*';
+
+function parseTransitionExpr(transitionValue, errors) {
+ const expressions = [];
+
+ if (typeof transitionValue == 'string') {
+ transitionValue.split(/\s*,\s*/).forEach(str => parseInnerTransitionStr(str, expressions, errors));
+ } else {
+ expressions.push(transitionValue);
+ }
+
+ return expressions;
+}
+
+function parseInnerTransitionStr(eventStr, expressions, errors) {
+ if (eventStr[0] == ':') {
+ const result = parseAnimationAlias(eventStr, errors);
+
+ if (typeof result == 'function') {
+ expressions.push(result);
+ return;
+ }
+
+ eventStr = result;
+ }
+
+ const match = eventStr.match(/^(\*|[-\w]+)\s*()\s*(\*|[-\w]+)$/);
+
+ if (match == null || match.length < 4) {
+ errors.push(invalidExpression(eventStr));
+ return expressions;
+ }
+
+ const fromState = match[1];
+ const separator = match[2];
+ const toState = match[3];
+ expressions.push(makeLambdaFromStates(fromState, toState));
+ const isFullAnyStateExpr = fromState == ANY_STATE && toState == ANY_STATE;
+
+ if (separator[0] == '<' && !isFullAnyStateExpr) {
+ expressions.push(makeLambdaFromStates(toState, fromState));
+ }
+}
+
+function parseAnimationAlias(alias, errors) {
+ switch (alias) {
+ case ':enter':
+ return 'void => *';
+
+ case ':leave':
+ return '* => void';
+
+ case ':increment':
+ return (fromState, toState) => parseFloat(toState) > parseFloat(fromState);
+
+ case ':decrement':
+ return (fromState, toState) => parseFloat(toState) < parseFloat(fromState);
+
+ default:
+ errors.push(invalidTransitionAlias(alias));
+ return '* => *';
+ }
+} // DO NOT REFACTOR ... keep the follow set instantiations
+// with the values intact (closure compiler for some reason
+// removes follow-up lines that add the values outside of
+// the constructor...
+
+
+const TRUE_BOOLEAN_VALUES = new Set(['true', '1']);
+const FALSE_BOOLEAN_VALUES = new Set(['false', '0']);
+
+function makeLambdaFromStates(lhs, rhs) {
+ const LHS_MATCH_BOOLEAN = TRUE_BOOLEAN_VALUES.has(lhs) || FALSE_BOOLEAN_VALUES.has(lhs);
+ const RHS_MATCH_BOOLEAN = TRUE_BOOLEAN_VALUES.has(rhs) || FALSE_BOOLEAN_VALUES.has(rhs);
+ return (fromState, toState) => {
+ let lhsMatch = lhs == ANY_STATE || lhs == fromState;
+ let rhsMatch = rhs == ANY_STATE || rhs == toState;
+
+ if (!lhsMatch && LHS_MATCH_BOOLEAN && typeof fromState === 'boolean') {
+ lhsMatch = fromState ? TRUE_BOOLEAN_VALUES.has(lhs) : FALSE_BOOLEAN_VALUES.has(lhs);
+ }
+
+ if (!rhsMatch && RHS_MATCH_BOOLEAN && typeof toState === 'boolean') {
+ rhsMatch = toState ? TRUE_BOOLEAN_VALUES.has(rhs) : FALSE_BOOLEAN_VALUES.has(rhs);
+ }
+
+ return lhsMatch && rhsMatch;
+ };
+}
+/**
+ * @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.io/license
+ */
+
+
+const SELF_TOKEN = ':self';
+const SELF_TOKEN_REGEX = new RegExp(`\s*${SELF_TOKEN}\s*,?`, 'g');
+/*
+ * [Validation]
+ * The visitor code below will traverse the animation AST generated by the animation verb functions
+ * (the output is a tree of objects) and attempt to perform a series of validations on the data. The
+ * following corner-cases will be validated:
+ *
+ * 1. Overlap of animations
+ * Given that a CSS property cannot be animated in more than one place at the same time, it's
+ * important that this behavior is detected and validated. The way in which this occurs is that
+ * each time a style property is examined, a string-map containing the property will be updated with
+ * the start and end times for when the property is used within an animation step.
+ *
+ * If there are two or more parallel animations that are currently running (these are invoked by the
+ * group()) on the same element then the validator will throw an error. Since the start/end timing
+ * values are collected for each property then if the current animation step is animating the same
+ * property and its timing values fall anywhere into the window of time that the property is
+ * currently being animated within then this is what causes an error.
+ *
+ * 2. Timing values
+ * The validator will validate to see if a timing value of `duration delay easing` or
+ * `durationNumber` is valid or not.
+ *
+ * (note that upon validation the code below will replace the timing data with an object containing
+ * {duration,delay,easing}.
+ *
+ * 3. Offset Validation
+ * Each of the style() calls are allowed to have an offset value when placed inside of keyframes().
+ * Offsets within keyframes() are considered valid when:
+ *
+ * - No offsets are used at all
+ * - Each style() entry contains an offset value
+ * - Each offset is between 0 and 1
+ * - Each offset is greater to or equal than the previous one
+ *
+ * Otherwise an error will be thrown.
+ */
+
+function buildAnimationAst(driver, metadata, errors, warnings) {
+ return new AnimationAstBuilderVisitor(driver).build(metadata, errors, warnings);
+}
+
+const ROOT_SELECTOR = '';
+
+class AnimationAstBuilderVisitor {
+ constructor(_driver) {
+ this._driver = _driver;
+ }
+
+ build(metadata, errors, warnings) {
+ const context = new AnimationAstBuilderContext(errors);
+
+ this._resetContextStyleTimingState(context);
+
+ const ast = visitDslNode(this, normalizeAnimationEntry(metadata), context);
+
+ if (typeof ngDevMode === 'undefined' || ngDevMode) {
+ if (context.unsupportedCSSPropertiesFound.size) {
+ pushUnrecognizedPropertiesWarning(warnings, [...context.unsupportedCSSPropertiesFound.keys()]);
+ }
+ }
+
+ return ast;
+ }
+
+ _resetContextStyleTimingState(context) {
+ context.currentQuerySelector = ROOT_SELECTOR;
+ context.collectedStyles = new Map();
+ context.collectedStyles.set(ROOT_SELECTOR, new Map());
+ context.currentTime = 0;
+ }
+
+ visitTrigger(metadata, context) {
+ let queryCount = context.queryCount = 0;
+ let depCount = context.depCount = 0;
+ const states = [];
+ const transitions = [];
+
+ if (metadata.name.charAt(0) == '@') {
+ context.errors.push(invalidTrigger());
+ }
+
+ metadata.definitions.forEach(def => {
+ this._resetContextStyleTimingState(context);
+
+ if (def.type == 0
+ /* AnimationMetadataType.State */
+ ) {
+ const stateDef = def;
+ const name = stateDef.name;
+ name.toString().split(/\s*,\s*/).forEach(n => {
+ stateDef.name = n;
+ states.push(this.visitState(stateDef, context));
+ });
+ stateDef.name = name;
+ } else if (def.type == 1
+ /* AnimationMetadataType.Transition */
+ ) {
+ const transition = this.visitTransition(def, context);
+ queryCount += transition.queryCount;
+ depCount += transition.depCount;
+ transitions.push(transition);
+ } else {
+ context.errors.push(invalidDefinition());
+ }
+ });
+ return {
+ type: 7
+ /* AnimationMetadataType.Trigger */
+ ,
+ name: metadata.name,
+ states,
+ transitions,
+ queryCount,
+ depCount,
+ options: null
+ };
+ }
+
+ visitState(metadata, context) {
+ const styleAst = this.visitStyle(metadata.styles, context);
+ const astParams = metadata.options && metadata.options.params || null;
+
+ if (styleAst.containsDynamicStyles) {
+ const missingSubs = new Set();
+ const params = astParams || {};
+ styleAst.styles.forEach(style => {
+ if (style instanceof Map) {
+ style.forEach(value => {
+ extractStyleParams(value).forEach(sub => {
+ if (!params.hasOwnProperty(sub)) {
+ missingSubs.add(sub);
+ }
+ });
+ });
+ }
+ });
+
+ if (missingSubs.size) {
+ const missingSubsArr = iteratorToArray(missingSubs.values());
+ context.errors.push(invalidState(metadata.name, missingSubsArr));
+ }
+ }
+
+ return {
+ type: 0
+ /* AnimationMetadataType.State */
+ ,
+ name: metadata.name,
+ style: styleAst,
+ options: astParams ? {
+ params: astParams
+ } : null
+ };
+ }
+
+ visitTransition(metadata, context) {
+ context.queryCount = 0;
+ context.depCount = 0;
+ const animation = visitDslNode(this, normalizeAnimationEntry(metadata.animation), context);
+ const matchers = parseTransitionExpr(metadata.expr, context.errors);
+ return {
+ type: 1
+ /* AnimationMetadataType.Transition */
+ ,
+ matchers,
+ animation,
+ queryCount: context.queryCount,
+ depCount: context.depCount,
+ options: normalizeAnimationOptions(metadata.options)
+ };
+ }
+
+ visitSequence(metadata, context) {
+ return {
+ type: 2
+ /* AnimationMetadataType.Sequence */
+ ,
+ steps: metadata.steps.map(s => visitDslNode(this, s, context)),
+ options: normalizeAnimationOptions(metadata.options)
+ };
+ }
+
+ visitGroup(metadata, context) {
+ const currentTime = context.currentTime;
+ let furthestTime = 0;
+ const steps = metadata.steps.map(step => {
+ context.currentTime = currentTime;
+ const innerAst = visitDslNode(this, step, context);
+ furthestTime = Math.max(furthestTime, context.currentTime);
+ return innerAst;
+ });
+ context.currentTime = furthestTime;
+ return {
+ type: 3
+ /* AnimationMetadataType.Group */
+ ,
+ steps,
+ options: normalizeAnimationOptions(metadata.options)
+ };
+ }
+
+ visitAnimate(metadata, context) {
+ const timingAst = constructTimingAst(metadata.timings, context.errors);
+ context.currentAnimateTimings = timingAst;
+ let styleAst;
+ let styleMetadata = metadata.styles ? metadata.styles : (0,_angular_animations__WEBPACK_IMPORTED_MODULE_1__.style)({});
+
+ if (styleMetadata.type == 5
+ /* AnimationMetadataType.Keyframes */
+ ) {
+ styleAst = this.visitKeyframes(styleMetadata, context);
+ } else {
+ let styleMetadata = metadata.styles;
+ let isEmpty = false;
+
+ if (!styleMetadata) {
+ isEmpty = true;
+ const newStyleData = {};
+
+ if (timingAst.easing) {
+ newStyleData['easing'] = timingAst.easing;
+ }
+
+ styleMetadata = (0,_angular_animations__WEBPACK_IMPORTED_MODULE_1__.style)(newStyleData);
+ }
+
+ context.currentTime += timingAst.duration + timingAst.delay;
+
+ const _styleAst = this.visitStyle(styleMetadata, context);
+
+ _styleAst.isEmptyStep = isEmpty;
+ styleAst = _styleAst;
+ }
+
+ context.currentAnimateTimings = null;
+ return {
+ type: 4
+ /* AnimationMetadataType.Animate */
+ ,
+ timings: timingAst,
+ style: styleAst,
+ options: null
+ };
+ }
+
+ visitStyle(metadata, context) {
+ const ast = this._makeStyleAst(metadata, context);
+
+ this._validateStyleAst(ast, context);
+
+ return ast;
+ }
+
+ _makeStyleAst(metadata, context) {
+ const styles = [];
+ const metadataStyles = Array.isArray(metadata.styles) ? metadata.styles : [metadata.styles];
+
+ for (let styleTuple of metadataStyles) {
+ if (typeof styleTuple === 'string') {
+ if (styleTuple === _angular_animations__WEBPACK_IMPORTED_MODULE_1__.AUTO_STYLE) {
+ styles.push(styleTuple);
+ } else {
+ context.errors.push(invalidStyleValue(styleTuple));
+ }
+ } else {
+ styles.push(convertToMap(styleTuple));
+ }
+ }
+
+ let containsDynamicStyles = false;
+ let collectedEasing = null;
+ styles.forEach(styleData => {
+ if (styleData instanceof Map) {
+ if (styleData.has('easing')) {
+ collectedEasing = styleData.get('easing');
+ styleData.delete('easing');
+ }
+
+ if (!containsDynamicStyles) {
+ for (let value of styleData.values()) {
+ if (value.toString().indexOf(SUBSTITUTION_EXPR_START) >= 0) {
+ containsDynamicStyles = true;
+ break;
+ }
+ }
+ }
+ }
+ });
+ return {
+ type: 6
+ /* AnimationMetadataType.Style */
+ ,
+ styles,
+ easing: collectedEasing,
+ offset: metadata.offset,
+ containsDynamicStyles,
+ options: null
+ };
+ }
+
+ _validateStyleAst(ast, context) {
+ const timings = context.currentAnimateTimings;
+ let endTime = context.currentTime;
+ let startTime = context.currentTime;
+
+ if (timings && startTime > 0) {
+ startTime -= timings.duration + timings.delay;
+ }
+
+ ast.styles.forEach(tuple => {
+ if (typeof tuple === 'string') return;
+ tuple.forEach((value, prop) => {
+ if (typeof ngDevMode === 'undefined' || ngDevMode) {
+ if (!this._driver.validateStyleProperty(prop)) {
+ tuple.delete(prop);
+ context.unsupportedCSSPropertiesFound.add(prop);
+ return;
+ }
+ } // This is guaranteed to have a defined Map at this querySelector location making it
+ // safe to add the assertion here. It is set as a default empty map in prior methods.
+
+
+ const collectedStyles = context.collectedStyles.get(context.currentQuerySelector);
+ const collectedEntry = collectedStyles.get(prop);
+ let updateCollectedStyle = true;
+
+ if (collectedEntry) {
+ if (startTime != endTime && startTime >= collectedEntry.startTime && endTime <= collectedEntry.endTime) {
+ context.errors.push(invalidParallelAnimation(prop, collectedEntry.startTime, collectedEntry.endTime, startTime, endTime));
+ updateCollectedStyle = false;
+ } // we always choose the smaller start time value since we
+ // want to have a record of the entire animation window where
+ // the style property is being animated in between
+
+
+ startTime = collectedEntry.startTime;
+ }
+
+ if (updateCollectedStyle) {
+ collectedStyles.set(prop, {
+ startTime,
+ endTime
+ });
+ }
+
+ if (context.options) {
+ validateStyleParams(value, context.options, context.errors);
+ }
+ });
+ });
+ }
+
+ visitKeyframes(metadata, context) {
+ const ast = {
+ type: 5
+ /* AnimationMetadataType.Keyframes */
+ ,
+ styles: [],
+ options: null
+ };
+
+ if (!context.currentAnimateTimings) {
+ context.errors.push(invalidKeyframes());
+ return ast;
+ }
+
+ const MAX_KEYFRAME_OFFSET = 1;
+ let totalKeyframesWithOffsets = 0;
+ const offsets = [];
+ let offsetsOutOfOrder = false;
+ let keyframesOutOfRange = false;
+ let previousOffset = 0;
+ const keyframes = metadata.steps.map(styles => {
+ const style = this._makeStyleAst(styles, context);
+
+ let offsetVal = style.offset != null ? style.offset : consumeOffset(style.styles);
+ let offset = 0;
+
+ if (offsetVal != null) {
+ totalKeyframesWithOffsets++;
+ offset = style.offset = offsetVal;
+ }
+
+ keyframesOutOfRange = keyframesOutOfRange || offset < 0 || offset > 1;
+ offsetsOutOfOrder = offsetsOutOfOrder || offset < previousOffset;
+ previousOffset = offset;
+ offsets.push(offset);
+ return style;
+ });
+
+ if (keyframesOutOfRange) {
+ context.errors.push(invalidOffset());
+ }
+
+ if (offsetsOutOfOrder) {
+ context.errors.push(keyframeOffsetsOutOfOrder());
+ }
+
+ const length = metadata.steps.length;
+ let generatedOffset = 0;
+
+ if (totalKeyframesWithOffsets > 0 && totalKeyframesWithOffsets < length) {
+ context.errors.push(keyframesMissingOffsets());
+ } else if (totalKeyframesWithOffsets == 0) {
+ generatedOffset = MAX_KEYFRAME_OFFSET / (length - 1);
+ }
+
+ const limit = length - 1;
+ const currentTime = context.currentTime;
+ const currentAnimateTimings = context.currentAnimateTimings;
+ const animateDuration = currentAnimateTimings.duration;
+ keyframes.forEach((kf, i) => {
+ const offset = generatedOffset > 0 ? i == limit ? 1 : generatedOffset * i : offsets[i];
+ const durationUpToThisFrame = offset * animateDuration;
+ context.currentTime = currentTime + currentAnimateTimings.delay + durationUpToThisFrame;
+ currentAnimateTimings.duration = durationUpToThisFrame;
+
+ this._validateStyleAst(kf, context);
+
+ kf.offset = offset;
+ ast.styles.push(kf);
+ });
+ return ast;
+ }
+
+ visitReference(metadata, context) {
+ return {
+ type: 8
+ /* AnimationMetadataType.Reference */
+ ,
+ animation: visitDslNode(this, normalizeAnimationEntry(metadata.animation), context),
+ options: normalizeAnimationOptions(metadata.options)
+ };
+ }
+
+ visitAnimateChild(metadata, context) {
+ context.depCount++;
+ return {
+ type: 9
+ /* AnimationMetadataType.AnimateChild */
+ ,
+ options: normalizeAnimationOptions(metadata.options)
+ };
+ }
+
+ visitAnimateRef(metadata, context) {
+ return {
+ type: 10
+ /* AnimationMetadataType.AnimateRef */
+ ,
+ animation: this.visitReference(metadata.animation, context),
+ options: normalizeAnimationOptions(metadata.options)
+ };
+ }
+
+ visitQuery(metadata, context) {
+ const parentSelector = context.currentQuerySelector;
+ const options = metadata.options || {};
+ context.queryCount++;
+ context.currentQuery = metadata;
+ const [selector, includeSelf] = normalizeSelector(metadata.selector);
+ context.currentQuerySelector = parentSelector.length ? parentSelector + ' ' + selector : selector;
+ getOrSetDefaultValue(context.collectedStyles, context.currentQuerySelector, new Map());
+ const animation = visitDslNode(this, normalizeAnimationEntry(metadata.animation), context);
+ context.currentQuery = null;
+ context.currentQuerySelector = parentSelector;
+ return {
+ type: 11
+ /* AnimationMetadataType.Query */
+ ,
+ selector,
+ limit: options.limit || 0,
+ optional: !!options.optional,
+ includeSelf,
+ animation,
+ originalSelector: metadata.selector,
+ options: normalizeAnimationOptions(metadata.options)
+ };
+ }
+
+ visitStagger(metadata, context) {
+ if (!context.currentQuery) {
+ context.errors.push(invalidStagger());
+ }
+
+ const timings = metadata.timings === 'full' ? {
+ duration: 0,
+ delay: 0,
+ easing: 'full'
+ } : resolveTiming(metadata.timings, context.errors, true);
+ return {
+ type: 12
+ /* AnimationMetadataType.Stagger */
+ ,
+ animation: visitDslNode(this, normalizeAnimationEntry(metadata.animation), context),
+ timings,
+ options: null
+ };
+ }
+
+}
+
+function normalizeSelector(selector) {
+ const hasAmpersand = selector.split(/\s*,\s*/).find(token => token == SELF_TOKEN) ? true : false;
+
+ if (hasAmpersand) {
+ selector = selector.replace(SELF_TOKEN_REGEX, '');
+ } // Note: the :enter and :leave aren't normalized here since those
+ // selectors are filled in at runtime during timeline building
+
+
+ selector = selector.replace(/@\*/g, NG_TRIGGER_SELECTOR).replace(/@\w+/g, match => NG_TRIGGER_SELECTOR + '-' + match.slice(1)).replace(/:animating/g, NG_ANIMATING_SELECTOR);
+ return [selector, hasAmpersand];
+}
+
+function normalizeParams(obj) {
+ return obj ? copyObj(obj) : null;
+}
+
+class AnimationAstBuilderContext {
+ constructor(errors) {
+ this.errors = errors;
+ this.queryCount = 0;
+ this.depCount = 0;
+ this.currentTransition = null;
+ this.currentQuery = null;
+ this.currentQuerySelector = null;
+ this.currentAnimateTimings = null;
+ this.currentTime = 0;
+ this.collectedStyles = new Map();
+ this.options = null;
+ this.unsupportedCSSPropertiesFound = new Set();
+ }
+
+}
+
+function consumeOffset(styles) {
+ if (typeof styles == 'string') return null;
+ let offset = null;
+
+ if (Array.isArray(styles)) {
+ styles.forEach(styleTuple => {
+ if (styleTuple instanceof Map && styleTuple.has('offset')) {
+ const obj = styleTuple;
+ offset = parseFloat(obj.get('offset'));
+ obj.delete('offset');
+ }
+ });
+ } else if (styles instanceof Map && styles.has('offset')) {
+ const obj = styles;
+ offset = parseFloat(obj.get('offset'));
+ obj.delete('offset');
+ }
+
+ return offset;
+}
+
+function constructTimingAst(value, errors) {
+ if (value.hasOwnProperty('duration')) {
+ return value;
+ }
+
+ if (typeof value == 'number') {
+ const duration = resolveTiming(value, errors).duration;
+ return makeTimingAst(duration, 0, '');
+ }
+
+ const strValue = value;
+ const isDynamic = strValue.split(/\s+/).some(v => v.charAt(0) == '{' && v.charAt(1) == '{');
+
+ if (isDynamic) {
+ const ast = makeTimingAst(0, 0, '');
+ ast.dynamic = true;
+ ast.strValue = strValue;
+ return ast;
+ }
+
+ const timings = resolveTiming(strValue, errors);
+ return makeTimingAst(timings.duration, timings.delay, timings.easing);
+}
+
+function normalizeAnimationOptions(options) {
+ if (options) {
+ options = copyObj(options);
+
+ if (options['params']) {
+ options['params'] = normalizeParams(options['params']);
+ }
+ } else {
+ options = {};
+ }
+
+ return options;
+}
+
+function makeTimingAst(duration, delay, easing) {
+ return {
+ duration,
+ delay,
+ easing
+ };
+}
+
+function createTimelineInstruction(element, keyframes, preStyleProps, postStyleProps, duration, delay, easing = null, subTimeline = false) {
+ return {
+ type: 1
+ /* AnimationTransitionInstructionType.TimelineAnimation */
+ ,
+ element,
+ keyframes,
+ preStyleProps,
+ postStyleProps,
+ duration,
+ delay,
+ totalTime: duration + delay,
+ easing,
+ subTimeline
+ };
+}
+
+class ElementInstructionMap {
+ constructor() {
+ this._map = new Map();
+ }
+
+ get(element) {
+ return this._map.get(element) || [];
+ }
+
+ append(element, instructions) {
+ let existingInstructions = this._map.get(element);
+
+ if (!existingInstructions) {
+ this._map.set(element, existingInstructions = []);
+ }
+
+ existingInstructions.push(...instructions);
+ }
+
+ has(element) {
+ return this._map.has(element);
+ }
+
+ clear() {
+ this._map.clear();
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+
+const ONE_FRAME_IN_MILLISECONDS = 1;
+const ENTER_TOKEN = ':enter';
+const ENTER_TOKEN_REGEX = new RegExp(ENTER_TOKEN, 'g');
+const LEAVE_TOKEN = ':leave';
+const LEAVE_TOKEN_REGEX = new RegExp(LEAVE_TOKEN, 'g');
+/*
+ * The code within this file aims to generate web-animations-compatible keyframes from Angular's
+ * animation DSL code.
+ *
+ * The code below will be converted from:
+ *
+ * ```
+ * sequence([
+ * style({ opacity: 0 }),
+ * animate(1000, style({ opacity: 0 }))
+ * ])
+ * ```
+ *
+ * To:
+ * ```
+ * keyframes = [{ opacity: 0, offset: 0 }, { opacity: 1, offset: 1 }]
+ * duration = 1000
+ * delay = 0
+ * easing = ''
+ * ```
+ *
+ * For this operation to cover the combination of animation verbs (style, animate, group, etc...) a
+ * combination of AST traversal and merge-sort-like algorithms are used.
+ *
+ * [AST Traversal]
+ * Each of the animation verbs, when executed, will return an string-map object representing what
+ * type of action it is (style, animate, group, etc...) and the data associated with it. This means
+ * that when functional composition mix of these functions is evaluated (like in the example above)
+ * then it will end up producing a tree of objects representing the animation itself.
+ *
+ * When this animation object tree is processed by the visitor code below it will visit each of the
+ * verb statements within the visitor. And during each visit it will build the context of the
+ * animation keyframes by interacting with the `TimelineBuilder`.
+ *
+ * [TimelineBuilder]
+ * This class is responsible for tracking the styles and building a series of keyframe objects for a
+ * timeline between a start and end time. The builder starts off with an initial timeline and each
+ * time the AST comes across a `group()`, `keyframes()` or a combination of the two within a
+ * `sequence()` then it will generate a sub timeline for each step as well as a new one after
+ * they are complete.
+ *
+ * As the AST is traversed, the timing state on each of the timelines will be incremented. If a sub
+ * timeline was created (based on one of the cases above) then the parent timeline will attempt to
+ * merge the styles used within the sub timelines into itself (only with group() this will happen).
+ * This happens with a merge operation (much like how the merge works in mergeSort) and it will only
+ * copy the most recently used styles from the sub timelines into the parent timeline. This ensures
+ * that if the styles are used later on in another phase of the animation then they will be the most
+ * up-to-date values.
+ *
+ * [How Missing Styles Are Updated]
+ * Each timeline has a `backFill` property which is responsible for filling in new styles into
+ * already processed keyframes if a new style shows up later within the animation sequence.
+ *
+ * ```
+ * sequence([
+ * style({ width: 0 }),
+ * animate(1000, style({ width: 100 })),
+ * animate(1000, style({ width: 200 })),
+ * animate(1000, style({ width: 300 }))
+ * animate(1000, style({ width: 400, height: 400 })) // notice how `height` doesn't exist anywhere
+ * else
+ * ])
+ * ```
+ *
+ * What is happening here is that the `height` value is added later in the sequence, but is missing
+ * from all previous animation steps. Therefore when a keyframe is created it would also be missing
+ * from all previous keyframes up until where it is first used. For the timeline keyframe generation
+ * to properly fill in the style it will place the previous value (the value from the parent
+ * timeline) or a default value of `*` into the backFill map. The `copyStyles` method in util.ts
+ * handles propagating that backfill map to the styles object.
+ *
+ * When a sub-timeline is created it will have its own backFill property. This is done so that
+ * styles present within the sub-timeline do not accidentally seep into the previous/future timeline
+ * keyframes
+ *
+ * [Validation]
+ * The code in this file is not responsible for validation. That functionality happens with within
+ * the `AnimationValidatorVisitor` code.
+ */
+
+function buildAnimationTimelines(driver, rootElement, ast, enterClassName, leaveClassName, startingStyles = new Map(), finalStyles = new Map(), options, subInstructions, errors = []) {
+ return new AnimationTimelineBuilderVisitor().buildKeyframes(driver, rootElement, ast, enterClassName, leaveClassName, startingStyles, finalStyles, options, subInstructions, errors);
+}
+
+class AnimationTimelineBuilderVisitor {
+ buildKeyframes(driver, rootElement, ast, enterClassName, leaveClassName, startingStyles, finalStyles, options, subInstructions, errors = []) {
+ subInstructions = subInstructions || new ElementInstructionMap();
+ const context = new AnimationTimelineContext(driver, rootElement, subInstructions, enterClassName, leaveClassName, errors, []);
+ context.options = options;
+ const delay = options.delay ? resolveTimingValue(options.delay) : 0;
+ context.currentTimeline.delayNextStep(delay);
+ context.currentTimeline.setStyles([startingStyles], null, context.errors, options);
+ visitDslNode(this, ast, context); // this checks to see if an actual animation happened
+
+ const timelines = context.timelines.filter(timeline => timeline.containsAnimation()); // note: we just want to apply the final styles for the rootElement, so we do not
+ // just apply the styles to the last timeline but the last timeline which
+ // element is the root one (basically `*`-styles are replaced with the actual
+ // state style values only for the root element)
+
+ if (timelines.length && finalStyles.size) {
+ let lastRootTimeline;
+
+ for (let i = timelines.length - 1; i >= 0; i--) {
+ const timeline = timelines[i];
+
+ if (timeline.element === rootElement) {
+ lastRootTimeline = timeline;
+ break;
+ }
+ }
+
+ if (lastRootTimeline && !lastRootTimeline.allowOnlyTimelineStyles()) {
+ lastRootTimeline.setStyles([finalStyles], null, context.errors, options);
+ }
+ }
+
+ return timelines.length ? timelines.map(timeline => timeline.buildKeyframes()) : [createTimelineInstruction(rootElement, [], [], [], 0, delay, '', false)];
+ }
+
+ visitTrigger(ast, context) {// these values are not visited in this AST
+ }
+
+ visitState(ast, context) {// these values are not visited in this AST
+ }
+
+ visitTransition(ast, context) {// these values are not visited in this AST
+ }
+
+ visitAnimateChild(ast, context) {
+ const elementInstructions = context.subInstructions.get(context.element);
+
+ if (elementInstructions) {
+ const innerContext = context.createSubContext(ast.options);
+ const startTime = context.currentTimeline.currentTime;
+
+ const endTime = this._visitSubInstructions(elementInstructions, innerContext, innerContext.options);
+
+ if (startTime != endTime) {
+ // we do this on the upper context because we created a sub context for
+ // the sub child animations
+ context.transformIntoNewTimeline(endTime);
+ }
+ }
+
+ context.previousNode = ast;
+ }
+
+ visitAnimateRef(ast, context) {
+ const innerContext = context.createSubContext(ast.options);
+ innerContext.transformIntoNewTimeline();
+
+ this._applyAnimationRefDelays([ast.options, ast.animation.options], context, innerContext);
+
+ this.visitReference(ast.animation, innerContext);
+ context.transformIntoNewTimeline(innerContext.currentTimeline.currentTime);
+ context.previousNode = ast;
+ }
+
+ _applyAnimationRefDelays(animationsRefsOptions, context, innerContext) {
+ for (const animationRefOptions of animationsRefsOptions) {
+ const animationDelay = animationRefOptions?.delay;
+
+ if (animationDelay) {
+ const animationDelayValue = typeof animationDelay === 'number' ? animationDelay : resolveTimingValue(interpolateParams(animationDelay, animationRefOptions?.params ?? {}, context.errors));
+ innerContext.delayNextStep(animationDelayValue);
+ }
+ }
+ }
+
+ _visitSubInstructions(instructions, context, options) {
+ const startTime = context.currentTimeline.currentTime;
+ let furthestTime = startTime; // this is a special-case for when a user wants to skip a sub
+ // animation from being fired entirely.
+
+ const duration = options.duration != null ? resolveTimingValue(options.duration) : null;
+ const delay = options.delay != null ? resolveTimingValue(options.delay) : null;
+
+ if (duration !== 0) {
+ instructions.forEach(instruction => {
+ const instructionTimings = context.appendInstructionToTimeline(instruction, duration, delay);
+ furthestTime = Math.max(furthestTime, instructionTimings.duration + instructionTimings.delay);
+ });
+ }
+
+ return furthestTime;
+ }
+
+ visitReference(ast, context) {
+ context.updateOptions(ast.options, true);
+ visitDslNode(this, ast.animation, context);
+ context.previousNode = ast;
+ }
+
+ visitSequence(ast, context) {
+ const subContextCount = context.subContextCount;
+ let ctx = context;
+ const options = ast.options;
+
+ if (options && (options.params || options.delay)) {
+ ctx = context.createSubContext(options);
+ ctx.transformIntoNewTimeline();
+
+ if (options.delay != null) {
+ if (ctx.previousNode.type == 6
+ /* AnimationMetadataType.Style */
+ ) {
+ ctx.currentTimeline.snapshotCurrentStyles();
+ ctx.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;
+ }
+
+ const delay = resolveTimingValue(options.delay);
+ ctx.delayNextStep(delay);
+ }
+ }
+
+ if (ast.steps.length) {
+ ast.steps.forEach(s => visitDslNode(this, s, ctx)); // this is here just in case the inner steps only contain or end with a style() call
+
+ ctx.currentTimeline.applyStylesToKeyframe(); // this means that some animation function within the sequence
+ // ended up creating a sub timeline (which means the current
+ // timeline cannot overlap with the contents of the sequence)
+
+ if (ctx.subContextCount > subContextCount) {
+ ctx.transformIntoNewTimeline();
+ }
+ }
+
+ context.previousNode = ast;
+ }
+
+ visitGroup(ast, context) {
+ const innerTimelines = [];
+ let furthestTime = context.currentTimeline.currentTime;
+ const delay = ast.options && ast.options.delay ? resolveTimingValue(ast.options.delay) : 0;
+ ast.steps.forEach(s => {
+ const innerContext = context.createSubContext(ast.options);
+
+ if (delay) {
+ innerContext.delayNextStep(delay);
+ }
+
+ visitDslNode(this, s, innerContext);
+ furthestTime = Math.max(furthestTime, innerContext.currentTimeline.currentTime);
+ innerTimelines.push(innerContext.currentTimeline);
+ }); // this operation is run after the AST loop because otherwise
+ // if the parent timeline's collected styles were updated then
+ // it would pass in invalid data into the new-to-be forked items
+
+ innerTimelines.forEach(timeline => context.currentTimeline.mergeTimelineCollectedStyles(timeline));
+ context.transformIntoNewTimeline(furthestTime);
+ context.previousNode = ast;
+ }
+
+ _visitTiming(ast, context) {
+ if (ast.dynamic) {
+ const strValue = ast.strValue;
+ const timingValue = context.params ? interpolateParams(strValue, context.params, context.errors) : strValue;
+ return resolveTiming(timingValue, context.errors);
+ } else {
+ return {
+ duration: ast.duration,
+ delay: ast.delay,
+ easing: ast.easing
+ };
+ }
+ }
+
+ visitAnimate(ast, context) {
+ const timings = context.currentAnimateTimings = this._visitTiming(ast.timings, context);
+
+ const timeline = context.currentTimeline;
+
+ if (timings.delay) {
+ context.incrementTime(timings.delay);
+ timeline.snapshotCurrentStyles();
+ }
+
+ const style = ast.style;
+
+ if (style.type == 5
+ /* AnimationMetadataType.Keyframes */
+ ) {
+ this.visitKeyframes(style, context);
+ } else {
+ context.incrementTime(timings.duration);
+ this.visitStyle(style, context);
+ timeline.applyStylesToKeyframe();
+ }
+
+ context.currentAnimateTimings = null;
+ context.previousNode = ast;
+ }
+
+ visitStyle(ast, context) {
+ const timeline = context.currentTimeline;
+ const timings = context.currentAnimateTimings; // this is a special case for when a style() call
+ // directly follows an animate() call (but not inside of an animate() call)
+
+ if (!timings && timeline.hasCurrentStyleProperties()) {
+ timeline.forwardFrame();
+ }
+
+ const easing = timings && timings.easing || ast.easing;
+
+ if (ast.isEmptyStep) {
+ timeline.applyEmptyStep(easing);
+ } else {
+ timeline.setStyles(ast.styles, easing, context.errors, context.options);
+ }
+
+ context.previousNode = ast;
+ }
+
+ visitKeyframes(ast, context) {
+ const currentAnimateTimings = context.currentAnimateTimings;
+ const startTime = context.currentTimeline.duration;
+ const duration = currentAnimateTimings.duration;
+ const innerContext = context.createSubContext();
+ const innerTimeline = innerContext.currentTimeline;
+ innerTimeline.easing = currentAnimateTimings.easing;
+ ast.styles.forEach(step => {
+ const offset = step.offset || 0;
+ innerTimeline.forwardTime(offset * duration);
+ innerTimeline.setStyles(step.styles, step.easing, context.errors, context.options);
+ innerTimeline.applyStylesToKeyframe();
+ }); // this will ensure that the parent timeline gets all the styles from
+ // the child even if the new timeline below is not used
+
+ context.currentTimeline.mergeTimelineCollectedStyles(innerTimeline); // we do this because the window between this timeline and the sub timeline
+ // should ensure that the styles within are exactly the same as they were before
+
+ context.transformIntoNewTimeline(startTime + duration);
+ context.previousNode = ast;
+ }
+
+ visitQuery(ast, context) {
+ // in the event that the first step before this is a style step we need
+ // to ensure the styles are applied before the children are animated
+ const startTime = context.currentTimeline.currentTime;
+ const options = ast.options || {};
+ const delay = options.delay ? resolveTimingValue(options.delay) : 0;
+
+ if (delay && (context.previousNode.type === 6
+ /* AnimationMetadataType.Style */
+ || startTime == 0 && context.currentTimeline.hasCurrentStyleProperties())) {
+ context.currentTimeline.snapshotCurrentStyles();
+ context.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;
+ }
+
+ let furthestTime = startTime;
+ const elms = context.invokeQuery(ast.selector, ast.originalSelector, ast.limit, ast.includeSelf, options.optional ? true : false, context.errors);
+ context.currentQueryTotal = elms.length;
+ let sameElementTimeline = null;
+ elms.forEach((element, i) => {
+ context.currentQueryIndex = i;
+ const innerContext = context.createSubContext(ast.options, element);
+
+ if (delay) {
+ innerContext.delayNextStep(delay);
+ }
+
+ if (element === context.element) {
+ sameElementTimeline = innerContext.currentTimeline;
+ }
+
+ visitDslNode(this, ast.animation, innerContext); // this is here just incase the inner steps only contain or end
+ // with a style() call (which is here to signal that this is a preparatory
+ // call to style an element before it is animated again)
+
+ innerContext.currentTimeline.applyStylesToKeyframe();
+ const endTime = innerContext.currentTimeline.currentTime;
+ furthestTime = Math.max(furthestTime, endTime);
+ });
+ context.currentQueryIndex = 0;
+ context.currentQueryTotal = 0;
+ context.transformIntoNewTimeline(furthestTime);
+
+ if (sameElementTimeline) {
+ context.currentTimeline.mergeTimelineCollectedStyles(sameElementTimeline);
+ context.currentTimeline.snapshotCurrentStyles();
+ }
+
+ context.previousNode = ast;
+ }
+
+ visitStagger(ast, context) {
+ const parentContext = context.parentContext;
+ const tl = context.currentTimeline;
+ const timings = ast.timings;
+ const duration = Math.abs(timings.duration);
+ const maxTime = duration * (context.currentQueryTotal - 1);
+ let delay = duration * context.currentQueryIndex;
+ let staggerTransformer = timings.duration < 0 ? 'reverse' : timings.easing;
+
+ switch (staggerTransformer) {
+ case 'reverse':
+ delay = maxTime - delay;
+ break;
+
+ case 'full':
+ delay = parentContext.currentStaggerTime;
+ break;
+ }
+
+ const timeline = context.currentTimeline;
+
+ if (delay) {
+ timeline.delayNextStep(delay);
+ }
+
+ const startingTime = timeline.currentTime;
+ visitDslNode(this, ast.animation, context);
+ context.previousNode = ast; // time = duration + delay
+ // the reason why this computation is so complex is because
+ // the inner timeline may either have a delay value or a stretched
+ // keyframe depending on if a subtimeline is not used or is used.
+
+ parentContext.currentStaggerTime = tl.currentTime - startingTime + (tl.startTime - parentContext.currentTimeline.startTime);
+ }
+
+}
+
+const DEFAULT_NOOP_PREVIOUS_NODE = {};
+
+class AnimationTimelineContext {
+ constructor(_driver, element, subInstructions, _enterClassName, _leaveClassName, errors, timelines, initialTimeline) {
+ this._driver = _driver;
+ this.element = element;
+ this.subInstructions = subInstructions;
+ this._enterClassName = _enterClassName;
+ this._leaveClassName = _leaveClassName;
+ this.errors = errors;
+ this.timelines = timelines;
+ this.parentContext = null;
+ this.currentAnimateTimings = null;
+ this.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;
+ this.subContextCount = 0;
+ this.options = {};
+ this.currentQueryIndex = 0;
+ this.currentQueryTotal = 0;
+ this.currentStaggerTime = 0;
+ this.currentTimeline = initialTimeline || new TimelineBuilder(this._driver, element, 0);
+ timelines.push(this.currentTimeline);
+ }
+
+ get params() {
+ return this.options.params;
+ }
+
+ updateOptions(options, skipIfExists) {
+ if (!options) return;
+ const newOptions = options;
+ let optionsToUpdate = this.options; // NOTE: this will get patched up when other animation methods support duration overrides
+
+ if (newOptions.duration != null) {
+ optionsToUpdate.duration = resolveTimingValue(newOptions.duration);
+ }
+
+ if (newOptions.delay != null) {
+ optionsToUpdate.delay = resolveTimingValue(newOptions.delay);
+ }
+
+ const newParams = newOptions.params;
+
+ if (newParams) {
+ let paramsToUpdate = optionsToUpdate.params;
+
+ if (!paramsToUpdate) {
+ paramsToUpdate = this.options.params = {};
+ }
+
+ Object.keys(newParams).forEach(name => {
+ if (!skipIfExists || !paramsToUpdate.hasOwnProperty(name)) {
+ paramsToUpdate[name] = interpolateParams(newParams[name], paramsToUpdate, this.errors);
+ }
+ });
+ }
+ }
+
+ _copyOptions() {
+ const options = {};
+
+ if (this.options) {
+ const oldParams = this.options.params;
+
+ if (oldParams) {
+ const params = options['params'] = {};
+ Object.keys(oldParams).forEach(name => {
+ params[name] = oldParams[name];
+ });
+ }
+ }
+
+ return options;
+ }
+
+ createSubContext(options = null, element, newTime) {
+ const target = element || this.element;
+ const context = new AnimationTimelineContext(this._driver, target, this.subInstructions, this._enterClassName, this._leaveClassName, this.errors, this.timelines, this.currentTimeline.fork(target, newTime || 0));
+ context.previousNode = this.previousNode;
+ context.currentAnimateTimings = this.currentAnimateTimings;
+ context.options = this._copyOptions();
+ context.updateOptions(options);
+ context.currentQueryIndex = this.currentQueryIndex;
+ context.currentQueryTotal = this.currentQueryTotal;
+ context.parentContext = this;
+ this.subContextCount++;
+ return context;
+ }
+
+ transformIntoNewTimeline(newTime) {
+ this.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;
+ this.currentTimeline = this.currentTimeline.fork(this.element, newTime);
+ this.timelines.push(this.currentTimeline);
+ return this.currentTimeline;
+ }
+
+ appendInstructionToTimeline(instruction, duration, delay) {
+ const updatedTimings = {
+ duration: duration != null ? duration : instruction.duration,
+ delay: this.currentTimeline.currentTime + (delay != null ? delay : 0) + instruction.delay,
+ easing: ''
+ };
+ const builder = new SubTimelineBuilder(this._driver, instruction.element, instruction.keyframes, instruction.preStyleProps, instruction.postStyleProps, updatedTimings, instruction.stretchStartingKeyframe);
+ this.timelines.push(builder);
+ return updatedTimings;
+ }
+
+ incrementTime(time) {
+ this.currentTimeline.forwardTime(this.currentTimeline.duration + time);
+ }
+
+ delayNextStep(delay) {
+ // negative delays are not yet supported
+ if (delay > 0) {
+ this.currentTimeline.delayNextStep(delay);
+ }
+ }
+
+ invokeQuery(selector, originalSelector, limit, includeSelf, optional, errors) {
+ let results = [];
+
+ if (includeSelf) {
+ results.push(this.element);
+ }
+
+ if (selector.length > 0) {
+ // only if :self is used then the selector can be empty
+ selector = selector.replace(ENTER_TOKEN_REGEX, '.' + this._enterClassName);
+ selector = selector.replace(LEAVE_TOKEN_REGEX, '.' + this._leaveClassName);
+ const multi = limit != 1;
+
+ let elements = this._driver.query(this.element, selector, multi);
+
+ if (limit !== 0) {
+ elements = limit < 0 ? elements.slice(elements.length + limit, elements.length) : elements.slice(0, limit);
+ }
+
+ results.push(...elements);
+ }
+
+ if (!optional && results.length == 0) {
+ errors.push(invalidQuery(originalSelector));
+ }
+
+ return results;
+ }
+
+}
+
+class TimelineBuilder {
+ constructor(_driver, element, startTime, _elementTimelineStylesLookup) {
+ this._driver = _driver;
+ this.element = element;
+ this.startTime = startTime;
+ this._elementTimelineStylesLookup = _elementTimelineStylesLookup;
+ this.duration = 0;
+ this._previousKeyframe = new Map();
+ this._currentKeyframe = new Map();
+ this._keyframes = new Map();
+ this._styleSummary = new Map();
+ this._localTimelineStyles = new Map();
+ this._pendingStyles = new Map();
+ this._backFill = new Map();
+ this._currentEmptyStepKeyframe = null;
+
+ if (!this._elementTimelineStylesLookup) {
+ this._elementTimelineStylesLookup = new Map();
+ }
+
+ this._globalTimelineStyles = this._elementTimelineStylesLookup.get(element);
+
+ if (!this._globalTimelineStyles) {
+ this._globalTimelineStyles = this._localTimelineStyles;
+
+ this._elementTimelineStylesLookup.set(element, this._localTimelineStyles);
+ }
+
+ this._loadKeyframe();
+ }
+
+ containsAnimation() {
+ switch (this._keyframes.size) {
+ case 0:
+ return false;
+
+ case 1:
+ return this.hasCurrentStyleProperties();
+
+ default:
+ return true;
+ }
+ }
+
+ hasCurrentStyleProperties() {
+ return this._currentKeyframe.size > 0;
+ }
+
+ get currentTime() {
+ return this.startTime + this.duration;
+ }
+
+ delayNextStep(delay) {
+ // in the event that a style() step is placed right before a stagger()
+ // and that style() step is the very first style() value in the animation
+ // then we need to make a copy of the keyframe [0, copy, 1] so that the delay
+ // properly applies the style() values to work with the stagger...
+ const hasPreStyleStep = this._keyframes.size === 1 && this._pendingStyles.size;
+
+ if (this.duration || hasPreStyleStep) {
+ this.forwardTime(this.currentTime + delay);
+
+ if (hasPreStyleStep) {
+ this.snapshotCurrentStyles();
+ }
+ } else {
+ this.startTime += delay;
+ }
+ }
+
+ fork(element, currentTime) {
+ this.applyStylesToKeyframe();
+ return new TimelineBuilder(this._driver, element, currentTime || this.currentTime, this._elementTimelineStylesLookup);
+ }
+
+ _loadKeyframe() {
+ if (this._currentKeyframe) {
+ this._previousKeyframe = this._currentKeyframe;
+ }
+
+ this._currentKeyframe = this._keyframes.get(this.duration);
+
+ if (!this._currentKeyframe) {
+ this._currentKeyframe = new Map();
+
+ this._keyframes.set(this.duration, this._currentKeyframe);
+ }
+ }
+
+ forwardFrame() {
+ this.duration += ONE_FRAME_IN_MILLISECONDS;
+
+ this._loadKeyframe();
+ }
+
+ forwardTime(time) {
+ this.applyStylesToKeyframe();
+ this.duration = time;
+
+ this._loadKeyframe();
+ }
+
+ _updateStyle(prop, value) {
+ this._localTimelineStyles.set(prop, value);
+
+ this._globalTimelineStyles.set(prop, value);
+
+ this._styleSummary.set(prop, {
+ time: this.currentTime,
+ value
+ });
+ }
+
+ allowOnlyTimelineStyles() {
+ return this._currentEmptyStepKeyframe !== this._currentKeyframe;
+ }
+
+ applyEmptyStep(easing) {
+ if (easing) {
+ this._previousKeyframe.set('easing', easing);
+ } // special case for animate(duration):
+ // all missing styles are filled with a `*` value then
+ // if any destination styles are filled in later on the same
+ // keyframe then they will override the overridden styles
+ // We use `_globalTimelineStyles` here because there may be
+ // styles in previous keyframes that are not present in this timeline
+
+
+ for (let [prop, value] of this._globalTimelineStyles) {
+ this._backFill.set(prop, value || _angular_animations__WEBPACK_IMPORTED_MODULE_1__.AUTO_STYLE);
+
+ this._currentKeyframe.set(prop, _angular_animations__WEBPACK_IMPORTED_MODULE_1__.AUTO_STYLE);
+ }
+
+ this._currentEmptyStepKeyframe = this._currentKeyframe;
+ }
+
+ setStyles(input, easing, errors, options) {
+ if (easing) {
+ this._previousKeyframe.set('easing', easing);
+ }
+
+ const params = options && options.params || {};
+ const styles = flattenStyles(input, this._globalTimelineStyles);
+
+ for (let [prop, value] of styles) {
+ const val = interpolateParams(value, params, errors);
+
+ this._pendingStyles.set(prop, val);
+
+ if (!this._localTimelineStyles.has(prop)) {
+ this._backFill.set(prop, this._globalTimelineStyles.get(prop) ?? _angular_animations__WEBPACK_IMPORTED_MODULE_1__.AUTO_STYLE);
+ }
+
+ this._updateStyle(prop, val);
+ }
+ }
+
+ applyStylesToKeyframe() {
+ if (this._pendingStyles.size == 0) return;
+
+ this._pendingStyles.forEach((val, prop) => {
+ this._currentKeyframe.set(prop, val);
+ });
+
+ this._pendingStyles.clear();
+
+ this._localTimelineStyles.forEach((val, prop) => {
+ if (!this._currentKeyframe.has(prop)) {
+ this._currentKeyframe.set(prop, val);
+ }
+ });
+ }
+
+ snapshotCurrentStyles() {
+ for (let [prop, val] of this._localTimelineStyles) {
+ this._pendingStyles.set(prop, val);
+
+ this._updateStyle(prop, val);
+ }
+ }
+
+ getFinalKeyframe() {
+ return this._keyframes.get(this.duration);
+ }
+
+ get properties() {
+ const properties = [];
+
+ for (let prop in this._currentKeyframe) {
+ properties.push(prop);
+ }
+
+ return properties;
+ }
+
+ mergeTimelineCollectedStyles(timeline) {
+ timeline._styleSummary.forEach((details1, prop) => {
+ const details0 = this._styleSummary.get(prop);
+
+ if (!details0 || details1.time > details0.time) {
+ this._updateStyle(prop, details1.value);
+ }
+ });
+ }
+
+ buildKeyframes() {
+ this.applyStylesToKeyframe();
+ const preStyleProps = new Set();
+ const postStyleProps = new Set();
+ const isEmpty = this._keyframes.size === 1 && this.duration === 0;
+ let finalKeyframes = [];
+
+ this._keyframes.forEach((keyframe, time) => {
+ const finalKeyframe = copyStyles(keyframe, new Map(), this._backFill);
+ finalKeyframe.forEach((value, prop) => {
+ if (value === _angular_animations__WEBPACK_IMPORTED_MODULE_1__["ɵPRE_STYLE"]) {
+ preStyleProps.add(prop);
+ } else if (value === _angular_animations__WEBPACK_IMPORTED_MODULE_1__.AUTO_STYLE) {
+ postStyleProps.add(prop);
+ }
+ });
+
+ if (!isEmpty) {
+ finalKeyframe.set('offset', time / this.duration);
+ }
+
+ finalKeyframes.push(finalKeyframe);
+ });
+
+ const preProps = preStyleProps.size ? iteratorToArray(preStyleProps.values()) : [];
+ const postProps = postStyleProps.size ? iteratorToArray(postStyleProps.values()) : []; // special case for a 0-second animation (which is designed just to place styles onscreen)
+
+ if (isEmpty) {
+ const kf0 = finalKeyframes[0];
+ const kf1 = new Map(kf0);
+ kf0.set('offset', 0);
+ kf1.set('offset', 1);
+ finalKeyframes = [kf0, kf1];
+ }
+
+ return createTimelineInstruction(this.element, finalKeyframes, preProps, postProps, this.duration, this.startTime, this.easing, false);
+ }
+
+}
+
+class SubTimelineBuilder extends TimelineBuilder {
+ constructor(driver, element, keyframes, preStyleProps, postStyleProps, timings, _stretchStartingKeyframe = false) {
+ super(driver, element, timings.delay);
+ this.keyframes = keyframes;
+ this.preStyleProps = preStyleProps;
+ this.postStyleProps = postStyleProps;
+ this._stretchStartingKeyframe = _stretchStartingKeyframe;
+ this.timings = {
+ duration: timings.duration,
+ delay: timings.delay,
+ easing: timings.easing
+ };
+ }
+
+ containsAnimation() {
+ return this.keyframes.length > 1;
+ }
+
+ buildKeyframes() {
+ let keyframes = this.keyframes;
+ let {
+ delay,
+ duration,
+ easing
+ } = this.timings;
+
+ if (this._stretchStartingKeyframe && delay) {
+ const newKeyframes = [];
+ const totalTime = duration + delay;
+ const startingGap = delay / totalTime; // the original starting keyframe now starts once the delay is done
+
+ const newFirstKeyframe = copyStyles(keyframes[0]);
+ newFirstKeyframe.set('offset', 0);
+ newKeyframes.push(newFirstKeyframe);
+ const oldFirstKeyframe = copyStyles(keyframes[0]);
+ oldFirstKeyframe.set('offset', roundOffset(startingGap));
+ newKeyframes.push(oldFirstKeyframe);
+ /*
+ When the keyframe is stretched then it means that the delay before the animation
+ starts is gone. Instead the first keyframe is placed at the start of the animation
+ and it is then copied to where it starts when the original delay is over. This basically
+ means nothing animates during that delay, but the styles are still rendered. For this
+ to work the original offset values that exist in the original keyframes must be "warped"
+ so that they can take the new keyframe + delay into account.
+ delay=1000, duration=1000, keyframes = 0 .5 1
+ turns into
+ delay=0, duration=2000, keyframes = 0 .33 .66 1
+ */
+ // offsets between 1 ... n -1 are all warped by the keyframe stretch
+
+ const limit = keyframes.length - 1;
+
+ for (let i = 1; i <= limit; i++) {
+ let kf = copyStyles(keyframes[i]);
+ const oldOffset = kf.get('offset');
+ const timeAtKeyframe = delay + oldOffset * duration;
+ kf.set('offset', roundOffset(timeAtKeyframe / totalTime));
+ newKeyframes.push(kf);
+ } // the new starting keyframe should be added at the start
+
+
+ duration = totalTime;
+ delay = 0;
+ easing = '';
+ keyframes = newKeyframes;
+ }
+
+ return createTimelineInstruction(this.element, keyframes, this.preStyleProps, this.postStyleProps, duration, delay, easing, true);
+ }
+
+}
+
+function roundOffset(offset, decimalPoints = 3) {
+ const mult = Math.pow(10, decimalPoints - 1);
+ return Math.round(offset * mult) / mult;
+}
+
+function flattenStyles(input, allStyles) {
+ const styles = new Map();
+ let allProperties;
+ input.forEach(token => {
+ if (token === '*') {
+ allProperties = allProperties || allStyles.keys();
+
+ for (let prop of allProperties) {
+ styles.set(prop, _angular_animations__WEBPACK_IMPORTED_MODULE_1__.AUTO_STYLE);
+ }
+ } else {
+ copyStyles(token, styles);
+ }
+ });
+ return styles;
+}
+
+class Animation {
+ constructor(_driver, input) {
+ this._driver = _driver;
+ const errors = [];
+ const warnings = [];
+ const ast = buildAnimationAst(_driver, input, errors, warnings);
+
+ if (errors.length) {
+ throw validationFailed(errors);
+ }
+
+ if (warnings.length) {
+ warnValidation(warnings);
+ }
+
+ this._animationAst = ast;
+ }
+
+ buildTimelines(element, startingStyles, destinationStyles, options, subInstructions) {
+ const start = Array.isArray(startingStyles) ? normalizeStyles(startingStyles) : startingStyles;
+ const dest = Array.isArray(destinationStyles) ? normalizeStyles(destinationStyles) : destinationStyles;
+ const errors = [];
+ subInstructions = subInstructions || new ElementInstructionMap();
+ const result = buildAnimationTimelines(this._driver, element, this._animationAst, ENTER_CLASSNAME, LEAVE_CLASSNAME, start, dest, options, subInstructions, errors);
+
+ if (errors.length) {
+ throw buildingFailed(errors);
+ }
+
+ return result;
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * @publicApi
+ */
+
+
+class AnimationStyleNormalizer {}
+/**
+ * @publicApi
+ */
+
+
+class NoopAnimationStyleNormalizer {
+ normalizePropertyName(propertyName, errors) {
+ return propertyName;
+ }
+
+ normalizeStyleValue(userProvidedProperty, normalizedProperty, value, errors) {
+ return value;
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+
+const DIMENSIONAL_PROP_SET = new Set(['width', 'height', 'minWidth', 'minHeight', 'maxWidth', 'maxHeight', 'left', 'top', 'bottom', 'right', 'fontSize', 'outlineWidth', 'outlineOffset', 'paddingTop', 'paddingLeft', 'paddingBottom', 'paddingRight', 'marginTop', 'marginLeft', 'marginBottom', 'marginRight', 'borderRadius', 'borderWidth', 'borderTopWidth', 'borderLeftWidth', 'borderRightWidth', 'borderBottomWidth', 'textIndent', 'perspective']);
+
+class WebAnimationsStyleNormalizer extends AnimationStyleNormalizer {
+ normalizePropertyName(propertyName, errors) {
+ return dashCaseToCamelCase(propertyName);
+ }
+
+ normalizeStyleValue(userProvidedProperty, normalizedProperty, value, errors) {
+ let unit = '';
+ const strVal = value.toString().trim();
+
+ if (DIMENSIONAL_PROP_SET.has(normalizedProperty) && value !== 0 && value !== '0') {
+ if (typeof value === 'number') {
+ unit = 'px';
+ } else {
+ const valAndSuffixMatch = value.match(/^[+-]?[\d\.]+([a-z]*)$/);
+
+ if (valAndSuffixMatch && valAndSuffixMatch[1].length == 0) {
+ errors.push(invalidCssUnitValue(userProvidedProperty, value));
+ }
+ }
+ }
+
+ return strVal + unit;
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+
+function createTransitionInstruction(element, triggerName, fromState, toState, isRemovalTransition, fromStyles, toStyles, timelines, queriedElements, preStyleProps, postStyleProps, totalTime, errors) {
+ return {
+ type: 0
+ /* AnimationTransitionInstructionType.TransitionAnimation */
+ ,
+ element,
+ triggerName,
+ isRemovalTransition,
+ fromState,
+ fromStyles,
+ toState,
+ toStyles,
+ timelines,
+ queriedElements,
+ preStyleProps,
+ postStyleProps,
+ totalTime,
+ errors
+ };
+}
+
+const EMPTY_OBJECT = {};
+
+class AnimationTransitionFactory {
+ constructor(_triggerName, ast, _stateStyles) {
+ this._triggerName = _triggerName;
+ this.ast = ast;
+ this._stateStyles = _stateStyles;
+ }
+
+ match(currentState, nextState, element, params) {
+ return oneOrMoreTransitionsMatch(this.ast.matchers, currentState, nextState, element, params);
+ }
+
+ buildStyles(stateName, params, errors) {
+ let styler = this._stateStyles.get('*');
+
+ if (stateName !== undefined) {
+ styler = this._stateStyles.get(stateName?.toString()) || styler;
+ }
+
+ return styler ? styler.buildStyles(params, errors) : new Map();
+ }
+
+ build(driver, element, currentState, nextState, enterClassName, leaveClassName, currentOptions, nextOptions, subInstructions, skipAstBuild) {
+ const errors = [];
+ const transitionAnimationParams = this.ast.options && this.ast.options.params || EMPTY_OBJECT;
+ const currentAnimationParams = currentOptions && currentOptions.params || EMPTY_OBJECT;
+ const currentStateStyles = this.buildStyles(currentState, currentAnimationParams, errors);
+ const nextAnimationParams = nextOptions && nextOptions.params || EMPTY_OBJECT;
+ const nextStateStyles = this.buildStyles(nextState, nextAnimationParams, errors);
+ const queriedElements = new Set();
+ const preStyleMap = new Map();
+ const postStyleMap = new Map();
+ const isRemoval = nextState === 'void';
+ const animationOptions = {
+ params: applyParamDefaults(nextAnimationParams, transitionAnimationParams),
+ delay: this.ast.options?.delay
+ };
+ const timelines = skipAstBuild ? [] : buildAnimationTimelines(driver, element, this.ast.animation, enterClassName, leaveClassName, currentStateStyles, nextStateStyles, animationOptions, subInstructions, errors);
+ let totalTime = 0;
+ timelines.forEach(tl => {
+ totalTime = Math.max(tl.duration + tl.delay, totalTime);
+ });
+
+ if (errors.length) {
+ return createTransitionInstruction(element, this._triggerName, currentState, nextState, isRemoval, currentStateStyles, nextStateStyles, [], [], preStyleMap, postStyleMap, totalTime, errors);
+ }
+
+ timelines.forEach(tl => {
+ const elm = tl.element;
+ const preProps = getOrSetDefaultValue(preStyleMap, elm, new Set());
+ tl.preStyleProps.forEach(prop => preProps.add(prop));
+ const postProps = getOrSetDefaultValue(postStyleMap, elm, new Set());
+ tl.postStyleProps.forEach(prop => postProps.add(prop));
+
+ if (elm !== element) {
+ queriedElements.add(elm);
+ }
+ });
+
+ if (typeof ngDevMode === 'undefined' || ngDevMode) {
+ checkNonAnimatableInTimelines(timelines, this._triggerName, driver);
+ }
+
+ const queriedElementsList = iteratorToArray(queriedElements.values());
+ return createTransitionInstruction(element, this._triggerName, currentState, nextState, isRemoval, currentStateStyles, nextStateStyles, timelines, queriedElementsList, preStyleMap, postStyleMap, totalTime);
+ }
+
+}
+/**
+ * Checks inside a set of timelines if they try to animate a css property which is not considered
+ * animatable, in that case it prints a warning on the console.
+ * Besides that the function doesn't have any other effect.
+ *
+ * Note: this check is done here after the timelines are built instead of doing on a lower level so
+ * that we can make sure that the warning appears only once per instruction (we can aggregate here
+ * all the issues instead of finding them separately).
+ *
+ * @param timelines The built timelines for the current instruction.
+ * @param triggerName The name of the trigger for the current instruction.
+ * @param driver Animation driver used to perform the check.
+ *
+ */
+
+
+function checkNonAnimatableInTimelines(timelines, triggerName, driver) {
+ if (!driver.validateAnimatableStyleProperty) {
+ return;
+ }
+
+ const invalidNonAnimatableProps = new Set();
+ timelines.forEach(({
+ keyframes
+ }) => {
+ const nonAnimatablePropsInitialValues = new Map();
+ keyframes.forEach(keyframe => {
+ for (const [prop, value] of keyframe.entries()) {
+ if (!driver.validateAnimatableStyleProperty(prop)) {
+ if (nonAnimatablePropsInitialValues.has(prop) && !invalidNonAnimatableProps.has(prop)) {
+ const propInitialValue = nonAnimatablePropsInitialValues.get(prop);
+
+ if (propInitialValue !== value) {
+ invalidNonAnimatableProps.add(prop);
+ }
+ } else {
+ nonAnimatablePropsInitialValues.set(prop, value);
+ }
+ }
+ }
+ });
+ });
+
+ if (invalidNonAnimatableProps.size > 0) {
+ console.warn(`Warning: The animation trigger "${triggerName}" is attempting to animate the following` + ' not animatable properties: ' + Array.from(invalidNonAnimatableProps).join(', ') + '\n' + '(to check the list of all animatable properties visit https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_animated_properties)');
+ }
+}
+
+function oneOrMoreTransitionsMatch(matchFns, currentState, nextState, element, params) {
+ return matchFns.some(fn => fn(currentState, nextState, element, params));
+}
+
+function applyParamDefaults(userParams, defaults) {
+ const result = copyObj(defaults);
+
+ for (const key in userParams) {
+ if (userParams.hasOwnProperty(key) && userParams[key] != null) {
+ result[key] = userParams[key];
+ }
+ }
+
+ return result;
+}
+
+class AnimationStateStyles {
+ constructor(styles, defaultParams, normalizer) {
+ this.styles = styles;
+ this.defaultParams = defaultParams;
+ this.normalizer = normalizer;
+ }
+
+ buildStyles(params, errors) {
+ const finalStyles = new Map();
+ const combinedParams = copyObj(this.defaultParams);
+ Object.keys(params).forEach(key => {
+ const value = params[key];
+
+ if (value !== null) {
+ combinedParams[key] = value;
+ }
+ });
+ this.styles.styles.forEach(value => {
+ if (typeof value !== 'string') {
+ value.forEach((val, prop) => {
+ if (val) {
+ val = interpolateParams(val, combinedParams, errors);
+ }
+
+ const normalizedProp = this.normalizer.normalizePropertyName(prop, errors);
+ val = this.normalizer.normalizeStyleValue(prop, normalizedProp, val, errors);
+ finalStyles.set(normalizedProp, val);
+ });
+ }
+ });
+ return finalStyles;
+ }
+
+}
+
+function buildTrigger(name, ast, normalizer) {
+ return new AnimationTrigger(name, ast, normalizer);
+}
+
+class AnimationTrigger {
+ constructor(name, ast, _normalizer) {
+ this.name = name;
+ this.ast = ast;
+ this._normalizer = _normalizer;
+ this.transitionFactories = [];
+ this.states = new Map();
+ ast.states.forEach(ast => {
+ const defaultParams = ast.options && ast.options.params || {};
+ this.states.set(ast.name, new AnimationStateStyles(ast.style, defaultParams, _normalizer));
+ });
+ balanceProperties(this.states, 'true', '1');
+ balanceProperties(this.states, 'false', '0');
+ ast.transitions.forEach(ast => {
+ this.transitionFactories.push(new AnimationTransitionFactory(name, ast, this.states));
+ });
+ this.fallbackTransition = createFallbackTransition(name, this.states, this._normalizer);
+ }
+
+ get containsQueries() {
+ return this.ast.queryCount > 0;
+ }
+
+ matchTransition(currentState, nextState, element, params) {
+ const entry = this.transitionFactories.find(f => f.match(currentState, nextState, element, params));
+ return entry || null;
+ }
+
+ matchStyles(currentState, params, errors) {
+ return this.fallbackTransition.buildStyles(currentState, params, errors);
+ }
+
+}
+
+function createFallbackTransition(triggerName, states, normalizer) {
+ const matchers = [(fromState, toState) => true];
+ const animation = {
+ type: 2
+ /* AnimationMetadataType.Sequence */
+ ,
+ steps: [],
+ options: null
+ };
+ const transition = {
+ type: 1
+ /* AnimationMetadataType.Transition */
+ ,
+ animation,
+ matchers,
+ options: null,
+ queryCount: 0,
+ depCount: 0
+ };
+ return new AnimationTransitionFactory(triggerName, transition, states);
+}
+
+function balanceProperties(stateMap, key1, key2) {
+ if (stateMap.has(key1)) {
+ if (!stateMap.has(key2)) {
+ stateMap.set(key2, stateMap.get(key1));
+ }
+ } else if (stateMap.has(key2)) {
+ stateMap.set(key1, stateMap.get(key2));
+ }
+}
+/**
+ * @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.io/license
+ */
+
+
+const EMPTY_INSTRUCTION_MAP = new ElementInstructionMap();
+
+class TimelineAnimationEngine {
+ constructor(bodyNode, _driver, _normalizer) {
+ this.bodyNode = bodyNode;
+ this._driver = _driver;
+ this._normalizer = _normalizer;
+ this._animations = new Map();
+ this._playersById = new Map();
+ this.players = [];
+ }
+
+ register(id, metadata) {
+ const errors = [];
+ const warnings = [];
+ const ast = buildAnimationAst(this._driver, metadata, errors, warnings);
+
+ if (errors.length) {
+ throw registerFailed(errors);
+ } else {
+ if (warnings.length) {
+ warnRegister(warnings);
+ }
+
+ this._animations.set(id, ast);
+ }
+ }
+
+ _buildPlayer(i, preStyles, postStyles) {
+ const element = i.element;
+ const keyframes = normalizeKeyframes$1(this._driver, this._normalizer, element, i.keyframes, preStyles, postStyles);
+ return this._driver.animate(element, keyframes, i.duration, i.delay, i.easing, [], true);
+ }
+
+ create(id, element, options = {}) {
+ const errors = [];
+
+ const ast = this._animations.get(id);
+
+ let instructions;
+ const autoStylesMap = new Map();
+
+ if (ast) {
+ instructions = buildAnimationTimelines(this._driver, element, ast, ENTER_CLASSNAME, LEAVE_CLASSNAME, new Map(), new Map(), options, EMPTY_INSTRUCTION_MAP, errors);
+ instructions.forEach(inst => {
+ const styles = getOrSetDefaultValue(autoStylesMap, inst.element, new Map());
+ inst.postStyleProps.forEach(prop => styles.set(prop, null));
+ });
+ } else {
+ errors.push(missingOrDestroyedAnimation());
+ instructions = [];
+ }
+
+ if (errors.length) {
+ throw createAnimationFailed(errors);
+ }
+
+ autoStylesMap.forEach((styles, element) => {
+ styles.forEach((_, prop) => {
+ styles.set(prop, this._driver.computeStyle(element, prop, _angular_animations__WEBPACK_IMPORTED_MODULE_1__.AUTO_STYLE));
+ });
+ });
+ const players = instructions.map(i => {
+ const styles = autoStylesMap.get(i.element);
+ return this._buildPlayer(i, new Map(), styles);
+ });
+ const player = optimizeGroupPlayer(players);
+
+ this._playersById.set(id, player);
+
+ player.onDestroy(() => this.destroy(id));
+ this.players.push(player);
+ return player;
+ }
+
+ destroy(id) {
+ const player = this._getPlayer(id);
+
+ player.destroy();
+
+ this._playersById.delete(id);
+
+ const index = this.players.indexOf(player);
+
+ if (index >= 0) {
+ this.players.splice(index, 1);
+ }
+ }
+
+ _getPlayer(id) {
+ const player = this._playersById.get(id);
+
+ if (!player) {
+ throw missingPlayer(id);
+ }
+
+ return player;
+ }
+
+ listen(id, element, eventName, callback) {
+ // triggerName, fromState, toState are all ignored for timeline animations
+ const baseEvent = makeAnimationEvent(element, '', '', '');
+ listenOnPlayer(this._getPlayer(id), eventName, baseEvent, callback);
+ return () => {};
+ }
+
+ command(id, element, command, args) {
+ if (command == 'register') {
+ this.register(id, args[0]);
+ return;
+ }
+
+ if (command == 'create') {
+ const options = args[0] || {};
+ this.create(id, element, options);
+ return;
+ }
+
+ const player = this._getPlayer(id);
+
+ switch (command) {
+ case 'play':
+ player.play();
+ break;
+
+ case 'pause':
+ player.pause();
+ break;
+
+ case 'reset':
+ player.reset();
+ break;
+
+ case 'restart':
+ player.restart();
+ break;
+
+ case 'finish':
+ player.finish();
+ break;
+
+ case 'init':
+ player.init();
+ break;
+
+ case 'setPosition':
+ player.setPosition(parseFloat(args[0]));
+ break;
+
+ case 'destroy':
+ this.destroy(id);
+ break;
+ }
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+
+const QUEUED_CLASSNAME = 'ng-animate-queued';
+const QUEUED_SELECTOR = '.ng-animate-queued';
+const DISABLED_CLASSNAME = 'ng-animate-disabled';
+const DISABLED_SELECTOR = '.ng-animate-disabled';
+const STAR_CLASSNAME = 'ng-star-inserted';
+const STAR_SELECTOR = '.ng-star-inserted';
+const EMPTY_PLAYER_ARRAY = [];
+const NULL_REMOVAL_STATE = {
+ namespaceId: '',
+ setForRemoval: false,
+ setForMove: false,
+ hasAnimation: false,
+ removedBeforeQueried: false
+};
+const NULL_REMOVED_QUERIED_STATE = {
+ namespaceId: '',
+ setForMove: false,
+ setForRemoval: false,
+ hasAnimation: false,
+ removedBeforeQueried: true
+};
+const REMOVAL_FLAG = '__ng_removed';
+
+class StateValue {
+ constructor(input, namespaceId = '') {
+ this.namespaceId = namespaceId;
+ const isObj = input && input.hasOwnProperty('value');
+ const value = isObj ? input['value'] : input;
+ this.value = normalizeTriggerValue(value);
+
+ if (isObj) {
+ const options = copyObj(input);
+ delete options['value'];
+ this.options = options;
+ } else {
+ this.options = {};
+ }
+
+ if (!this.options.params) {
+ this.options.params = {};
+ }
+ }
+
+ get params() {
+ return this.options.params;
+ }
+
+ absorbOptions(options) {
+ const newParams = options.params;
+
+ if (newParams) {
+ const oldParams = this.options.params;
+ Object.keys(newParams).forEach(prop => {
+ if (oldParams[prop] == null) {
+ oldParams[prop] = newParams[prop];
+ }
+ });
+ }
+ }
+
+}
+
+const VOID_VALUE = 'void';
+const DEFAULT_STATE_VALUE = new StateValue(VOID_VALUE);
+
+class AnimationTransitionNamespace {
+ constructor(id, hostElement, _engine) {
+ this.id = id;
+ this.hostElement = hostElement;
+ this._engine = _engine;
+ this.players = [];
+ this._triggers = new Map();
+ this._queue = [];
+ this._elementListeners = new Map();
+ this._hostClassName = 'ng-tns-' + id;
+ addClass(hostElement, this._hostClassName);
+ }
+
+ listen(element, name, phase, callback) {
+ if (!this._triggers.has(name)) {
+ throw missingTrigger(phase, name);
+ }
+
+ if (phase == null || phase.length == 0) {
+ throw missingEvent(name);
+ }
+
+ if (!isTriggerEventValid(phase)) {
+ throw unsupportedTriggerEvent(phase, name);
+ }
+
+ const listeners = getOrSetDefaultValue(this._elementListeners, element, []);
+ const data = {
+ name,
+ phase,
+ callback
+ };
+ listeners.push(data);
+ const triggersWithStates = getOrSetDefaultValue(this._engine.statesByElement, element, new Map());
+
+ if (!triggersWithStates.has(name)) {
+ addClass(element, NG_TRIGGER_CLASSNAME);
+ addClass(element, NG_TRIGGER_CLASSNAME + '-' + name);
+ triggersWithStates.set(name, DEFAULT_STATE_VALUE);
+ }
+
+ return () => {
+ // the event listener is removed AFTER the flush has occurred such
+ // that leave animations callbacks can fire (otherwise if the node
+ // is removed in between then the listeners would be deregistered)
+ this._engine.afterFlush(() => {
+ const index = listeners.indexOf(data);
+
+ if (index >= 0) {
+ listeners.splice(index, 1);
+ }
+
+ if (!this._triggers.has(name)) {
+ triggersWithStates.delete(name);
+ }
+ });
+ };
+ }
+
+ register(name, ast) {
+ if (this._triggers.has(name)) {
+ // throw
+ return false;
+ } else {
+ this._triggers.set(name, ast);
+
+ return true;
+ }
+ }
+
+ _getTrigger(name) {
+ const trigger = this._triggers.get(name);
+
+ if (!trigger) {
+ throw unregisteredTrigger(name);
+ }
+
+ return trigger;
+ }
+
+ trigger(element, triggerName, value, defaultToFallback = true) {
+ const trigger = this._getTrigger(triggerName);
+
+ const player = new TransitionAnimationPlayer(this.id, triggerName, element);
+
+ let triggersWithStates = this._engine.statesByElement.get(element);
+
+ if (!triggersWithStates) {
+ addClass(element, NG_TRIGGER_CLASSNAME);
+ addClass(element, NG_TRIGGER_CLASSNAME + '-' + triggerName);
+
+ this._engine.statesByElement.set(element, triggersWithStates = new Map());
+ }
+
+ let fromState = triggersWithStates.get(triggerName);
+ const toState = new StateValue(value, this.id);
+ const isObj = value && value.hasOwnProperty('value');
+
+ if (!isObj && fromState) {
+ toState.absorbOptions(fromState.options);
+ }
+
+ triggersWithStates.set(triggerName, toState);
+
+ if (!fromState) {
+ fromState = DEFAULT_STATE_VALUE;
+ }
+
+ const isRemoval = toState.value === VOID_VALUE; // normally this isn't reached by here, however, if an object expression
+ // is passed in then it may be a new object each time. Comparing the value
+ // is important since that will stay the same despite there being a new object.
+ // The removal arc here is special cased because the same element is triggered
+ // twice in the event that it contains animations on the outer/inner portions
+ // of the host container
+
+ if (!isRemoval && fromState.value === toState.value) {
+ // this means that despite the value not changing, some inner params
+ // have changed which means that the animation final styles need to be applied
+ if (!objEquals(fromState.params, toState.params)) {
+ const errors = [];
+ const fromStyles = trigger.matchStyles(fromState.value, fromState.params, errors);
+ const toStyles = trigger.matchStyles(toState.value, toState.params, errors);
+
+ if (errors.length) {
+ this._engine.reportError(errors);
+ } else {
+ this._engine.afterFlush(() => {
+ eraseStyles(element, fromStyles);
+ setStyles(element, toStyles);
+ });
+ }
+ }
+
+ return;
+ }
+
+ const playersOnElement = getOrSetDefaultValue(this._engine.playersByElement, element, []);
+ playersOnElement.forEach(player => {
+ // only remove the player if it is queued on the EXACT same trigger/namespace
+ // we only also deal with queued players here because if the animation has
+ // started then we want to keep the player alive until the flush happens
+ // (which is where the previousPlayers are passed into the new player)
+ if (player.namespaceId == this.id && player.triggerName == triggerName && player.queued) {
+ player.destroy();
+ }
+ });
+ let transition = trigger.matchTransition(fromState.value, toState.value, element, toState.params);
+ let isFallbackTransition = false;
+
+ if (!transition) {
+ if (!defaultToFallback) return;
+ transition = trigger.fallbackTransition;
+ isFallbackTransition = true;
+ }
+
+ this._engine.totalQueuedPlayers++;
+
+ this._queue.push({
+ element,
+ triggerName,
+ transition,
+ fromState,
+ toState,
+ player,
+ isFallbackTransition
+ });
+
+ if (!isFallbackTransition) {
+ addClass(element, QUEUED_CLASSNAME);
+ player.onStart(() => {
+ removeClass(element, QUEUED_CLASSNAME);
+ });
+ }
+
+ player.onDone(() => {
+ let index = this.players.indexOf(player);
+
+ if (index >= 0) {
+ this.players.splice(index, 1);
+ }
+
+ const players = this._engine.playersByElement.get(element);
+
+ if (players) {
+ let index = players.indexOf(player);
+
+ if (index >= 0) {
+ players.splice(index, 1);
+ }
+ }
+ });
+ this.players.push(player);
+ playersOnElement.push(player);
+ return player;
+ }
+
+ deregister(name) {
+ this._triggers.delete(name);
+
+ this._engine.statesByElement.forEach(stateMap => stateMap.delete(name));
+
+ this._elementListeners.forEach((listeners, element) => {
+ this._elementListeners.set(element, listeners.filter(entry => {
+ return entry.name != name;
+ }));
+ });
+ }
+
+ clearElementCache(element) {
+ this._engine.statesByElement.delete(element);
+
+ this._elementListeners.delete(element);
+
+ const elementPlayers = this._engine.playersByElement.get(element);
+
+ if (elementPlayers) {
+ elementPlayers.forEach(player => player.destroy());
+
+ this._engine.playersByElement.delete(element);
+ }
+ }
+
+ _signalRemovalForInnerTriggers(rootElement, context) {
+ const elements = this._engine.driver.query(rootElement, NG_TRIGGER_SELECTOR, true); // emulate a leave animation for all inner nodes within this node.
+ // If there are no animations found for any of the nodes then clear the cache
+ // for the element.
+
+
+ elements.forEach(elm => {
+ // this means that an inner remove() operation has already kicked off
+ // the animation on this element...
+ if (elm[REMOVAL_FLAG]) return;
+
+ const namespaces = this._engine.fetchNamespacesByElement(elm);
+
+ if (namespaces.size) {
+ namespaces.forEach(ns => ns.triggerLeaveAnimation(elm, context, false, true));
+ } else {
+ this.clearElementCache(elm);
+ }
+ }); // If the child elements were removed along with the parent, their animations might not
+ // have completed. Clear all the elements from the cache so we don't end up with a memory leak.
+
+ this._engine.afterFlushAnimationsDone(() => elements.forEach(elm => this.clearElementCache(elm)));
+ }
+
+ triggerLeaveAnimation(element, context, destroyAfterComplete, defaultToFallback) {
+ const triggerStates = this._engine.statesByElement.get(element);
+
+ const previousTriggersValues = new Map();
+
+ if (triggerStates) {
+ const players = [];
+ triggerStates.forEach((state, triggerName) => {
+ previousTriggersValues.set(triggerName, state.value); // this check is here in the event that an element is removed
+ // twice (both on the host level and the component level)
+
+ if (this._triggers.has(triggerName)) {
+ const player = this.trigger(element, triggerName, VOID_VALUE, defaultToFallback);
+
+ if (player) {
+ players.push(player);
+ }
+ }
+ });
+
+ if (players.length) {
+ this._engine.markElementAsRemoved(this.id, element, true, context, previousTriggersValues);
+
+ if (destroyAfterComplete) {
+ optimizeGroupPlayer(players).onDone(() => this._engine.processLeaveNode(element));
+ }
+
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ prepareLeaveAnimationListeners(element) {
+ const listeners = this._elementListeners.get(element);
+
+ const elementStates = this._engine.statesByElement.get(element); // if this statement fails then it means that the element was picked up
+ // by an earlier flush (or there are no listeners at all to track the leave).
+
+
+ if (listeners && elementStates) {
+ const visitedTriggers = new Set();
+ listeners.forEach(listener => {
+ const triggerName = listener.name;
+ if (visitedTriggers.has(triggerName)) return;
+ visitedTriggers.add(triggerName);
+
+ const trigger = this._triggers.get(triggerName);
+
+ const transition = trigger.fallbackTransition;
+ const fromState = elementStates.get(triggerName) || DEFAULT_STATE_VALUE;
+ const toState = new StateValue(VOID_VALUE);
+ const player = new TransitionAnimationPlayer(this.id, triggerName, element);
+ this._engine.totalQueuedPlayers++;
+
+ this._queue.push({
+ element,
+ triggerName,
+ transition,
+ fromState,
+ toState,
+ player,
+ isFallbackTransition: true
+ });
+ });
+ }
+ }
+
+ removeNode(element, context) {
+ const engine = this._engine;
+
+ if (element.childElementCount) {
+ this._signalRemovalForInnerTriggers(element, context);
+ } // this means that a * => VOID animation was detected and kicked off
+
+
+ if (this.triggerLeaveAnimation(element, context, true)) return; // find the player that is animating and make sure that the
+ // removal is delayed until that player has completed
+
+ let containsPotentialParentTransition = false;
+
+ if (engine.totalAnimations) {
+ const currentPlayers = engine.players.length ? engine.playersByQueriedElement.get(element) : []; // when this `if statement` does not continue forward it means that
+ // a previous animation query has selected the current element and
+ // is animating it. In this situation want to continue forwards and
+ // allow the element to be queued up for animation later.
+
+ if (currentPlayers && currentPlayers.length) {
+ containsPotentialParentTransition = true;
+ } else {
+ let parent = element;
+
+ while (parent = parent.parentNode) {
+ const triggers = engine.statesByElement.get(parent);
+
+ if (triggers) {
+ containsPotentialParentTransition = true;
+ break;
+ }
+ }
+ }
+ } // at this stage we know that the element will either get removed
+ // during flush or will be picked up by a parent query. Either way
+ // we need to fire the listeners for this element when it DOES get
+ // removed (once the query parent animation is done or after flush)
+
+
+ this.prepareLeaveAnimationListeners(element); // whether or not a parent has an animation we need to delay the deferral of the leave
+ // operation until we have more information (which we do after flush() has been called)
+
+ if (containsPotentialParentTransition) {
+ engine.markElementAsRemoved(this.id, element, false, context);
+ } else {
+ const removalFlag = element[REMOVAL_FLAG];
+
+ if (!removalFlag || removalFlag === NULL_REMOVAL_STATE) {
+ // we do this after the flush has occurred such
+ // that the callbacks can be fired
+ engine.afterFlush(() => this.clearElementCache(element));
+ engine.destroyInnerAnimations(element);
+
+ engine._onRemovalComplete(element, context);
+ }
+ }
+ }
+
+ insertNode(element, parent) {
+ addClass(element, this._hostClassName);
+ }
+
+ drainQueuedTransitions(microtaskId) {
+ const instructions = [];
+
+ this._queue.forEach(entry => {
+ const player = entry.player;
+ if (player.destroyed) return;
+ const element = entry.element;
+
+ const listeners = this._elementListeners.get(element);
+
+ if (listeners) {
+ listeners.forEach(listener => {
+ if (listener.name == entry.triggerName) {
+ const baseEvent = makeAnimationEvent(element, entry.triggerName, entry.fromState.value, entry.toState.value);
+ baseEvent['_data'] = microtaskId;
+ listenOnPlayer(entry.player, listener.phase, baseEvent, listener.callback);
+ }
+ });
+ }
+
+ if (player.markedForDestroy) {
+ this._engine.afterFlush(() => {
+ // now we can destroy the element properly since the event listeners have
+ // been bound to the player
+ player.destroy();
+ });
+ } else {
+ instructions.push(entry);
+ }
+ });
+
+ this._queue = [];
+ return instructions.sort((a, b) => {
+ // if depCount == 0 them move to front
+ // otherwise if a contains b then move back
+ const d0 = a.transition.ast.depCount;
+ const d1 = b.transition.ast.depCount;
+
+ if (d0 == 0 || d1 == 0) {
+ return d0 - d1;
+ }
+
+ return this._engine.driver.containsElement(a.element, b.element) ? 1 : -1;
+ });
+ }
+
+ destroy(context) {
+ this.players.forEach(p => p.destroy());
+
+ this._signalRemovalForInnerTriggers(this.hostElement, context);
+ }
+
+ elementContainsData(element) {
+ let containsData = false;
+ if (this._elementListeners.has(element)) containsData = true;
+ containsData = (this._queue.find(entry => entry.element === element) ? true : false) || containsData;
+ return containsData;
+ }
+
+}
+
+class TransitionAnimationEngine {
+ constructor(bodyNode, driver, _normalizer) {
+ this.bodyNode = bodyNode;
+ this.driver = driver;
+ this._normalizer = _normalizer;
+ this.players = [];
+ this.newHostElements = new Map();
+ this.playersByElement = new Map();
+ this.playersByQueriedElement = new Map();
+ this.statesByElement = new Map();
+ this.disabledNodes = new Set();
+ this.totalAnimations = 0;
+ this.totalQueuedPlayers = 0;
+ this._namespaceLookup = {};
+ this._namespaceList = [];
+ this._flushFns = [];
+ this._whenQuietFns = [];
+ this.namespacesByHostElement = new Map();
+ this.collectedEnterElements = [];
+ this.collectedLeaveElements = []; // this method is designed to be overridden by the code that uses this engine
+
+ this.onRemovalComplete = (element, context) => {};
+ }
+ /** @internal */
+
+
+ _onRemovalComplete(element, context) {
+ this.onRemovalComplete(element, context);
+ }
+
+ get queuedPlayers() {
+ const players = [];
+
+ this._namespaceList.forEach(ns => {
+ ns.players.forEach(player => {
+ if (player.queued) {
+ players.push(player);
+ }
+ });
+ });
+
+ return players;
+ }
+
+ createNamespace(namespaceId, hostElement) {
+ const ns = new AnimationTransitionNamespace(namespaceId, hostElement, this);
+
+ if (this.bodyNode && this.driver.containsElement(this.bodyNode, hostElement)) {
+ this._balanceNamespaceList(ns, hostElement);
+ } else {
+ // defer this later until flush during when the host element has
+ // been inserted so that we know exactly where to place it in
+ // the namespace list
+ this.newHostElements.set(hostElement, ns); // given that this host element is a part of the animation code, it
+ // may or may not be inserted by a parent node that is of an
+ // animation renderer type. If this happens then we can still have
+ // access to this item when we query for :enter nodes. If the parent
+ // is a renderer then the set data-structure will normalize the entry
+
+ this.collectEnterElement(hostElement);
+ }
+
+ return this._namespaceLookup[namespaceId] = ns;
+ }
+
+ _balanceNamespaceList(ns, hostElement) {
+ const namespaceList = this._namespaceList;
+ const namespacesByHostElement = this.namespacesByHostElement;
+ const limit = namespaceList.length - 1;
+
+ if (limit >= 0) {
+ let found = false; // Find the closest ancestor with an existing namespace so we can then insert `ns` after it,
+ // establishing a top-down ordering of namespaces in `this._namespaceList`.
+
+ let ancestor = this.driver.getParentElement(hostElement);
+
+ while (ancestor) {
+ const ancestorNs = namespacesByHostElement.get(ancestor);
+
+ if (ancestorNs) {
+ // An animation namespace has been registered for this ancestor, so we insert `ns`
+ // right after it to establish top-down ordering of animation namespaces.
+ const index = namespaceList.indexOf(ancestorNs);
+ namespaceList.splice(index + 1, 0, ns);
+ found = true;
+ break;
+ }
+
+ ancestor = this.driver.getParentElement(ancestor);
+ }
+
+ if (!found) {
+ // No namespace exists that is an ancestor of `ns`, so `ns` is inserted at the front to
+ // ensure that any existing descendants are ordered after `ns`, retaining the desired
+ // top-down ordering.
+ namespaceList.unshift(ns);
+ }
+ } else {
+ namespaceList.push(ns);
+ }
+
+ namespacesByHostElement.set(hostElement, ns);
+ return ns;
+ }
+
+ register(namespaceId, hostElement) {
+ let ns = this._namespaceLookup[namespaceId];
+
+ if (!ns) {
+ ns = this.createNamespace(namespaceId, hostElement);
+ }
+
+ return ns;
+ }
+
+ registerTrigger(namespaceId, name, trigger) {
+ let ns = this._namespaceLookup[namespaceId];
+
+ if (ns && ns.register(name, trigger)) {
+ this.totalAnimations++;
+ }
+ }
+
+ destroy(namespaceId, context) {
+ if (!namespaceId) return;
+
+ const ns = this._fetchNamespace(namespaceId);
+
+ this.afterFlush(() => {
+ this.namespacesByHostElement.delete(ns.hostElement);
+ delete this._namespaceLookup[namespaceId];
+
+ const index = this._namespaceList.indexOf(ns);
+
+ if (index >= 0) {
+ this._namespaceList.splice(index, 1);
+ }
+ });
+ this.afterFlushAnimationsDone(() => ns.destroy(context));
+ }
+
+ _fetchNamespace(id) {
+ return this._namespaceLookup[id];
+ }
+
+ fetchNamespacesByElement(element) {
+ // normally there should only be one namespace per element, however
+ // if @triggers are placed on both the component element and then
+ // its host element (within the component code) then there will be
+ // two namespaces returned. We use a set here to simply deduplicate
+ // the namespaces in case (for the reason described above) there are multiple triggers
+ const namespaces = new Set();
+ const elementStates = this.statesByElement.get(element);
+
+ if (elementStates) {
+ for (let stateValue of elementStates.values()) {
+ if (stateValue.namespaceId) {
+ const ns = this._fetchNamespace(stateValue.namespaceId);
+
+ if (ns) {
+ namespaces.add(ns);
+ }
+ }
+ }
+ }
+
+ return namespaces;
+ }
+
+ trigger(namespaceId, element, name, value) {
+ if (isElementNode(element)) {
+ const ns = this._fetchNamespace(namespaceId);
+
+ if (ns) {
+ ns.trigger(element, name, value);
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ insertNode(namespaceId, element, parent, insertBefore) {
+ if (!isElementNode(element)) return; // special case for when an element is removed and reinserted (move operation)
+ // when this occurs we do not want to use the element for deletion later
+
+ const details = element[REMOVAL_FLAG];
+
+ if (details && details.setForRemoval) {
+ details.setForRemoval = false;
+ details.setForMove = true;
+ const index = this.collectedLeaveElements.indexOf(element);
+
+ if (index >= 0) {
+ this.collectedLeaveElements.splice(index, 1);
+ }
+ } // in the event that the namespaceId is blank then the caller
+ // code does not contain any animation code in it, but it is
+ // just being called so that the node is marked as being inserted
+
+
+ if (namespaceId) {
+ const ns = this._fetchNamespace(namespaceId); // This if-statement is a workaround for router issue #21947.
+ // The router sometimes hits a race condition where while a route
+ // is being instantiated a new navigation arrives, triggering leave
+ // animation of DOM that has not been fully initialized, until this
+ // is resolved, we need to handle the scenario when DOM is not in a
+ // consistent state during the animation.
+
+
+ if (ns) {
+ ns.insertNode(element, parent);
+ }
+ } // only *directives and host elements are inserted before
+
+
+ if (insertBefore) {
+ this.collectEnterElement(element);
+ }
+ }
+
+ collectEnterElement(element) {
+ this.collectedEnterElements.push(element);
+ }
+
+ markElementAsDisabled(element, value) {
+ if (value) {
+ if (!this.disabledNodes.has(element)) {
+ this.disabledNodes.add(element);
+ addClass(element, DISABLED_CLASSNAME);
+ }
+ } else if (this.disabledNodes.has(element)) {
+ this.disabledNodes.delete(element);
+ removeClass(element, DISABLED_CLASSNAME);
+ }
+ }
+
+ removeNode(namespaceId, element, isHostElement, context) {
+ if (isElementNode(element)) {
+ const ns = namespaceId ? this._fetchNamespace(namespaceId) : null;
+
+ if (ns) {
+ ns.removeNode(element, context);
+ } else {
+ this.markElementAsRemoved(namespaceId, element, false, context);
+ }
+
+ if (isHostElement) {
+ const hostNS = this.namespacesByHostElement.get(element);
+
+ if (hostNS && hostNS.id !== namespaceId) {
+ hostNS.removeNode(element, context);
+ }
+ }
+ } else {
+ this._onRemovalComplete(element, context);
+ }
+ }
+
+ markElementAsRemoved(namespaceId, element, hasAnimation, context, previousTriggersValues) {
+ this.collectedLeaveElements.push(element);
+ element[REMOVAL_FLAG] = {
+ namespaceId,
+ setForRemoval: context,
+ hasAnimation,
+ removedBeforeQueried: false,
+ previousTriggersValues
+ };
+ }
+
+ listen(namespaceId, element, name, phase, callback) {
+ if (isElementNode(element)) {
+ return this._fetchNamespace(namespaceId).listen(element, name, phase, callback);
+ }
+
+ return () => {};
+ }
+
+ _buildInstruction(entry, subTimelines, enterClassName, leaveClassName, skipBuildAst) {
+ return entry.transition.build(this.driver, entry.element, entry.fromState.value, entry.toState.value, enterClassName, leaveClassName, entry.fromState.options, entry.toState.options, subTimelines, skipBuildAst);
+ }
+
+ destroyInnerAnimations(containerElement) {
+ let elements = this.driver.query(containerElement, NG_TRIGGER_SELECTOR, true);
+ elements.forEach(element => this.destroyActiveAnimationsForElement(element));
+ if (this.playersByQueriedElement.size == 0) return;
+ elements = this.driver.query(containerElement, NG_ANIMATING_SELECTOR, true);
+ elements.forEach(element => this.finishActiveQueriedAnimationOnElement(element));
+ }
+
+ destroyActiveAnimationsForElement(element) {
+ const players = this.playersByElement.get(element);
+
+ if (players) {
+ players.forEach(player => {
+ // special case for when an element is set for destruction, but hasn't started.
+ // in this situation we want to delay the destruction until the flush occurs
+ // so that any event listeners attached to the player are triggered.
+ if (player.queued) {
+ player.markedForDestroy = true;
+ } else {
+ player.destroy();
+ }
+ });
+ }
+ }
+
+ finishActiveQueriedAnimationOnElement(element) {
+ const players = this.playersByQueriedElement.get(element);
+
+ if (players) {
+ players.forEach(player => player.finish());
+ }
+ }
+
+ whenRenderingDone() {
+ return new Promise(resolve => {
+ if (this.players.length) {
+ return optimizeGroupPlayer(this.players).onDone(() => resolve());
+ } else {
+ resolve();
+ }
+ });
+ }
+
+ processLeaveNode(element) {
+ const details = element[REMOVAL_FLAG];
+
+ if (details && details.setForRemoval) {
+ // this will prevent it from removing it twice
+ element[REMOVAL_FLAG] = NULL_REMOVAL_STATE;
+
+ if (details.namespaceId) {
+ this.destroyInnerAnimations(element);
+
+ const ns = this._fetchNamespace(details.namespaceId);
+
+ if (ns) {
+ ns.clearElementCache(element);
+ }
+ }
+
+ this._onRemovalComplete(element, details.setForRemoval);
+ }
+
+ if (element.classList?.contains(DISABLED_CLASSNAME)) {
+ this.markElementAsDisabled(element, false);
+ }
+
+ this.driver.query(element, DISABLED_SELECTOR, true).forEach(node => {
+ this.markElementAsDisabled(node, false);
+ });
+ }
+
+ flush(microtaskId = -1) {
+ let players = [];
+
+ if (this.newHostElements.size) {
+ this.newHostElements.forEach((ns, element) => this._balanceNamespaceList(ns, element));
+ this.newHostElements.clear();
+ }
+
+ if (this.totalAnimations && this.collectedEnterElements.length) {
+ for (let i = 0; i < this.collectedEnterElements.length; i++) {
+ const elm = this.collectedEnterElements[i];
+ addClass(elm, STAR_CLASSNAME);
+ }
+ }
+
+ if (this._namespaceList.length && (this.totalQueuedPlayers || this.collectedLeaveElements.length)) {
+ const cleanupFns = [];
+
+ try {
+ players = this._flushAnimations(cleanupFns, microtaskId);
+ } finally {
+ for (let i = 0; i < cleanupFns.length; i++) {
+ cleanupFns[i]();
+ }
+ }
+ } else {
+ for (let i = 0; i < this.collectedLeaveElements.length; i++) {
+ const element = this.collectedLeaveElements[i];
+ this.processLeaveNode(element);
+ }
+ }
+
+ this.totalQueuedPlayers = 0;
+ this.collectedEnterElements.length = 0;
+ this.collectedLeaveElements.length = 0;
+
+ this._flushFns.forEach(fn => fn());
+
+ this._flushFns = [];
+
+ if (this._whenQuietFns.length) {
+ // we move these over to a variable so that
+ // if any new callbacks are registered in another
+ // flush they do not populate the existing set
+ const quietFns = this._whenQuietFns;
+ this._whenQuietFns = [];
+
+ if (players.length) {
+ optimizeGroupPlayer(players).onDone(() => {
+ quietFns.forEach(fn => fn());
+ });
+ } else {
+ quietFns.forEach(fn => fn());
+ }
+ }
+ }
+
+ reportError(errors) {
+ throw triggerTransitionsFailed(errors);
+ }
+
+ _flushAnimations(cleanupFns, microtaskId) {
+ const subTimelines = new ElementInstructionMap();
+ const skippedPlayers = [];
+ const skippedPlayersMap = new Map();
+ const queuedInstructions = [];
+ const queriedElements = new Map();
+ const allPreStyleElements = new Map();
+ const allPostStyleElements = new Map();
+ const disabledElementsSet = new Set();
+ this.disabledNodes.forEach(node => {
+ disabledElementsSet.add(node);
+ const nodesThatAreDisabled = this.driver.query(node, QUEUED_SELECTOR, true);
+
+ for (let i = 0; i < nodesThatAreDisabled.length; i++) {
+ disabledElementsSet.add(nodesThatAreDisabled[i]);
+ }
+ });
+ const bodyNode = this.bodyNode;
+ const allTriggerElements = Array.from(this.statesByElement.keys());
+ const enterNodeMap = buildRootMap(allTriggerElements, this.collectedEnterElements); // this must occur before the instructions are built below such that
+ // the :enter queries match the elements (since the timeline queries
+ // are fired during instruction building).
+
+ const enterNodeMapIds = new Map();
+ let i = 0;
+ enterNodeMap.forEach((nodes, root) => {
+ const className = ENTER_CLASSNAME + i++;
+ enterNodeMapIds.set(root, className);
+ nodes.forEach(node => addClass(node, className));
+ });
+ const allLeaveNodes = [];
+ const mergedLeaveNodes = new Set();
+ const leaveNodesWithoutAnimations = new Set();
+
+ for (let i = 0; i < this.collectedLeaveElements.length; i++) {
+ const element = this.collectedLeaveElements[i];
+ const details = element[REMOVAL_FLAG];
+
+ if (details && details.setForRemoval) {
+ allLeaveNodes.push(element);
+ mergedLeaveNodes.add(element);
+
+ if (details.hasAnimation) {
+ this.driver.query(element, STAR_SELECTOR, true).forEach(elm => mergedLeaveNodes.add(elm));
+ } else {
+ leaveNodesWithoutAnimations.add(element);
+ }
+ }
+ }
+
+ const leaveNodeMapIds = new Map();
+ const leaveNodeMap = buildRootMap(allTriggerElements, Array.from(mergedLeaveNodes));
+ leaveNodeMap.forEach((nodes, root) => {
+ const className = LEAVE_CLASSNAME + i++;
+ leaveNodeMapIds.set(root, className);
+ nodes.forEach(node => addClass(node, className));
+ });
+ cleanupFns.push(() => {
+ enterNodeMap.forEach((nodes, root) => {
+ const className = enterNodeMapIds.get(root);
+ nodes.forEach(node => removeClass(node, className));
+ });
+ leaveNodeMap.forEach((nodes, root) => {
+ const className = leaveNodeMapIds.get(root);
+ nodes.forEach(node => removeClass(node, className));
+ });
+ allLeaveNodes.forEach(element => {
+ this.processLeaveNode(element);
+ });
+ });
+ const allPlayers = [];
+ const erroneousTransitions = [];
+
+ for (let i = this._namespaceList.length - 1; i >= 0; i--) {
+ const ns = this._namespaceList[i];
+ ns.drainQueuedTransitions(microtaskId).forEach(entry => {
+ const player = entry.player;
+ const element = entry.element;
+ allPlayers.push(player);
+
+ if (this.collectedEnterElements.length) {
+ const details = element[REMOVAL_FLAG]; // animations for move operations (elements being removed and reinserted,
+ // e.g. when the order of an *ngFor list changes) are currently not supported
+
+ if (details && details.setForMove) {
+ if (details.previousTriggersValues && details.previousTriggersValues.has(entry.triggerName)) {
+ const previousValue = details.previousTriggersValues.get(entry.triggerName); // we need to restore the previous trigger value since the element has
+ // only been moved and hasn't actually left the DOM
+
+ const triggersWithStates = this.statesByElement.get(entry.element);
+
+ if (triggersWithStates && triggersWithStates.has(entry.triggerName)) {
+ const state = triggersWithStates.get(entry.triggerName);
+ state.value = previousValue;
+ triggersWithStates.set(entry.triggerName, state);
+ }
+ }
+
+ player.destroy();
+ return;
+ }
+ }
+
+ const nodeIsOrphaned = !bodyNode || !this.driver.containsElement(bodyNode, element);
+ const leaveClassName = leaveNodeMapIds.get(element);
+ const enterClassName = enterNodeMapIds.get(element);
+
+ const instruction = this._buildInstruction(entry, subTimelines, enterClassName, leaveClassName, nodeIsOrphaned);
+
+ if (instruction.errors && instruction.errors.length) {
+ erroneousTransitions.push(instruction);
+ return;
+ } // even though the element may not be in the DOM, it may still
+ // be added at a later point (due to the mechanics of content
+ // projection and/or dynamic component insertion) therefore it's
+ // important to still style the element.
+
+
+ if (nodeIsOrphaned) {
+ player.onStart(() => eraseStyles(element, instruction.fromStyles));
+ player.onDestroy(() => setStyles(element, instruction.toStyles));
+ skippedPlayers.push(player);
+ return;
+ } // if an unmatched transition is queued and ready to go
+ // then it SHOULD NOT render an animation and cancel the
+ // previously running animations.
+
+
+ if (entry.isFallbackTransition) {
+ player.onStart(() => eraseStyles(element, instruction.fromStyles));
+ player.onDestroy(() => setStyles(element, instruction.toStyles));
+ skippedPlayers.push(player);
+ return;
+ } // this means that if a parent animation uses this animation as a sub-trigger
+ // then it will instruct the timeline builder not to add a player delay, but
+ // instead stretch the first keyframe gap until the animation starts. This is
+ // important in order to prevent extra initialization styles from being
+ // required by the user for the animation.
+
+
+ const timelines = [];
+ instruction.timelines.forEach(tl => {
+ tl.stretchStartingKeyframe = true;
+
+ if (!this.disabledNodes.has(tl.element)) {
+ timelines.push(tl);
+ }
+ });
+ instruction.timelines = timelines;
+ subTimelines.append(element, instruction.timelines);
+ const tuple = {
+ instruction,
+ player,
+ element
+ };
+ queuedInstructions.push(tuple);
+ instruction.queriedElements.forEach(element => getOrSetDefaultValue(queriedElements, element, []).push(player));
+ instruction.preStyleProps.forEach((stringMap, element) => {
+ if (stringMap.size) {
+ let setVal = allPreStyleElements.get(element);
+
+ if (!setVal) {
+ allPreStyleElements.set(element, setVal = new Set());
+ }
+
+ stringMap.forEach((_, prop) => setVal.add(prop));
+ }
+ });
+ instruction.postStyleProps.forEach((stringMap, element) => {
+ let setVal = allPostStyleElements.get(element);
+
+ if (!setVal) {
+ allPostStyleElements.set(element, setVal = new Set());
+ }
+
+ stringMap.forEach((_, prop) => setVal.add(prop));
+ });
+ });
+ }
+
+ if (erroneousTransitions.length) {
+ const errors = [];
+ erroneousTransitions.forEach(instruction => {
+ errors.push(transitionFailed(instruction.triggerName, instruction.errors));
+ });
+ allPlayers.forEach(player => player.destroy());
+ this.reportError(errors);
+ }
+
+ const allPreviousPlayersMap = new Map(); // this map tells us which element in the DOM tree is contained by
+ // which animation. Further down this map will get populated once
+ // the players are built and in doing so we can use it to efficiently
+ // figure out if a sub player is skipped due to a parent player having priority.
+
+ const animationElementMap = new Map();
+ queuedInstructions.forEach(entry => {
+ const element = entry.element;
+
+ if (subTimelines.has(element)) {
+ animationElementMap.set(element, element);
+
+ this._beforeAnimationBuild(entry.player.namespaceId, entry.instruction, allPreviousPlayersMap);
+ }
+ });
+ skippedPlayers.forEach(player => {
+ const element = player.element;
+
+ const previousPlayers = this._getPreviousPlayers(element, false, player.namespaceId, player.triggerName, null);
+
+ previousPlayers.forEach(prevPlayer => {
+ getOrSetDefaultValue(allPreviousPlayersMap, element, []).push(prevPlayer);
+ prevPlayer.destroy();
+ });
+ }); // this is a special case for nodes that will be removed either by
+ // having their own leave animations or by being queried in a container
+ // that will be removed once a parent animation is complete. The idea
+ // here is that * styles must be identical to ! styles because of
+ // backwards compatibility (* is also filled in by default in many places).
+ // Otherwise * styles will return an empty value or "auto" since the element
+ // passed to getComputedStyle will not be visible (since * === destination)
+
+ const replaceNodes = allLeaveNodes.filter(node => {
+ return replacePostStylesAsPre(node, allPreStyleElements, allPostStyleElements);
+ }); // POST STAGE: fill the * styles
+
+ const postStylesMap = new Map();
+ const allLeaveQueriedNodes = cloakAndComputeStyles(postStylesMap, this.driver, leaveNodesWithoutAnimations, allPostStyleElements, _angular_animations__WEBPACK_IMPORTED_MODULE_1__.AUTO_STYLE);
+ allLeaveQueriedNodes.forEach(node => {
+ if (replacePostStylesAsPre(node, allPreStyleElements, allPostStyleElements)) {
+ replaceNodes.push(node);
+ }
+ }); // PRE STAGE: fill the ! styles
+
+ const preStylesMap = new Map();
+ enterNodeMap.forEach((nodes, root) => {
+ cloakAndComputeStyles(preStylesMap, this.driver, new Set(nodes), allPreStyleElements, _angular_animations__WEBPACK_IMPORTED_MODULE_1__["ɵPRE_STYLE"]);
+ });
+ replaceNodes.forEach(node => {
+ const post = postStylesMap.get(node);
+ const pre = preStylesMap.get(node);
+ postStylesMap.set(node, new Map([...Array.from(post?.entries() ?? []), ...Array.from(pre?.entries() ?? [])]));
+ });
+ const rootPlayers = [];
+ const subPlayers = [];
+ const NO_PARENT_ANIMATION_ELEMENT_DETECTED = {};
+ queuedInstructions.forEach(entry => {
+ const {
+ element,
+ player,
+ instruction
+ } = entry; // this means that it was never consumed by a parent animation which
+ // means that it is independent and therefore should be set for animation
+
+ if (subTimelines.has(element)) {
+ if (disabledElementsSet.has(element)) {
+ player.onDestroy(() => setStyles(element, instruction.toStyles));
+ player.disabled = true;
+ player.overrideTotalTime(instruction.totalTime);
+ skippedPlayers.push(player);
+ return;
+ } // this will flow up the DOM and query the map to figure out
+ // if a parent animation has priority over it. In the situation
+ // that a parent is detected then it will cancel the loop. If
+ // nothing is detected, or it takes a few hops to find a parent,
+ // then it will fill in the missing nodes and signal them as having
+ // a detected parent (or a NO_PARENT value via a special constant).
+
+
+ let parentWithAnimation = NO_PARENT_ANIMATION_ELEMENT_DETECTED;
+
+ if (animationElementMap.size > 1) {
+ let elm = element;
+ const parentsToAdd = [];
+
+ while (elm = elm.parentNode) {
+ const detectedParent = animationElementMap.get(elm);
+
+ if (detectedParent) {
+ parentWithAnimation = detectedParent;
+ break;
+ }
+
+ parentsToAdd.push(elm);
+ }
+
+ parentsToAdd.forEach(parent => animationElementMap.set(parent, parentWithAnimation));
+ }
+
+ const innerPlayer = this._buildAnimation(player.namespaceId, instruction, allPreviousPlayersMap, skippedPlayersMap, preStylesMap, postStylesMap);
+
+ player.setRealPlayer(innerPlayer);
+
+ if (parentWithAnimation === NO_PARENT_ANIMATION_ELEMENT_DETECTED) {
+ rootPlayers.push(player);
+ } else {
+ const parentPlayers = this.playersByElement.get(parentWithAnimation);
+
+ if (parentPlayers && parentPlayers.length) {
+ player.parentPlayer = optimizeGroupPlayer(parentPlayers);
+ }
+
+ skippedPlayers.push(player);
+ }
+ } else {
+ eraseStyles(element, instruction.fromStyles);
+ player.onDestroy(() => setStyles(element, instruction.toStyles)); // there still might be a ancestor player animating this
+ // element therefore we will still add it as a sub player
+ // even if its animation may be disabled
+
+ subPlayers.push(player);
+
+ if (disabledElementsSet.has(element)) {
+ skippedPlayers.push(player);
+ }
+ }
+ }); // find all of the sub players' corresponding inner animation players
+
+ subPlayers.forEach(player => {
+ // even if no players are found for a sub animation it
+ // will still complete itself after the next tick since it's Noop
+ const playersForElement = skippedPlayersMap.get(player.element);
+
+ if (playersForElement && playersForElement.length) {
+ const innerPlayer = optimizeGroupPlayer(playersForElement);
+ player.setRealPlayer(innerPlayer);
+ }
+ }); // the reason why we don't actually play the animation is
+ // because all that a skipped player is designed to do is to
+ // fire the start/done transition callback events
+
+ skippedPlayers.forEach(player => {
+ if (player.parentPlayer) {
+ player.syncPlayerEvents(player.parentPlayer);
+ } else {
+ player.destroy();
+ }
+ }); // run through all of the queued removals and see if they
+ // were picked up by a query. If not then perform the removal
+ // operation right away unless a parent animation is ongoing.
+
+ for (let i = 0; i < allLeaveNodes.length; i++) {
+ const element = allLeaveNodes[i];
+ const details = element[REMOVAL_FLAG];
+ removeClass(element, LEAVE_CLASSNAME); // this means the element has a removal animation that is being
+ // taken care of and therefore the inner elements will hang around
+ // until that animation is over (or the parent queried animation)
+
+ if (details && details.hasAnimation) continue;
+ let players = []; // if this element is queried or if it contains queried children
+ // then we want for the element not to be removed from the page
+ // until the queried animations have finished
+
+ if (queriedElements.size) {
+ let queriedPlayerResults = queriedElements.get(element);
+
+ if (queriedPlayerResults && queriedPlayerResults.length) {
+ players.push(...queriedPlayerResults);
+ }
+
+ let queriedInnerElements = this.driver.query(element, NG_ANIMATING_SELECTOR, true);
+
+ for (let j = 0; j < queriedInnerElements.length; j++) {
+ let queriedPlayers = queriedElements.get(queriedInnerElements[j]);
+
+ if (queriedPlayers && queriedPlayers.length) {
+ players.push(...queriedPlayers);
+ }
+ }
+ }
+
+ const activePlayers = players.filter(p => !p.destroyed);
+
+ if (activePlayers.length) {
+ removeNodesAfterAnimationDone(this, element, activePlayers);
+ } else {
+ this.processLeaveNode(element);
+ }
+ } // this is required so the cleanup method doesn't remove them
+
+
+ allLeaveNodes.length = 0;
+ rootPlayers.forEach(player => {
+ this.players.push(player);
+ player.onDone(() => {
+ player.destroy();
+ const index = this.players.indexOf(player);
+ this.players.splice(index, 1);
+ });
+ player.play();
+ });
+ return rootPlayers;
+ }
+
+ elementContainsData(namespaceId, element) {
+ let containsData = false;
+ const details = element[REMOVAL_FLAG];
+ if (details && details.setForRemoval) containsData = true;
+ if (this.playersByElement.has(element)) containsData = true;
+ if (this.playersByQueriedElement.has(element)) containsData = true;
+ if (this.statesByElement.has(element)) containsData = true;
+ return this._fetchNamespace(namespaceId).elementContainsData(element) || containsData;
+ }
+
+ afterFlush(callback) {
+ this._flushFns.push(callback);
+ }
+
+ afterFlushAnimationsDone(callback) {
+ this._whenQuietFns.push(callback);
+ }
+
+ _getPreviousPlayers(element, isQueriedElement, namespaceId, triggerName, toStateValue) {
+ let players = [];
+
+ if (isQueriedElement) {
+ const queriedElementPlayers = this.playersByQueriedElement.get(element);
+
+ if (queriedElementPlayers) {
+ players = queriedElementPlayers;
+ }
+ } else {
+ const elementPlayers = this.playersByElement.get(element);
+
+ if (elementPlayers) {
+ const isRemovalAnimation = !toStateValue || toStateValue == VOID_VALUE;
+ elementPlayers.forEach(player => {
+ if (player.queued) return;
+ if (!isRemovalAnimation && player.triggerName != triggerName) return;
+ players.push(player);
+ });
+ }
+ }
+
+ if (namespaceId || triggerName) {
+ players = players.filter(player => {
+ if (namespaceId && namespaceId != player.namespaceId) return false;
+ if (triggerName && triggerName != player.triggerName) return false;
+ return true;
+ });
+ }
+
+ return players;
+ }
+
+ _beforeAnimationBuild(namespaceId, instruction, allPreviousPlayersMap) {
+ const triggerName = instruction.triggerName;
+ const rootElement = instruction.element; // when a removal animation occurs, ALL previous players are collected
+ // and destroyed (even if they are outside of the current namespace)
+
+ const targetNameSpaceId = instruction.isRemovalTransition ? undefined : namespaceId;
+ const targetTriggerName = instruction.isRemovalTransition ? undefined : triggerName;
+
+ for (const timelineInstruction of instruction.timelines) {
+ const element = timelineInstruction.element;
+ const isQueriedElement = element !== rootElement;
+ const players = getOrSetDefaultValue(allPreviousPlayersMap, element, []);
+
+ const previousPlayers = this._getPreviousPlayers(element, isQueriedElement, targetNameSpaceId, targetTriggerName, instruction.toState);
+
+ previousPlayers.forEach(player => {
+ const realPlayer = player.getRealPlayer();
+
+ if (realPlayer.beforeDestroy) {
+ realPlayer.beforeDestroy();
+ }
+
+ player.destroy();
+ players.push(player);
+ });
+ } // this needs to be done so that the PRE/POST styles can be
+ // computed properly without interfering with the previous animation
+
+
+ eraseStyles(rootElement, instruction.fromStyles);
+ }
+
+ _buildAnimation(namespaceId, instruction, allPreviousPlayersMap, skippedPlayersMap, preStylesMap, postStylesMap) {
+ const triggerName = instruction.triggerName;
+ const rootElement = instruction.element; // we first run this so that the previous animation player
+ // data can be passed into the successive animation players
+
+ const allQueriedPlayers = [];
+ const allConsumedElements = new Set();
+ const allSubElements = new Set();
+ const allNewPlayers = instruction.timelines.map(timelineInstruction => {
+ const element = timelineInstruction.element;
+ allConsumedElements.add(element); // FIXME (matsko): make sure to-be-removed animations are removed properly
+
+ const details = element[REMOVAL_FLAG];
+ if (details && details.removedBeforeQueried) return new _angular_animations__WEBPACK_IMPORTED_MODULE_1__.NoopAnimationPlayer(timelineInstruction.duration, timelineInstruction.delay);
+ const isQueriedElement = element !== rootElement;
+ const previousPlayers = flattenGroupPlayers((allPreviousPlayersMap.get(element) || EMPTY_PLAYER_ARRAY).map(p => p.getRealPlayer())).filter(p => {
+ // the `element` is not apart of the AnimationPlayer definition, but
+ // Mock/WebAnimations
+ // use the element within their implementation. This will be added in Angular5 to
+ // AnimationPlayer
+ const pp = p;
+ return pp.element ? pp.element === element : false;
+ });
+ const preStyles = preStylesMap.get(element);
+ const postStyles = postStylesMap.get(element);
+ const keyframes = normalizeKeyframes$1(this.driver, this._normalizer, element, timelineInstruction.keyframes, preStyles, postStyles);
+
+ const player = this._buildPlayer(timelineInstruction, keyframes, previousPlayers); // this means that this particular player belongs to a sub trigger. It is
+ // important that we match this player up with the corresponding (@trigger.listener)
+
+
+ if (timelineInstruction.subTimeline && skippedPlayersMap) {
+ allSubElements.add(element);
+ }
+
+ if (isQueriedElement) {
+ const wrappedPlayer = new TransitionAnimationPlayer(namespaceId, triggerName, element);
+ wrappedPlayer.setRealPlayer(player);
+ allQueriedPlayers.push(wrappedPlayer);
+ }
+
+ return player;
+ });
+ allQueriedPlayers.forEach(player => {
+ getOrSetDefaultValue(this.playersByQueriedElement, player.element, []).push(player);
+ player.onDone(() => deleteOrUnsetInMap(this.playersByQueriedElement, player.element, player));
+ });
+ allConsumedElements.forEach(element => addClass(element, NG_ANIMATING_CLASSNAME));
+ const player = optimizeGroupPlayer(allNewPlayers);
+ player.onDestroy(() => {
+ allConsumedElements.forEach(element => removeClass(element, NG_ANIMATING_CLASSNAME));
+ setStyles(rootElement, instruction.toStyles);
+ }); // this basically makes all of the callbacks for sub element animations
+ // be dependent on the upper players for when they finish
+
+ allSubElements.forEach(element => {
+ getOrSetDefaultValue(skippedPlayersMap, element, []).push(player);
+ });
+ return player;
+ }
+
+ _buildPlayer(instruction, keyframes, previousPlayers) {
+ if (keyframes.length > 0) {
+ return this.driver.animate(instruction.element, keyframes, instruction.duration, instruction.delay, instruction.easing, previousPlayers);
+ } // special case for when an empty transition|definition is provided
+ // ... there is no point in rendering an empty animation
+
+
+ return new _angular_animations__WEBPACK_IMPORTED_MODULE_1__.NoopAnimationPlayer(instruction.duration, instruction.delay);
+ }
+
+}
+
+class TransitionAnimationPlayer {
+ constructor(namespaceId, triggerName, element) {
+ this.namespaceId = namespaceId;
+ this.triggerName = triggerName;
+ this.element = element;
+ this._player = new _angular_animations__WEBPACK_IMPORTED_MODULE_1__.NoopAnimationPlayer();
+ this._containsRealPlayer = false;
+ this._queuedCallbacks = new Map();
+ this.destroyed = false;
+ this.markedForDestroy = false;
+ this.disabled = false;
+ this.queued = true;
+ this.totalTime = 0;
+ }
+
+ setRealPlayer(player) {
+ if (this._containsRealPlayer) return;
+ this._player = player;
+
+ this._queuedCallbacks.forEach((callbacks, phase) => {
+ callbacks.forEach(callback => listenOnPlayer(player, phase, undefined, callback));
+ });
+
+ this._queuedCallbacks.clear();
+
+ this._containsRealPlayer = true;
+ this.overrideTotalTime(player.totalTime);
+ this.queued = false;
+ }
+
+ getRealPlayer() {
+ return this._player;
+ }
+
+ overrideTotalTime(totalTime) {
+ this.totalTime = totalTime;
+ }
+
+ syncPlayerEvents(player) {
+ const p = this._player;
+
+ if (p.triggerCallback) {
+ player.onStart(() => p.triggerCallback('start'));
+ }
+
+ player.onDone(() => this.finish());
+ player.onDestroy(() => this.destroy());
+ }
+
+ _queueEvent(name, callback) {
+ getOrSetDefaultValue(this._queuedCallbacks, name, []).push(callback);
+ }
+
+ onDone(fn) {
+ if (this.queued) {
+ this._queueEvent('done', fn);
+ }
+
+ this._player.onDone(fn);
+ }
+
+ onStart(fn) {
+ if (this.queued) {
+ this._queueEvent('start', fn);
+ }
+
+ this._player.onStart(fn);
+ }
+
+ onDestroy(fn) {
+ if (this.queued) {
+ this._queueEvent('destroy', fn);
+ }
+
+ this._player.onDestroy(fn);
+ }
+
+ init() {
+ this._player.init();
+ }
+
+ hasStarted() {
+ return this.queued ? false : this._player.hasStarted();
+ }
+
+ play() {
+ !this.queued && this._player.play();
+ }
+
+ pause() {
+ !this.queued && this._player.pause();
+ }
+
+ restart() {
+ !this.queued && this._player.restart();
+ }
+
+ finish() {
+ this._player.finish();
+ }
+
+ destroy() {
+ this.destroyed = true;
+
+ this._player.destroy();
+ }
+
+ reset() {
+ !this.queued && this._player.reset();
+ }
+
+ setPosition(p) {
+ if (!this.queued) {
+ this._player.setPosition(p);
+ }
+ }
+
+ getPosition() {
+ return this.queued ? 0 : this._player.getPosition();
+ }
+ /** @internal */
+
+
+ triggerCallback(phaseName) {
+ const p = this._player;
+
+ if (p.triggerCallback) {
+ p.triggerCallback(phaseName);
+ }
+ }
+
+}
+
+function deleteOrUnsetInMap(map, key, value) {
+ let currentValues = map.get(key);
+
+ if (currentValues) {
+ if (currentValues.length) {
+ const index = currentValues.indexOf(value);
+ currentValues.splice(index, 1);
+ }
+
+ if (currentValues.length == 0) {
+ map.delete(key);
+ }
+ }
+
+ return currentValues;
+}
+
+function normalizeTriggerValue(value) {
+ // we use `!= null` here because it's the most simple
+ // way to test against a "falsy" value without mixing
+ // in empty strings or a zero value. DO NOT OPTIMIZE.
+ return value != null ? value : null;
+}
+
+function isElementNode(node) {
+ return node && node['nodeType'] === 1;
+}
+
+function isTriggerEventValid(eventName) {
+ return eventName == 'start' || eventName == 'done';
+}
+
+function cloakElement(element, value) {
+ const oldValue = element.style.display;
+ element.style.display = value != null ? value : 'none';
+ return oldValue;
+}
+
+function cloakAndComputeStyles(valuesMap, driver, elements, elementPropsMap, defaultStyle) {
+ const cloakVals = [];
+ elements.forEach(element => cloakVals.push(cloakElement(element)));
+ const failedElements = [];
+ elementPropsMap.forEach((props, element) => {
+ const styles = new Map();
+ props.forEach(prop => {
+ const value = driver.computeStyle(element, prop, defaultStyle);
+ styles.set(prop, value); // there is no easy way to detect this because a sub element could be removed
+ // by a parent animation element being detached.
+
+ if (!value || value.length == 0) {
+ element[REMOVAL_FLAG] = NULL_REMOVED_QUERIED_STATE;
+ failedElements.push(element);
+ }
+ });
+ valuesMap.set(element, styles);
+ }); // we use a index variable here since Set.forEach(a, i) does not return
+ // an index value for the closure (but instead just the value)
+
+ let i = 0;
+ elements.forEach(element => cloakElement(element, cloakVals[i++]));
+ return failedElements;
+}
+/*
+Since the Angular renderer code will return a collection of inserted
+nodes in all areas of a DOM tree, it's up to this algorithm to figure
+out which nodes are roots for each animation @trigger.
+
+By placing each inserted node into a Set and traversing upwards, it
+is possible to find the @trigger elements and well any direct *star
+insertion nodes, if a @trigger root is found then the enter element
+is placed into the Map[@trigger] spot.
+ */
+
+
+function buildRootMap(roots, nodes) {
+ const rootMap = new Map();
+ roots.forEach(root => rootMap.set(root, []));
+ if (nodes.length == 0) return rootMap;
+ const NULL_NODE = 1;
+ const nodeSet = new Set(nodes);
+ const localRootMap = new Map();
+
+ function getRoot(node) {
+ if (!node) return NULL_NODE;
+ let root = localRootMap.get(node);
+ if (root) return root;
+ const parent = node.parentNode;
+
+ if (rootMap.has(parent)) {
+ // ngIf inside @trigger
+ root = parent;
+ } else if (nodeSet.has(parent)) {
+ // ngIf inside ngIf
+ root = NULL_NODE;
+ } else {
+ // recurse upwards
+ root = getRoot(parent);
+ }
+
+ localRootMap.set(node, root);
+ return root;
+ }
+
+ nodes.forEach(node => {
+ const root = getRoot(node);
+
+ if (root !== NULL_NODE) {
+ rootMap.get(root).push(node);
+ }
+ });
+ return rootMap;
+}
+
+function addClass(element, className) {
+ element.classList?.add(className);
+}
+
+function removeClass(element, className) {
+ element.classList?.remove(className);
+}
+
+function removeNodesAfterAnimationDone(engine, element, players) {
+ optimizeGroupPlayer(players).onDone(() => engine.processLeaveNode(element));
+}
+
+function flattenGroupPlayers(players) {
+ const finalPlayers = [];
+
+ _flattenGroupPlayersRecur(players, finalPlayers);
+
+ return finalPlayers;
+}
+
+function _flattenGroupPlayersRecur(players, finalPlayers) {
+ for (let i = 0; i < players.length; i++) {
+ const player = players[i];
+
+ if (player instanceof _angular_animations__WEBPACK_IMPORTED_MODULE_1__["ɵAnimationGroupPlayer"]) {
+ _flattenGroupPlayersRecur(player.players, finalPlayers);
+ } else {
+ finalPlayers.push(player);
+ }
+ }
+}
+
+function objEquals(a, b) {
+ const k1 = Object.keys(a);
+ const k2 = Object.keys(b);
+ if (k1.length != k2.length) return false;
+
+ for (let i = 0; i < k1.length; i++) {
+ const prop = k1[i];
+ if (!b.hasOwnProperty(prop) || a[prop] !== b[prop]) return false;
+ }
+
+ return true;
+}
+
+function replacePostStylesAsPre(element, allPreStyleElements, allPostStyleElements) {
+ const postEntry = allPostStyleElements.get(element);
+ if (!postEntry) return false;
+ let preEntry = allPreStyleElements.get(element);
+
+ if (preEntry) {
+ postEntry.forEach(data => preEntry.add(data));
+ } else {
+ allPreStyleElements.set(element, postEntry);
+ }
+
+ allPostStyleElements.delete(element);
+ return true;
+}
+
+class AnimationEngine {
+ constructor(bodyNode, _driver, _normalizer) {
+ this.bodyNode = bodyNode;
+ this._driver = _driver;
+ this._normalizer = _normalizer;
+ this._triggerCache = {}; // this method is designed to be overridden by the code that uses this engine
+
+ this.onRemovalComplete = (element, context) => {};
+
+ this._transitionEngine = new TransitionAnimationEngine(bodyNode, _driver, _normalizer);
+ this._timelineEngine = new TimelineAnimationEngine(bodyNode, _driver, _normalizer);
+
+ this._transitionEngine.onRemovalComplete = (element, context) => this.onRemovalComplete(element, context);
+ }
+
+ registerTrigger(componentId, namespaceId, hostElement, name, metadata) {
+ const cacheKey = componentId + '-' + name;
+ let trigger = this._triggerCache[cacheKey];
+
+ if (!trigger) {
+ const errors = [];
+ const warnings = [];
+ const ast = buildAnimationAst(this._driver, metadata, errors, warnings);
+
+ if (errors.length) {
+ throw triggerBuildFailed(name, errors);
+ }
+
+ if (warnings.length) {
+ warnTriggerBuild(name, warnings);
+ }
+
+ trigger = buildTrigger(name, ast, this._normalizer);
+ this._triggerCache[cacheKey] = trigger;
+ }
+
+ this._transitionEngine.registerTrigger(namespaceId, name, trigger);
+ }
+
+ register(namespaceId, hostElement) {
+ this._transitionEngine.register(namespaceId, hostElement);
+ }
+
+ destroy(namespaceId, context) {
+ this._transitionEngine.destroy(namespaceId, context);
+ }
+
+ onInsert(namespaceId, element, parent, insertBefore) {
+ this._transitionEngine.insertNode(namespaceId, element, parent, insertBefore);
+ }
+
+ onRemove(namespaceId, element, context, isHostElement) {
+ this._transitionEngine.removeNode(namespaceId, element, isHostElement || false, context);
+ }
+
+ disableAnimations(element, disable) {
+ this._transitionEngine.markElementAsDisabled(element, disable);
+ }
+
+ process(namespaceId, element, property, value) {
+ if (property.charAt(0) == '@') {
+ const [id, action] = parseTimelineCommand(property);
+ const args = value;
+
+ this._timelineEngine.command(id, element, action, args);
+ } else {
+ this._transitionEngine.trigger(namespaceId, element, property, value);
+ }
+ }
+
+ listen(namespaceId, element, eventName, eventPhase, callback) {
+ // @@listen
+ if (eventName.charAt(0) == '@') {
+ const [id, action] = parseTimelineCommand(eventName);
+ return this._timelineEngine.listen(id, element, action, callback);
+ }
+
+ return this._transitionEngine.listen(namespaceId, element, eventName, eventPhase, callback);
+ }
+
+ flush(microtaskId = -1) {
+ this._transitionEngine.flush(microtaskId);
+ }
+
+ get players() {
+ return this._transitionEngine.players.concat(this._timelineEngine.players);
+ }
+
+ whenRenderingDone() {
+ return this._transitionEngine.whenRenderingDone();
+ }
+
+}
+/**
+ * Returns an instance of `SpecialCasedStyles` if and when any special (non animateable) styles are
+ * detected.
+ *
+ * In CSS there exist properties that cannot be animated within a keyframe animation
+ * (whether it be via CSS keyframes or web-animations) and the animation implementation
+ * will ignore them. This function is designed to detect those special cased styles and
+ * return a container that will be executed at the start and end of the animation.
+ *
+ * @returns an instance of `SpecialCasedStyles` if any special styles are detected otherwise `null`
+ */
+
+
+function packageNonAnimatableStyles(element, styles) {
+ let startStyles = null;
+ let endStyles = null;
+
+ if (Array.isArray(styles) && styles.length) {
+ startStyles = filterNonAnimatableStyles(styles[0]);
+
+ if (styles.length > 1) {
+ endStyles = filterNonAnimatableStyles(styles[styles.length - 1]);
+ }
+ } else if (styles instanceof Map) {
+ startStyles = filterNonAnimatableStyles(styles);
+ }
+
+ return startStyles || endStyles ? new SpecialCasedStyles(element, startStyles, endStyles) : null;
+}
+/**
+ * Designed to be executed during a keyframe-based animation to apply any special-cased styles.
+ *
+ * When started (when the `start()` method is run) then the provided `startStyles`
+ * will be applied. When finished (when the `finish()` method is called) the
+ * `endStyles` will be applied as well any any starting styles. Finally when
+ * `destroy()` is called then all styles will be removed.
+ */
+
+
+class SpecialCasedStyles {
+ constructor(_element, _startStyles, _endStyles) {
+ this._element = _element;
+ this._startStyles = _startStyles;
+ this._endStyles = _endStyles;
+ this._state = 0
+ /* SpecialCasedStylesState.Pending */
+ ;
+ let initialStyles = SpecialCasedStyles.initialStylesByElement.get(_element);
+
+ if (!initialStyles) {
+ SpecialCasedStyles.initialStylesByElement.set(_element, initialStyles = new Map());
+ }
+
+ this._initialStyles = initialStyles;
+ }
+
+ start() {
+ if (this._state < 1
+ /* SpecialCasedStylesState.Started */
+ ) {
+ if (this._startStyles) {
+ setStyles(this._element, this._startStyles, this._initialStyles);
+ }
+
+ this._state = 1
+ /* SpecialCasedStylesState.Started */
+ ;
+ }
+ }
+
+ finish() {
+ this.start();
+
+ if (this._state < 2
+ /* SpecialCasedStylesState.Finished */
+ ) {
+ setStyles(this._element, this._initialStyles);
+
+ if (this._endStyles) {
+ setStyles(this._element, this._endStyles);
+ this._endStyles = null;
+ }
+
+ this._state = 1
+ /* SpecialCasedStylesState.Started */
+ ;
+ }
+ }
+
+ destroy() {
+ this.finish();
+
+ if (this._state < 3
+ /* SpecialCasedStylesState.Destroyed */
+ ) {
+ SpecialCasedStyles.initialStylesByElement.delete(this._element);
+
+ if (this._startStyles) {
+ eraseStyles(this._element, this._startStyles);
+ this._endStyles = null;
+ }
+
+ if (this._endStyles) {
+ eraseStyles(this._element, this._endStyles);
+ this._endStyles = null;
+ }
+
+ setStyles(this._element, this._initialStyles);
+ this._state = 3
+ /* SpecialCasedStylesState.Destroyed */
+ ;
+ }
+ }
+
+}
+
+SpecialCasedStyles.initialStylesByElement = /* @__PURE__ */new WeakMap();
+
+function filterNonAnimatableStyles(styles) {
+ let result = null;
+ styles.forEach((val, prop) => {
+ if (isNonAnimatableStyle(prop)) {
+ result = result || new Map();
+ result.set(prop, val);
+ }
+ });
+ return result;
+}
+
+function isNonAnimatableStyle(prop) {
+ return prop === 'display' || prop === 'position';
+}
+
+class WebAnimationsPlayer {
+ constructor(element, keyframes, options, _specialStyles) {
+ this.element = element;
+ this.keyframes = keyframes;
+ this.options = options;
+ this._specialStyles = _specialStyles;
+ this._onDoneFns = [];
+ this._onStartFns = [];
+ this._onDestroyFns = [];
+ this._initialized = false;
+ this._finished = false;
+ this._started = false;
+ this._destroyed = false; // the following original fns are persistent copies of the _onStartFns and _onDoneFns
+ // and are used to reset the fns to their original values upon reset()
+ // (since the _onStartFns and _onDoneFns get deleted after they are called)
+
+ this._originalOnDoneFns = [];
+ this._originalOnStartFns = [];
+ this.time = 0;
+ this.parentPlayer = null;
+ this.currentSnapshot = new Map();
+ this._duration = options['duration'];
+ this._delay = options['delay'] || 0;
+ this.time = this._duration + this._delay;
+ }
+
+ _onFinish() {
+ if (!this._finished) {
+ this._finished = true;
+
+ this._onDoneFns.forEach(fn => fn());
+
+ this._onDoneFns = [];
+ }
+ }
+
+ init() {
+ this._buildPlayer();
+
+ this._preparePlayerBeforeStart();
+ }
+
+ _buildPlayer() {
+ if (this._initialized) return;
+ this._initialized = true;
+ const keyframes = this.keyframes;
+ this.domPlayer = this._triggerWebAnimation(this.element, keyframes, this.options);
+ this._finalKeyframe = keyframes.length ? keyframes[keyframes.length - 1] : new Map();
+ this.domPlayer.addEventListener('finish', () => this._onFinish());
+ }
+
+ _preparePlayerBeforeStart() {
+ // this is required so that the player doesn't start to animate right away
+ if (this._delay) {
+ this._resetDomPlayerState();
+ } else {
+ this.domPlayer.pause();
+ }
+ }
+
+ _convertKeyframesToObject(keyframes) {
+ const kfs = [];
+ keyframes.forEach(frame => {
+ kfs.push(Object.fromEntries(frame));
+ });
+ return kfs;
+ }
+ /** @internal */
+
+
+ _triggerWebAnimation(element, keyframes, options) {
+ // jscompiler doesn't seem to know animate is a native property because it's not fully
+ // supported yet across common browsers (we polyfill it for Edge/Safari) [CL #143630929]
+ return element['animate'](this._convertKeyframesToObject(keyframes), options);
+ }
+
+ onStart(fn) {
+ this._originalOnStartFns.push(fn);
+
+ this._onStartFns.push(fn);
+ }
+
+ onDone(fn) {
+ this._originalOnDoneFns.push(fn);
+
+ this._onDoneFns.push(fn);
+ }
+
+ onDestroy(fn) {
+ this._onDestroyFns.push(fn);
+ }
+
+ play() {
+ this._buildPlayer();
+
+ if (!this.hasStarted()) {
+ this._onStartFns.forEach(fn => fn());
+
+ this._onStartFns = [];
+ this._started = true;
+
+ if (this._specialStyles) {
+ this._specialStyles.start();
+ }
+ }
+
+ this.domPlayer.play();
+ }
+
+ pause() {
+ this.init();
+ this.domPlayer.pause();
+ }
+
+ finish() {
+ this.init();
+
+ if (this._specialStyles) {
+ this._specialStyles.finish();
+ }
+
+ this._onFinish();
+
+ this.domPlayer.finish();
+ }
+
+ reset() {
+ this._resetDomPlayerState();
+
+ this._destroyed = false;
+ this._finished = false;
+ this._started = false;
+ this._onStartFns = this._originalOnStartFns;
+ this._onDoneFns = this._originalOnDoneFns;
+ }
+
+ _resetDomPlayerState() {
+ if (this.domPlayer) {
+ this.domPlayer.cancel();
+ }
+ }
+
+ restart() {
+ this.reset();
+ this.play();
+ }
+
+ hasStarted() {
+ return this._started;
+ }
+
+ destroy() {
+ if (!this._destroyed) {
+ this._destroyed = true;
+
+ this._resetDomPlayerState();
+
+ this._onFinish();
+
+ if (this._specialStyles) {
+ this._specialStyles.destroy();
+ }
+
+ this._onDestroyFns.forEach(fn => fn());
+
+ this._onDestroyFns = [];
+ }
+ }
+
+ setPosition(p) {
+ if (this.domPlayer === undefined) {
+ this.init();
+ }
+
+ this.domPlayer.currentTime = p * this.time;
+ }
+
+ getPosition() {
+ return this.domPlayer.currentTime / this.time;
+ }
+
+ get totalTime() {
+ return this._delay + this._duration;
+ }
+
+ beforeDestroy() {
+ const styles = new Map();
+
+ if (this.hasStarted()) {
+ // note: this code is invoked only when the `play` function was called prior to this
+ // (thus `hasStarted` returns true), this implies that the code that initializes
+ // `_finalKeyframe` has also been executed and the non-null assertion can be safely used here
+ const finalKeyframe = this._finalKeyframe;
+ finalKeyframe.forEach((val, prop) => {
+ if (prop !== 'offset') {
+ styles.set(prop, this._finished ? val : computeStyle(this.element, prop));
+ }
+ });
+ }
+
+ this.currentSnapshot = styles;
+ }
+ /** @internal */
+
+
+ triggerCallback(phaseName) {
+ const methods = phaseName === 'start' ? this._onStartFns : this._onDoneFns;
+ methods.forEach(fn => fn());
+ methods.length = 0;
+ }
+
+}
+
+class WebAnimationsDriver {
+ validateStyleProperty(prop) {
+ // Perform actual validation in dev mode only, in prod mode this check is a noop.
+ if (typeof ngDevMode === 'undefined' || ngDevMode) {
+ return validateStyleProperty(prop);
+ }
+
+ return true;
+ }
+
+ validateAnimatableStyleProperty(prop) {
+ // Perform actual validation in dev mode only, in prod mode this check is a noop.
+ if (typeof ngDevMode === 'undefined' || ngDevMode) {
+ const cssProp = camelCaseToDashCase(prop);
+ return validateWebAnimatableStyleProperty(cssProp);
+ }
+
+ return true;
+ }
+
+ matchesElement(_element, _selector) {
+ // This method is deprecated and no longer in use so we return false.
+ return false;
+ }
+
+ containsElement(elm1, elm2) {
+ return containsElement(elm1, elm2);
+ }
+
+ getParentElement(element) {
+ return getParentElement(element);
+ }
+
+ query(element, selector, multi) {
+ return invokeQuery(element, selector, multi);
+ }
+
+ computeStyle(element, prop, defaultValue) {
+ return window.getComputedStyle(element)[prop];
+ }
+
+ animate(element, keyframes, duration, delay, easing, previousPlayers = []) {
+ const fill = delay == 0 ? 'both' : 'forwards';
+ const playerOptions = {
+ duration,
+ delay,
+ fill
+ }; // we check for this to avoid having a null|undefined value be present
+ // for the easing (which results in an error for certain browsers #9752)
+
+ if (easing) {
+ playerOptions['easing'] = easing;
+ }
+
+ const previousStyles = new Map();
+ const previousWebAnimationPlayers = previousPlayers.filter(player => player instanceof WebAnimationsPlayer);
+
+ if (allowPreviousPlayerStylesMerge(duration, delay)) {
+ previousWebAnimationPlayers.forEach(player => {
+ player.currentSnapshot.forEach((val, prop) => previousStyles.set(prop, val));
+ });
+ }
+
+ let _keyframes = normalizeKeyframes(keyframes).map(styles => copyStyles(styles));
+
+ _keyframes = balancePreviousStylesIntoKeyframes(element, _keyframes, previousStyles);
+ const specialStyles = packageNonAnimatableStyles(element, _keyframes);
+ return new WebAnimationsPlayer(element, _keyframes, playerOptions, specialStyles);
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+
+
+
+/***/ }),
+
+/***/ 4218:
+/*!*****************************************************!*\
+ !*** ./node_modules/@angular/cdk/fesm2020/a11y.mjs ***!
+ \*****************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "A11yModule": () => (/* binding */ A11yModule),
+/* harmony export */ "ActiveDescendantKeyManager": () => (/* binding */ ActiveDescendantKeyManager),
+/* harmony export */ "AriaDescriber": () => (/* binding */ AriaDescriber),
+/* harmony export */ "CDK_DESCRIBEDBY_HOST_ATTRIBUTE": () => (/* binding */ CDK_DESCRIBEDBY_HOST_ATTRIBUTE),
+/* harmony export */ "CDK_DESCRIBEDBY_ID_PREFIX": () => (/* binding */ CDK_DESCRIBEDBY_ID_PREFIX),
+/* harmony export */ "CdkAriaLive": () => (/* binding */ CdkAriaLive),
+/* harmony export */ "CdkMonitorFocus": () => (/* binding */ CdkMonitorFocus),
+/* harmony export */ "CdkTrapFocus": () => (/* binding */ CdkTrapFocus),
+/* harmony export */ "ConfigurableFocusTrap": () => (/* binding */ ConfigurableFocusTrap),
+/* harmony export */ "ConfigurableFocusTrapFactory": () => (/* binding */ ConfigurableFocusTrapFactory),
+/* harmony export */ "EventListenerFocusTrapInertStrategy": () => (/* binding */ EventListenerFocusTrapInertStrategy),
+/* harmony export */ "FOCUS_MONITOR_DEFAULT_OPTIONS": () => (/* binding */ FOCUS_MONITOR_DEFAULT_OPTIONS),
+/* harmony export */ "FOCUS_TRAP_INERT_STRATEGY": () => (/* binding */ FOCUS_TRAP_INERT_STRATEGY),
+/* harmony export */ "FocusKeyManager": () => (/* binding */ FocusKeyManager),
+/* harmony export */ "FocusMonitor": () => (/* binding */ FocusMonitor),
+/* harmony export */ "FocusTrap": () => (/* binding */ FocusTrap),
+/* harmony export */ "FocusTrapFactory": () => (/* binding */ FocusTrapFactory),
+/* harmony export */ "HighContrastModeDetector": () => (/* binding */ HighContrastModeDetector),
+/* harmony export */ "INPUT_MODALITY_DETECTOR_DEFAULT_OPTIONS": () => (/* binding */ INPUT_MODALITY_DETECTOR_DEFAULT_OPTIONS),
+/* harmony export */ "INPUT_MODALITY_DETECTOR_OPTIONS": () => (/* binding */ INPUT_MODALITY_DETECTOR_OPTIONS),
+/* harmony export */ "InputModalityDetector": () => (/* binding */ InputModalityDetector),
+/* harmony export */ "InteractivityChecker": () => (/* binding */ InteractivityChecker),
+/* harmony export */ "IsFocusableConfig": () => (/* binding */ IsFocusableConfig),
+/* harmony export */ "LIVE_ANNOUNCER_DEFAULT_OPTIONS": () => (/* binding */ LIVE_ANNOUNCER_DEFAULT_OPTIONS),
+/* harmony export */ "LIVE_ANNOUNCER_ELEMENT_TOKEN": () => (/* binding */ LIVE_ANNOUNCER_ELEMENT_TOKEN),
+/* harmony export */ "LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY": () => (/* binding */ LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY),
+/* harmony export */ "ListKeyManager": () => (/* binding */ ListKeyManager),
+/* harmony export */ "LiveAnnouncer": () => (/* binding */ LiveAnnouncer),
+/* harmony export */ "MESSAGES_CONTAINER_ID": () => (/* binding */ MESSAGES_CONTAINER_ID),
+/* harmony export */ "isFakeMousedownFromScreenReader": () => (/* binding */ isFakeMousedownFromScreenReader),
+/* harmony export */ "isFakeTouchstartFromScreenReader": () => (/* binding */ isFakeTouchstartFromScreenReader)
+/* harmony export */ });
+/* harmony import */ var _angular_common__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @angular/common */ 4666);
+/* harmony import */ var _angular_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @angular/core */ 2560);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! rxjs */ 228);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! rxjs */ 6078);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! rxjs */ 6317);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! rxjs */ 745);
+/* harmony import */ var _angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! @angular/cdk/keycodes */ 8456);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! rxjs/operators */ 9337);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! rxjs/operators */ 1989);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! rxjs/operators */ 116);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! rxjs/operators */ 635);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! rxjs/operators */ 9295);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! rxjs/operators */ 7260);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! rxjs/operators */ 8977);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! rxjs/operators */ 8951);
+/* harmony import */ var _angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! @angular/cdk/coercion */ 8971);
+/* harmony import */ var _angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! @angular/cdk/platform */ 9107);
+/* harmony import */ var _angular_cdk_observers__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! @angular/cdk/observers */ 3773);
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * @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.io/license
+ */
+
+/** IDs are delimited by an empty space, as per the spec. */
+
+const ID_DELIMITER = ' ';
+/**
+ * Adds the given ID to the specified ARIA attribute on an element.
+ * Used for attributes such as aria-labelledby, aria-owns, etc.
+ */
+
+function addAriaReferencedId(el, attr, id) {
+ const ids = getAriaReferenceIds(el, attr);
+
+ if (ids.some(existingId => existingId.trim() == id.trim())) {
+ return;
+ }
+
+ ids.push(id.trim());
+ el.setAttribute(attr, ids.join(ID_DELIMITER));
+}
+/**
+ * Removes the given ID from the specified ARIA attribute on an element.
+ * Used for attributes such as aria-labelledby, aria-owns, etc.
+ */
+
+
+function removeAriaReferencedId(el, attr, id) {
+ const ids = getAriaReferenceIds(el, attr);
+ const filteredIds = ids.filter(val => val != id.trim());
+
+ if (filteredIds.length) {
+ el.setAttribute(attr, filteredIds.join(ID_DELIMITER));
+ } else {
+ el.removeAttribute(attr);
+ }
+}
+/**
+ * Gets the list of IDs referenced by the given ARIA attribute on an element.
+ * Used for attributes such as aria-labelledby, aria-owns, etc.
+ */
+
+
+function getAriaReferenceIds(el, attr) {
+ // Get string array of all individual ids (whitespace delimited) in the attribute value
+ return (el.getAttribute(attr) || '').match(/\S+/g) || [];
+}
+/**
+ * @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.io/license
+ */
+
+/** ID used for the body container where all messages are appended. */
+
+
+const MESSAGES_CONTAINER_ID = 'cdk-describedby-message-container';
+/** ID prefix used for each created message element. */
+
+const CDK_DESCRIBEDBY_ID_PREFIX = 'cdk-describedby-message';
+/** Attribute given to each host element that is described by a message element. */
+
+const CDK_DESCRIBEDBY_HOST_ATTRIBUTE = 'cdk-describedby-host';
+/** Global incremental identifier for each registered message element. */
+
+let nextId = 0;
+/** Global map of all registered message elements that have been placed into the document. */
+
+const messageRegistry = new Map();
+/** Container for all registered messages. */
+
+let messagesContainer = null;
+/**
+ * Utility that creates visually hidden elements with a message content. Useful for elements that
+ * want to use aria-describedby to further describe themselves without adding additional visual
+ * content.
+ */
+
+class AriaDescriber {
+ constructor(_document) {
+ this._document = _document;
+ }
+
+ describe(hostElement, message, role) {
+ if (!this._canBeDescribed(hostElement, message)) {
+ return;
+ }
+
+ const key = getKey(message, role);
+
+ if (typeof message !== 'string') {
+ // We need to ensure that the element has an ID.
+ setMessageId(message);
+ messageRegistry.set(key, {
+ messageElement: message,
+ referenceCount: 0
+ });
+ } else if (!messageRegistry.has(key)) {
+ this._createMessageElement(message, role);
+ }
+
+ if (!this._isElementDescribedByMessage(hostElement, key)) {
+ this._addMessageReference(hostElement, key);
+ }
+ }
+
+ removeDescription(hostElement, message, role) {
+ if (!message || !this._isElementNode(hostElement)) {
+ return;
+ }
+
+ const key = getKey(message, role);
+
+ if (this._isElementDescribedByMessage(hostElement, key)) {
+ this._removeMessageReference(hostElement, key);
+ } // If the message is a string, it means that it's one that we created for the
+ // consumer so we can remove it safely, otherwise we should leave it in place.
+
+
+ if (typeof message === 'string') {
+ const registeredMessage = messageRegistry.get(key);
+
+ if (registeredMessage && registeredMessage.referenceCount === 0) {
+ this._deleteMessageElement(key);
+ }
+ }
+
+ if (messagesContainer && messagesContainer.childNodes.length === 0) {
+ this._deleteMessagesContainer();
+ }
+ }
+ /** Unregisters all created message elements and removes the message container. */
+
+
+ ngOnDestroy() {
+ const describedElements = this._document.querySelectorAll(`[${CDK_DESCRIBEDBY_HOST_ATTRIBUTE}]`);
+
+ for (let i = 0; i < describedElements.length; i++) {
+ this._removeCdkDescribedByReferenceIds(describedElements[i]);
+
+ describedElements[i].removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);
+ }
+
+ if (messagesContainer) {
+ this._deleteMessagesContainer();
+ }
+
+ messageRegistry.clear();
+ }
+ /**
+ * Creates a new element in the visually hidden message container element with the message
+ * as its content and adds it to the message registry.
+ */
+
+
+ _createMessageElement(message, role) {
+ const messageElement = this._document.createElement('div');
+
+ setMessageId(messageElement);
+ messageElement.textContent = message;
+
+ if (role) {
+ messageElement.setAttribute('role', role);
+ }
+
+ this._createMessagesContainer();
+
+ messagesContainer.appendChild(messageElement);
+ messageRegistry.set(getKey(message, role), {
+ messageElement,
+ referenceCount: 0
+ });
+ }
+ /** Deletes the message element from the global messages container. */
+
+
+ _deleteMessageElement(key) {
+ const registeredMessage = messageRegistry.get(key);
+ registeredMessage?.messageElement?.remove();
+ messageRegistry.delete(key);
+ }
+ /** Creates the global container for all aria-describedby messages. */
+
+
+ _createMessagesContainer() {
+ if (!messagesContainer) {
+ const preExistingContainer = this._document.getElementById(MESSAGES_CONTAINER_ID); // When going from the server to the client, we may end up in a situation where there's
+ // already a container on the page, but we don't have a reference to it. Clear the
+ // old container so we don't get duplicates. Doing this, instead of emptying the previous
+ // container, should be slightly faster.
+
+
+ preExistingContainer?.remove();
+ messagesContainer = this._document.createElement('div');
+ messagesContainer.id = MESSAGES_CONTAINER_ID; // We add `visibility: hidden` in order to prevent text in this container from
+ // being searchable by the browser's Ctrl + F functionality.
+ // Screen-readers will still read the description for elements with aria-describedby even
+ // when the description element is not visible.
+
+ messagesContainer.style.visibility = 'hidden'; // Even though we use `visibility: hidden`, we still apply `cdk-visually-hidden` so that
+ // the description element doesn't impact page layout.
+
+ messagesContainer.classList.add('cdk-visually-hidden');
+
+ this._document.body.appendChild(messagesContainer);
+ }
+ }
+ /** Deletes the global messages container. */
+
+
+ _deleteMessagesContainer() {
+ if (messagesContainer) {
+ messagesContainer.remove();
+ messagesContainer = null;
+ }
+ }
+ /** Removes all cdk-describedby messages that are hosted through the element. */
+
+
+ _removeCdkDescribedByReferenceIds(element) {
+ // Remove all aria-describedby reference IDs that are prefixed by CDK_DESCRIBEDBY_ID_PREFIX
+ const originalReferenceIds = getAriaReferenceIds(element, 'aria-describedby').filter(id => id.indexOf(CDK_DESCRIBEDBY_ID_PREFIX) != 0);
+ element.setAttribute('aria-describedby', originalReferenceIds.join(' '));
+ }
+ /**
+ * Adds a message reference to the element using aria-describedby and increments the registered
+ * message's reference count.
+ */
+
+
+ _addMessageReference(element, key) {
+ const registeredMessage = messageRegistry.get(key); // Add the aria-describedby reference and set the
+ // describedby_host attribute to mark the element.
+
+ addAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);
+ element.setAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE, '');
+ registeredMessage.referenceCount++;
+ }
+ /**
+ * Removes a message reference from the element using aria-describedby
+ * and decrements the registered message's reference count.
+ */
+
+
+ _removeMessageReference(element, key) {
+ const registeredMessage = messageRegistry.get(key);
+ registeredMessage.referenceCount--;
+ removeAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);
+ element.removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);
+ }
+ /** Returns true if the element has been described by the provided message ID. */
+
+
+ _isElementDescribedByMessage(element, key) {
+ const referenceIds = getAriaReferenceIds(element, 'aria-describedby');
+ const registeredMessage = messageRegistry.get(key);
+ const messageId = registeredMessage && registeredMessage.messageElement.id;
+ return !!messageId && referenceIds.indexOf(messageId) != -1;
+ }
+ /** Determines whether a message can be described on a particular element. */
+
+
+ _canBeDescribed(element, message) {
+ if (!this._isElementNode(element)) {
+ return false;
+ }
+
+ if (message && typeof message === 'object') {
+ // We'd have to make some assumptions about the description element's text, if the consumer
+ // passed in an element. Assume that if an element is passed in, the consumer has verified
+ // that it can be used as a description.
+ return true;
+ }
+
+ const trimmedMessage = message == null ? '' : `${message}`.trim();
+ const ariaLabel = element.getAttribute('aria-label'); // We shouldn't set descriptions if they're exactly the same as the `aria-label` of the
+ // element, because screen readers will end up reading out the same text twice in a row.
+
+ return trimmedMessage ? !ariaLabel || ariaLabel.trim() !== trimmedMessage : false;
+ }
+ /** Checks whether a node is an Element node. */
+
+
+ _isElementNode(element) {
+ return element.nodeType === this._document.ELEMENT_NODE;
+ }
+
+}
+
+AriaDescriber.ɵfac = function AriaDescriber_Factory(t) {
+ return new (t || AriaDescriber)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT));
+};
+
+AriaDescriber.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjectable"]({
+ token: AriaDescriber,
+ factory: AriaDescriber.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](AriaDescriber, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT]
+ }]
+ }];
+ }, null);
+})();
+/** Gets a key that can be used to look messages up in the registry. */
+
+
+function getKey(message, role) {
+ return typeof message === 'string' ? `${role || ''}/${message}` : message;
+}
+/** Assigns a unique ID to an element, if it doesn't have one already. */
+
+
+function setMessageId(element) {
+ if (!element.id) {
+ element.id = `${CDK_DESCRIBEDBY_ID_PREFIX}-${nextId++}`;
+ }
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * This class manages keyboard events for selectable lists. If you pass it a query list
+ * of items, it will set the active item correctly when arrow events occur.
+ */
+
+
+class ListKeyManager {
+ constructor(_items) {
+ this._items = _items;
+ this._activeItemIndex = -1;
+ this._activeItem = null;
+ this._wrap = false;
+ this._letterKeyStream = new rxjs__WEBPACK_IMPORTED_MODULE_2__.Subject();
+ this._typeaheadSubscription = rxjs__WEBPACK_IMPORTED_MODULE_3__.Subscription.EMPTY;
+ this._vertical = true;
+ this._allowedModifierKeys = [];
+ this._homeAndEnd = false;
+ /**
+ * Predicate function that can be used to check whether an item should be skipped
+ * by the key manager. By default, disabled items are skipped.
+ */
+
+ this._skipPredicateFn = item => item.disabled; // Buffer for the letters that the user has pressed when the typeahead option is turned on.
+
+
+ this._pressedLetters = [];
+ /**
+ * Stream that emits any time the TAB key is pressed, so components can react
+ * when focus is shifted off of the list.
+ */
+
+ this.tabOut = new rxjs__WEBPACK_IMPORTED_MODULE_2__.Subject();
+ /** Stream that emits whenever the active item of the list manager changes. */
+
+ this.change = new rxjs__WEBPACK_IMPORTED_MODULE_2__.Subject(); // We allow for the items to be an array because, in some cases, the consumer may
+ // not have access to a QueryList of the items they want to manage (e.g. when the
+ // items aren't being collected via `ViewChildren` or `ContentChildren`).
+
+ if (_items instanceof _angular_core__WEBPACK_IMPORTED_MODULE_0__.QueryList) {
+ _items.changes.subscribe(newItems => {
+ if (this._activeItem) {
+ const itemArray = newItems.toArray();
+ const newIndex = itemArray.indexOf(this._activeItem);
+
+ if (newIndex > -1 && newIndex !== this._activeItemIndex) {
+ this._activeItemIndex = newIndex;
+ }
+ }
+ });
+ }
+ }
+ /**
+ * Sets the predicate function that determines which items should be skipped by the
+ * list key manager.
+ * @param predicate Function that determines whether the given item should be skipped.
+ */
+
+
+ skipPredicate(predicate) {
+ this._skipPredicateFn = predicate;
+ return this;
+ }
+ /**
+ * Configures wrapping mode, which determines whether the active item will wrap to
+ * the other end of list when there are no more items in the given direction.
+ * @param shouldWrap Whether the list should wrap when reaching the end.
+ */
+
+
+ withWrap(shouldWrap = true) {
+ this._wrap = shouldWrap;
+ return this;
+ }
+ /**
+ * Configures whether the key manager should be able to move the selection vertically.
+ * @param enabled Whether vertical selection should be enabled.
+ */
+
+
+ withVerticalOrientation(enabled = true) {
+ this._vertical = enabled;
+ return this;
+ }
+ /**
+ * Configures the key manager to move the selection horizontally.
+ * Passing in `null` will disable horizontal movement.
+ * @param direction Direction in which the selection can be moved.
+ */
+
+
+ withHorizontalOrientation(direction) {
+ this._horizontal = direction;
+ return this;
+ }
+ /**
+ * Modifier keys which are allowed to be held down and whose default actions will be prevented
+ * as the user is pressing the arrow keys. Defaults to not allowing any modifier keys.
+ */
+
+
+ withAllowedModifierKeys(keys) {
+ this._allowedModifierKeys = keys;
+ return this;
+ }
+ /**
+ * Turns on typeahead mode which allows users to set the active item by typing.
+ * @param debounceInterval Time to wait after the last keystroke before setting the active item.
+ */
+
+
+ withTypeAhead(debounceInterval = 200) {
+ if ((typeof ngDevMode === 'undefined' || ngDevMode) && this._items.length && this._items.some(item => typeof item.getLabel !== 'function')) {
+ throw Error('ListKeyManager items in typeahead mode must implement the `getLabel` method.');
+ }
+
+ this._typeaheadSubscription.unsubscribe(); // Debounce the presses of non-navigational keys, collect the ones that correspond to letters
+ // and convert those letters back into a string. Afterwards find the first item that starts
+ // with that string and select it.
+
+
+ this._typeaheadSubscription = this._letterKeyStream.pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_4__.tap)(letter => this._pressedLetters.push(letter)), (0,rxjs_operators__WEBPACK_IMPORTED_MODULE_5__.debounceTime)(debounceInterval), (0,rxjs_operators__WEBPACK_IMPORTED_MODULE_6__.filter)(() => this._pressedLetters.length > 0), (0,rxjs_operators__WEBPACK_IMPORTED_MODULE_7__.map)(() => this._pressedLetters.join(''))).subscribe(inputString => {
+ const items = this._getItemsArray(); // Start at 1 because we want to start searching at the item immediately
+ // following the current active item.
+
+
+ for (let i = 1; i < items.length + 1; i++) {
+ const index = (this._activeItemIndex + i) % items.length;
+ const item = items[index];
+
+ if (!this._skipPredicateFn(item) && item.getLabel().toUpperCase().trim().indexOf(inputString) === 0) {
+ this.setActiveItem(index);
+ break;
+ }
+ }
+
+ this._pressedLetters = [];
+ });
+ return this;
+ }
+ /**
+ * Configures the key manager to activate the first and last items
+ * respectively when the Home or End key is pressed.
+ * @param enabled Whether pressing the Home or End key activates the first/last item.
+ */
+
+
+ withHomeAndEnd(enabled = true) {
+ this._homeAndEnd = enabled;
+ return this;
+ }
+
+ setActiveItem(item) {
+ const previousActiveItem = this._activeItem;
+ this.updateActiveItem(item);
+
+ if (this._activeItem !== previousActiveItem) {
+ this.change.next(this._activeItemIndex);
+ }
+ }
+ /**
+ * Sets the active item depending on the key event passed in.
+ * @param event Keyboard event to be used for determining which element should be active.
+ */
+
+
+ onKeydown(event) {
+ const keyCode = event.keyCode;
+ const modifiers = ['altKey', 'ctrlKey', 'metaKey', 'shiftKey'];
+ const isModifierAllowed = modifiers.every(modifier => {
+ return !event[modifier] || this._allowedModifierKeys.indexOf(modifier) > -1;
+ });
+
+ switch (keyCode) {
+ case _angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_8__.TAB:
+ this.tabOut.next();
+ return;
+
+ case _angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_8__.DOWN_ARROW:
+ if (this._vertical && isModifierAllowed) {
+ this.setNextItemActive();
+ break;
+ } else {
+ return;
+ }
+
+ case _angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_8__.UP_ARROW:
+ if (this._vertical && isModifierAllowed) {
+ this.setPreviousItemActive();
+ break;
+ } else {
+ return;
+ }
+
+ case _angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_8__.RIGHT_ARROW:
+ if (this._horizontal && isModifierAllowed) {
+ this._horizontal === 'rtl' ? this.setPreviousItemActive() : this.setNextItemActive();
+ break;
+ } else {
+ return;
+ }
+
+ case _angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_8__.LEFT_ARROW:
+ if (this._horizontal && isModifierAllowed) {
+ this._horizontal === 'rtl' ? this.setNextItemActive() : this.setPreviousItemActive();
+ break;
+ } else {
+ return;
+ }
+
+ case _angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_8__.HOME:
+ if (this._homeAndEnd && isModifierAllowed) {
+ this.setFirstItemActive();
+ break;
+ } else {
+ return;
+ }
+
+ case _angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_8__.END:
+ if (this._homeAndEnd && isModifierAllowed) {
+ this.setLastItemActive();
+ break;
+ } else {
+ return;
+ }
+
+ default:
+ if (isModifierAllowed || (0,_angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_8__.hasModifierKey)(event, 'shiftKey')) {
+ // Attempt to use the `event.key` which also maps it to the user's keyboard language,
+ // otherwise fall back to resolving alphanumeric characters via the keyCode.
+ if (event.key && event.key.length === 1) {
+ this._letterKeyStream.next(event.key.toLocaleUpperCase());
+ } else if (keyCode >= _angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_8__.A && keyCode <= _angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_8__.Z || keyCode >= _angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_8__.ZERO && keyCode <= _angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_8__.NINE) {
+ this._letterKeyStream.next(String.fromCharCode(keyCode));
+ }
+ } // Note that we return here, in order to avoid preventing
+ // the default action of non-navigational keys.
+
+
+ return;
+ }
+
+ this._pressedLetters = [];
+ event.preventDefault();
+ }
+ /** Index of the currently active item. */
+
+
+ get activeItemIndex() {
+ return this._activeItemIndex;
+ }
+ /** The active item. */
+
+
+ get activeItem() {
+ return this._activeItem;
+ }
+ /** Gets whether the user is currently typing into the manager using the typeahead feature. */
+
+
+ isTyping() {
+ return this._pressedLetters.length > 0;
+ }
+ /** Sets the active item to the first enabled item in the list. */
+
+
+ setFirstItemActive() {
+ this._setActiveItemByIndex(0, 1);
+ }
+ /** Sets the active item to the last enabled item in the list. */
+
+
+ setLastItemActive() {
+ this._setActiveItemByIndex(this._items.length - 1, -1);
+ }
+ /** Sets the active item to the next enabled item in the list. */
+
+
+ setNextItemActive() {
+ this._activeItemIndex < 0 ? this.setFirstItemActive() : this._setActiveItemByDelta(1);
+ }
+ /** Sets the active item to a previous enabled item in the list. */
+
+
+ setPreviousItemActive() {
+ this._activeItemIndex < 0 && this._wrap ? this.setLastItemActive() : this._setActiveItemByDelta(-1);
+ }
+
+ updateActiveItem(item) {
+ const itemArray = this._getItemsArray();
+
+ const index = typeof item === 'number' ? item : itemArray.indexOf(item);
+ const activeItem = itemArray[index]; // Explicitly check for `null` and `undefined` because other falsy values are valid.
+
+ this._activeItem = activeItem == null ? null : activeItem;
+ this._activeItemIndex = index;
+ }
+ /**
+ * This method sets the active item, given a list of items and the delta between the
+ * currently active item and the new active item. It will calculate differently
+ * depending on whether wrap mode is turned on.
+ */
+
+
+ _setActiveItemByDelta(delta) {
+ this._wrap ? this._setActiveInWrapMode(delta) : this._setActiveInDefaultMode(delta);
+ }
+ /**
+ * Sets the active item properly given "wrap" mode. In other words, it will continue to move
+ * down the list until it finds an item that is not disabled, and it will wrap if it
+ * encounters either end of the list.
+ */
+
+
+ _setActiveInWrapMode(delta) {
+ const items = this._getItemsArray();
+
+ for (let i = 1; i <= items.length; i++) {
+ const index = (this._activeItemIndex + delta * i + items.length) % items.length;
+ const item = items[index];
+
+ if (!this._skipPredicateFn(item)) {
+ this.setActiveItem(index);
+ return;
+ }
+ }
+ }
+ /**
+ * Sets the active item properly given the default mode. In other words, it will
+ * continue to move down the list until it finds an item that is not disabled. If
+ * it encounters either end of the list, it will stop and not wrap.
+ */
+
+
+ _setActiveInDefaultMode(delta) {
+ this._setActiveItemByIndex(this._activeItemIndex + delta, delta);
+ }
+ /**
+ * Sets the active item to the first enabled item starting at the index specified. If the
+ * item is disabled, it will move in the fallbackDelta direction until it either
+ * finds an enabled item or encounters the end of the list.
+ */
+
+
+ _setActiveItemByIndex(index, fallbackDelta) {
+ const items = this._getItemsArray();
+
+ if (!items[index]) {
+ return;
+ }
+
+ while (this._skipPredicateFn(items[index])) {
+ index += fallbackDelta;
+
+ if (!items[index]) {
+ return;
+ }
+ }
+
+ this.setActiveItem(index);
+ }
+ /** Returns the items as an array. */
+
+
+ _getItemsArray() {
+ return this._items instanceof _angular_core__WEBPACK_IMPORTED_MODULE_0__.QueryList ? this._items.toArray() : this._items;
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+
+class ActiveDescendantKeyManager extends ListKeyManager {
+ setActiveItem(index) {
+ if (this.activeItem) {
+ this.activeItem.setInactiveStyles();
+ }
+
+ super.setActiveItem(index);
+
+ if (this.activeItem) {
+ this.activeItem.setActiveStyles();
+ }
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+
+class FocusKeyManager extends ListKeyManager {
+ constructor() {
+ super(...arguments);
+ this._origin = 'program';
+ }
+ /**
+ * Sets the focus origin that will be passed in to the items for any subsequent `focus` calls.
+ * @param origin Focus origin to be used when focusing items.
+ */
+
+
+ setFocusOrigin(origin) {
+ this._origin = origin;
+ return this;
+ }
+
+ setActiveItem(item) {
+ super.setActiveItem(item);
+
+ if (this.activeItem) {
+ this.activeItem.focus(this._origin);
+ }
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * Configuration for the isFocusable method.
+ */
+
+
+class IsFocusableConfig {
+ constructor() {
+ /**
+ * Whether to count an element as focusable even if it is not currently visible.
+ */
+ this.ignoreVisibility = false;
+ }
+
+} // The InteractivityChecker leans heavily on the ally.js accessibility utilities.
+// Methods like `isTabbable` are only covering specific edge-cases for the browsers which are
+// supported.
+
+/**
+ * Utility for checking the interactivity of an element, such as whether is is focusable or
+ * tabbable.
+ */
+
+
+class InteractivityChecker {
+ constructor(_platform) {
+ this._platform = _platform;
+ }
+ /**
+ * Gets whether an element is disabled.
+ *
+ * @param element Element to be checked.
+ * @returns Whether the element is disabled.
+ */
+
+
+ isDisabled(element) {
+ // This does not capture some cases, such as a non-form control with a disabled attribute or
+ // a form control inside of a disabled form, but should capture the most common cases.
+ return element.hasAttribute('disabled');
+ }
+ /**
+ * Gets whether an element is visible for the purposes of interactivity.
+ *
+ * This will capture states like `display: none` and `visibility: hidden`, but not things like
+ * being clipped by an `overflow: hidden` parent or being outside the viewport.
+ *
+ * @returns Whether the element is visible.
+ */
+
+
+ isVisible(element) {
+ return hasGeometry(element) && getComputedStyle(element).visibility === 'visible';
+ }
+ /**
+ * Gets whether an element can be reached via Tab key.
+ * Assumes that the element has already been checked with isFocusable.
+ *
+ * @param element Element to be checked.
+ * @returns Whether the element is tabbable.
+ */
+
+
+ isTabbable(element) {
+ // Nothing is tabbable on the server 😎
+ if (!this._platform.isBrowser) {
+ return false;
+ }
+
+ const frameElement = getFrameElement(getWindow(element));
+
+ if (frameElement) {
+ // Frame elements inherit their tabindex onto all child elements.
+ if (getTabIndexValue(frameElement) === -1) {
+ return false;
+ } // Browsers disable tabbing to an element inside of an invisible frame.
+
+
+ if (!this.isVisible(frameElement)) {
+ return false;
+ }
+ }
+
+ let nodeName = element.nodeName.toLowerCase();
+ let tabIndexValue = getTabIndexValue(element);
+
+ if (element.hasAttribute('contenteditable')) {
+ return tabIndexValue !== -1;
+ }
+
+ if (nodeName === 'iframe' || nodeName === 'object') {
+ // The frame or object's content may be tabbable depending on the content, but it's
+ // not possibly to reliably detect the content of the frames. We always consider such
+ // elements as non-tabbable.
+ return false;
+ } // In iOS, the browser only considers some specific elements as tabbable.
+
+
+ if (this._platform.WEBKIT && this._platform.IOS && !isPotentiallyTabbableIOS(element)) {
+ return false;
+ }
+
+ if (nodeName === 'audio') {
+ // Audio elements without controls enabled are never tabbable, regardless
+ // of the tabindex attribute explicitly being set.
+ if (!element.hasAttribute('controls')) {
+ return false;
+ } // Audio elements with controls are by default tabbable unless the
+ // tabindex attribute is set to `-1` explicitly.
+
+
+ return tabIndexValue !== -1;
+ }
+
+ if (nodeName === 'video') {
+ // For all video elements, if the tabindex attribute is set to `-1`, the video
+ // is not tabbable. Note: We cannot rely on the default `HTMLElement.tabIndex`
+ // property as that one is set to `-1` in Chrome, Edge and Safari v13.1. The
+ // tabindex attribute is the source of truth here.
+ if (tabIndexValue === -1) {
+ return false;
+ } // If the tabindex is explicitly set, and not `-1` (as per check before), the
+ // video element is always tabbable (regardless of whether it has controls or not).
+
+
+ if (tabIndexValue !== null) {
+ return true;
+ } // Otherwise (when no explicit tabindex is set), a video is only tabbable if it
+ // has controls enabled. Firefox is special as videos are always tabbable regardless
+ // of whether there are controls or not.
+
+
+ return this._platform.FIREFOX || element.hasAttribute('controls');
+ }
+
+ return element.tabIndex >= 0;
+ }
+ /**
+ * Gets whether an element can be focused by the user.
+ *
+ * @param element Element to be checked.
+ * @param config The config object with options to customize this method's behavior
+ * @returns Whether the element is focusable.
+ */
+
+
+ isFocusable(element, config) {
+ // Perform checks in order of left to most expensive.
+ // Again, naive approach that does not capture many edge cases and browser quirks.
+ return isPotentiallyFocusable(element) && !this.isDisabled(element) && (config?.ignoreVisibility || this.isVisible(element));
+ }
+
+}
+
+InteractivityChecker.ɵfac = function InteractivityChecker_Factory(t) {
+ return new (t || InteractivityChecker)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.Platform));
+};
+
+InteractivityChecker.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjectable"]({
+ token: InteractivityChecker,
+ factory: InteractivityChecker.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](InteractivityChecker, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: _angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.Platform
+ }];
+ }, null);
+})();
+/**
+ * Returns the frame element from a window object. Since browsers like MS Edge throw errors if
+ * the frameElement property is being accessed from a different host address, this property
+ * should be accessed carefully.
+ */
+
+
+function getFrameElement(window) {
+ try {
+ return window.frameElement;
+ } catch {
+ return null;
+ }
+}
+/** Checks whether the specified element has any geometry / rectangles. */
+
+
+function hasGeometry(element) {
+ // Use logic from jQuery to check for an invisible element.
+ // See https://github.com/jquery/jquery/blob/master/src/css/hiddenVisibleSelectors.js#L12
+ return !!(element.offsetWidth || element.offsetHeight || typeof element.getClientRects === 'function' && element.getClientRects().length);
+}
+/** Gets whether an element's */
+
+
+function isNativeFormElement(element) {
+ let nodeName = element.nodeName.toLowerCase();
+ return nodeName === 'input' || nodeName === 'select' || nodeName === 'button' || nodeName === 'textarea';
+}
+/** Gets whether an element is an ``. */
+
+
+function isHiddenInput(element) {
+ return isInputElement(element) && element.type == 'hidden';
+}
+/** Gets whether an element is an anchor that has an href attribute. */
+
+
+function isAnchorWithHref(element) {
+ return isAnchorElement(element) && element.hasAttribute('href');
+}
+/** Gets whether an element is an input element. */
+
+
+function isInputElement(element) {
+ return element.nodeName.toLowerCase() == 'input';
+}
+/** Gets whether an element is an anchor element. */
+
+
+function isAnchorElement(element) {
+ return element.nodeName.toLowerCase() == 'a';
+}
+/** Gets whether an element has a valid tabindex. */
+
+
+function hasValidTabIndex(element) {
+ if (!element.hasAttribute('tabindex') || element.tabIndex === undefined) {
+ return false;
+ }
+
+ let tabIndex = element.getAttribute('tabindex');
+ return !!(tabIndex && !isNaN(parseInt(tabIndex, 10)));
+}
+/**
+ * Returns the parsed tabindex from the element attributes instead of returning the
+ * evaluated tabindex from the browsers defaults.
+ */
+
+
+function getTabIndexValue(element) {
+ if (!hasValidTabIndex(element)) {
+ return null;
+ } // See browser issue in Gecko https://bugzilla.mozilla.org/show_bug.cgi?id=1128054
+
+
+ const tabIndex = parseInt(element.getAttribute('tabindex') || '', 10);
+ return isNaN(tabIndex) ? -1 : tabIndex;
+}
+/** Checks whether the specified element is potentially tabbable on iOS */
+
+
+function isPotentiallyTabbableIOS(element) {
+ let nodeName = element.nodeName.toLowerCase();
+ let inputType = nodeName === 'input' && element.type;
+ return inputType === 'text' || inputType === 'password' || nodeName === 'select' || nodeName === 'textarea';
+}
+/**
+ * Gets whether an element is potentially focusable without taking current visible/disabled state
+ * into account.
+ */
+
+
+function isPotentiallyFocusable(element) {
+ // Inputs are potentially focusable *unless* they're type="hidden".
+ if (isHiddenInput(element)) {
+ return false;
+ }
+
+ return isNativeFormElement(element) || isAnchorWithHref(element) || element.hasAttribute('contenteditable') || hasValidTabIndex(element);
+}
+/** Gets the parent window of a DOM node with regards of being inside of an iframe. */
+
+
+function getWindow(node) {
+ // ownerDocument is null if `node` itself *is* a document.
+ return node.ownerDocument && node.ownerDocument.defaultView || window;
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * Class that allows for trapping focus within a DOM element.
+ *
+ * This class currently uses a relatively simple approach to focus trapping.
+ * It assumes that the tab order is the same as DOM order, which is not necessarily true.
+ * Things like `tabIndex > 0`, flex `order`, and shadow roots can cause the two to be misaligned.
+ *
+ * @deprecated Use `ConfigurableFocusTrap` instead.
+ * @breaking-change 11.0.0
+ */
+
+
+class FocusTrap {
+ constructor(_element, _checker, _ngZone, _document, deferAnchors = false) {
+ this._element = _element;
+ this._checker = _checker;
+ this._ngZone = _ngZone;
+ this._document = _document;
+ this._hasAttached = false; // Event listeners for the anchors. Need to be regular functions so that we can unbind them later.
+
+ this.startAnchorListener = () => this.focusLastTabbableElement();
+
+ this.endAnchorListener = () => this.focusFirstTabbableElement();
+
+ this._enabled = true;
+
+ if (!deferAnchors) {
+ this.attachAnchors();
+ }
+ }
+ /** Whether the focus trap is active. */
+
+
+ get enabled() {
+ return this._enabled;
+ }
+
+ set enabled(value) {
+ this._enabled = value;
+
+ if (this._startAnchor && this._endAnchor) {
+ this._toggleAnchorTabIndex(value, this._startAnchor);
+
+ this._toggleAnchorTabIndex(value, this._endAnchor);
+ }
+ }
+ /** Destroys the focus trap by cleaning up the anchors. */
+
+
+ destroy() {
+ const startAnchor = this._startAnchor;
+ const endAnchor = this._endAnchor;
+
+ if (startAnchor) {
+ startAnchor.removeEventListener('focus', this.startAnchorListener);
+ startAnchor.remove();
+ }
+
+ if (endAnchor) {
+ endAnchor.removeEventListener('focus', this.endAnchorListener);
+ endAnchor.remove();
+ }
+
+ this._startAnchor = this._endAnchor = null;
+ this._hasAttached = false;
+ }
+ /**
+ * Inserts the anchors into the DOM. This is usually done automatically
+ * in the constructor, but can be deferred for cases like directives with `*ngIf`.
+ * @returns Whether the focus trap managed to attach successfully. This may not be the case
+ * if the target element isn't currently in the DOM.
+ */
+
+
+ attachAnchors() {
+ // If we're not on the browser, there can be no focus to trap.
+ if (this._hasAttached) {
+ return true;
+ }
+
+ this._ngZone.runOutsideAngular(() => {
+ if (!this._startAnchor) {
+ this._startAnchor = this._createAnchor();
+
+ this._startAnchor.addEventListener('focus', this.startAnchorListener);
+ }
+
+ if (!this._endAnchor) {
+ this._endAnchor = this._createAnchor();
+
+ this._endAnchor.addEventListener('focus', this.endAnchorListener);
+ }
+ });
+
+ if (this._element.parentNode) {
+ this._element.parentNode.insertBefore(this._startAnchor, this._element);
+
+ this._element.parentNode.insertBefore(this._endAnchor, this._element.nextSibling);
+
+ this._hasAttached = true;
+ }
+
+ return this._hasAttached;
+ }
+ /**
+ * Waits for the zone to stabilize, then focuses the first tabbable element.
+ * @returns Returns a promise that resolves with a boolean, depending
+ * on whether focus was moved successfully.
+ */
+
+
+ focusInitialElementWhenReady(options) {
+ return new Promise(resolve => {
+ this._executeOnStable(() => resolve(this.focusInitialElement(options)));
+ });
+ }
+ /**
+ * Waits for the zone to stabilize, then focuses
+ * the first tabbable element within the focus trap region.
+ * @returns Returns a promise that resolves with a boolean, depending
+ * on whether focus was moved successfully.
+ */
+
+
+ focusFirstTabbableElementWhenReady(options) {
+ return new Promise(resolve => {
+ this._executeOnStable(() => resolve(this.focusFirstTabbableElement(options)));
+ });
+ }
+ /**
+ * Waits for the zone to stabilize, then focuses
+ * the last tabbable element within the focus trap region.
+ * @returns Returns a promise that resolves with a boolean, depending
+ * on whether focus was moved successfully.
+ */
+
+
+ focusLastTabbableElementWhenReady(options) {
+ return new Promise(resolve => {
+ this._executeOnStable(() => resolve(this.focusLastTabbableElement(options)));
+ });
+ }
+ /**
+ * Get the specified boundary element of the trapped region.
+ * @param bound The boundary to get (start or end of trapped region).
+ * @returns The boundary element.
+ */
+
+
+ _getRegionBoundary(bound) {
+ // Contains the deprecated version of selector, for temporary backwards comparability.
+ let markers = this._element.querySelectorAll(`[cdk-focus-region-${bound}], ` + `[cdkFocusRegion${bound}], ` + `[cdk-focus-${bound}]`);
+
+ for (let i = 0; i < markers.length; i++) {
+ // @breaking-change 8.0.0
+ if (markers[i].hasAttribute(`cdk-focus-${bound}`)) {
+ console.warn(`Found use of deprecated attribute 'cdk-focus-${bound}', ` + `use 'cdkFocusRegion${bound}' instead. The deprecated ` + `attribute will be removed in 8.0.0.`, markers[i]);
+ } else if (markers[i].hasAttribute(`cdk-focus-region-${bound}`)) {
+ console.warn(`Found use of deprecated attribute 'cdk-focus-region-${bound}', ` + `use 'cdkFocusRegion${bound}' instead. The deprecated attribute ` + `will be removed in 8.0.0.`, markers[i]);
+ }
+ }
+
+ if (bound == 'start') {
+ return markers.length ? markers[0] : this._getFirstTabbableElement(this._element);
+ }
+
+ return markers.length ? markers[markers.length - 1] : this._getLastTabbableElement(this._element);
+ }
+ /**
+ * Focuses the element that should be focused when the focus trap is initialized.
+ * @returns Whether focus was moved successfully.
+ */
+
+
+ focusInitialElement(options) {
+ // Contains the deprecated version of selector, for temporary backwards comparability.
+ const redirectToElement = this._element.querySelector(`[cdk-focus-initial], ` + `[cdkFocusInitial]`);
+
+ if (redirectToElement) {
+ // @breaking-change 8.0.0
+ if (redirectToElement.hasAttribute(`cdk-focus-initial`)) {
+ console.warn(`Found use of deprecated attribute 'cdk-focus-initial', ` + `use 'cdkFocusInitial' instead. The deprecated attribute ` + `will be removed in 8.0.0`, redirectToElement);
+ } // Warn the consumer if the element they've pointed to
+ // isn't focusable, when not in production mode.
+
+
+ if ((typeof ngDevMode === 'undefined' || ngDevMode) && !this._checker.isFocusable(redirectToElement)) {
+ console.warn(`Element matching '[cdkFocusInitial]' is not focusable.`, redirectToElement);
+ }
+
+ if (!this._checker.isFocusable(redirectToElement)) {
+ const focusableChild = this._getFirstTabbableElement(redirectToElement);
+
+ focusableChild?.focus(options);
+ return !!focusableChild;
+ }
+
+ redirectToElement.focus(options);
+ return true;
+ }
+
+ return this.focusFirstTabbableElement(options);
+ }
+ /**
+ * Focuses the first tabbable element within the focus trap region.
+ * @returns Whether focus was moved successfully.
+ */
+
+
+ focusFirstTabbableElement(options) {
+ const redirectToElement = this._getRegionBoundary('start');
+
+ if (redirectToElement) {
+ redirectToElement.focus(options);
+ }
+
+ return !!redirectToElement;
+ }
+ /**
+ * Focuses the last tabbable element within the focus trap region.
+ * @returns Whether focus was moved successfully.
+ */
+
+
+ focusLastTabbableElement(options) {
+ const redirectToElement = this._getRegionBoundary('end');
+
+ if (redirectToElement) {
+ redirectToElement.focus(options);
+ }
+
+ return !!redirectToElement;
+ }
+ /**
+ * Checks whether the focus trap has successfully been attached.
+ */
+
+
+ hasAttached() {
+ return this._hasAttached;
+ }
+ /** Get the first tabbable element from a DOM subtree (inclusive). */
+
+
+ _getFirstTabbableElement(root) {
+ if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {
+ return root;
+ }
+
+ const children = root.children;
+
+ for (let i = 0; i < children.length; i++) {
+ const tabbableChild = children[i].nodeType === this._document.ELEMENT_NODE ? this._getFirstTabbableElement(children[i]) : null;
+
+ if (tabbableChild) {
+ return tabbableChild;
+ }
+ }
+
+ return null;
+ }
+ /** Get the last tabbable element from a DOM subtree (inclusive). */
+
+
+ _getLastTabbableElement(root) {
+ if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {
+ return root;
+ } // Iterate in reverse DOM order.
+
+
+ const children = root.children;
+
+ for (let i = children.length - 1; i >= 0; i--) {
+ const tabbableChild = children[i].nodeType === this._document.ELEMENT_NODE ? this._getLastTabbableElement(children[i]) : null;
+
+ if (tabbableChild) {
+ return tabbableChild;
+ }
+ }
+
+ return null;
+ }
+ /** Creates an anchor element. */
+
+
+ _createAnchor() {
+ const anchor = this._document.createElement('div');
+
+ this._toggleAnchorTabIndex(this._enabled, anchor);
+
+ anchor.classList.add('cdk-visually-hidden');
+ anchor.classList.add('cdk-focus-trap-anchor');
+ anchor.setAttribute('aria-hidden', 'true');
+ return anchor;
+ }
+ /**
+ * Toggles the `tabindex` of an anchor, based on the enabled state of the focus trap.
+ * @param isEnabled Whether the focus trap is enabled.
+ * @param anchor Anchor on which to toggle the tabindex.
+ */
+
+
+ _toggleAnchorTabIndex(isEnabled, anchor) {
+ // Remove the tabindex completely, rather than setting it to -1, because if the
+ // element has a tabindex, the user might still hit it when navigating with the arrow keys.
+ isEnabled ? anchor.setAttribute('tabindex', '0') : anchor.removeAttribute('tabindex');
+ }
+ /**
+ * Toggles the`tabindex` of both anchors to either trap Tab focus or allow it to escape.
+ * @param enabled: Whether the anchors should trap Tab.
+ */
+
+
+ toggleAnchors(enabled) {
+ if (this._startAnchor && this._endAnchor) {
+ this._toggleAnchorTabIndex(enabled, this._startAnchor);
+
+ this._toggleAnchorTabIndex(enabled, this._endAnchor);
+ }
+ }
+ /** Executes a function when the zone is stable. */
+
+
+ _executeOnStable(fn) {
+ if (this._ngZone.isStable) {
+ fn();
+ } else {
+ this._ngZone.onStable.pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_10__.take)(1)).subscribe(fn);
+ }
+ }
+
+}
+/**
+ * Factory that allows easy instantiation of focus traps.
+ * @deprecated Use `ConfigurableFocusTrapFactory` instead.
+ * @breaking-change 11.0.0
+ */
+
+
+class FocusTrapFactory {
+ constructor(_checker, _ngZone, _document) {
+ this._checker = _checker;
+ this._ngZone = _ngZone;
+ this._document = _document;
+ }
+ /**
+ * Creates a focus-trapped region around the given element.
+ * @param element The element around which focus will be trapped.
+ * @param deferCaptureElements Defers the creation of focus-capturing elements to be done
+ * manually by the user.
+ * @returns The created focus trap instance.
+ */
+
+
+ create(element, deferCaptureElements = false) {
+ return new FocusTrap(element, this._checker, this._ngZone, this._document, deferCaptureElements);
+ }
+
+}
+
+FocusTrapFactory.ɵfac = function FocusTrapFactory_Factory(t) {
+ return new (t || FocusTrapFactory)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](InteractivityChecker), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT));
+};
+
+FocusTrapFactory.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjectable"]({
+ token: FocusTrapFactory,
+ factory: FocusTrapFactory.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](FocusTrapFactory, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: InteractivityChecker
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone
+ }, {
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT]
+ }]
+ }];
+ }, null);
+})();
+/** Directive for trapping focus within a region. */
+
+
+class CdkTrapFocus {
+ constructor(_elementRef, _focusTrapFactory,
+ /**
+ * @deprecated No longer being used. To be removed.
+ * @breaking-change 13.0.0
+ */
+ _document) {
+ this._elementRef = _elementRef;
+ this._focusTrapFactory = _focusTrapFactory;
+ /** Previously focused element to restore focus to upon destroy when using autoCapture. */
+
+ this._previouslyFocusedElement = null;
+ this.focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement, true);
+ }
+ /** Whether the focus trap is active. */
+
+
+ get enabled() {
+ return this.focusTrap.enabled;
+ }
+
+ set enabled(value) {
+ this.focusTrap.enabled = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_11__.coerceBooleanProperty)(value);
+ }
+ /**
+ * Whether the directive should automatically move focus into the trapped region upon
+ * initialization and return focus to the previous activeElement upon destruction.
+ */
+
+
+ get autoCapture() {
+ return this._autoCapture;
+ }
+
+ set autoCapture(value) {
+ this._autoCapture = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_11__.coerceBooleanProperty)(value);
+ }
+
+ ngOnDestroy() {
+ this.focusTrap.destroy(); // If we stored a previously focused element when using autoCapture, return focus to that
+ // element now that the trapped region is being destroyed.
+
+ if (this._previouslyFocusedElement) {
+ this._previouslyFocusedElement.focus();
+
+ this._previouslyFocusedElement = null;
+ }
+ }
+
+ ngAfterContentInit() {
+ this.focusTrap.attachAnchors();
+
+ if (this.autoCapture) {
+ this._captureFocus();
+ }
+ }
+
+ ngDoCheck() {
+ if (!this.focusTrap.hasAttached()) {
+ this.focusTrap.attachAnchors();
+ }
+ }
+
+ ngOnChanges(changes) {
+ const autoCaptureChange = changes['autoCapture'];
+
+ if (autoCaptureChange && !autoCaptureChange.firstChange && this.autoCapture && this.focusTrap.hasAttached()) {
+ this._captureFocus();
+ }
+ }
+
+ _captureFocus() {
+ this._previouslyFocusedElement = (0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__._getFocusedElementPierceShadowDom)();
+ this.focusTrap.focusInitialElementWhenReady();
+ }
+
+}
+
+CdkTrapFocus.ɵfac = function CdkTrapFocus_Factory(t) {
+ return new (t || CdkTrapFocus)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.ElementRef), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](FocusTrapFactory), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT));
+};
+
+CdkTrapFocus.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineDirective"]({
+ type: CdkTrapFocus,
+ selectors: [["", "cdkTrapFocus", ""]],
+ inputs: {
+ enabled: ["cdkTrapFocus", "enabled"],
+ autoCapture: ["cdkTrapFocusAutoCapture", "autoCapture"]
+ },
+ exportAs: ["cdkTrapFocus"],
+ features: [_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵNgOnChangesFeature"]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](CdkTrapFocus, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Directive,
+ args: [{
+ selector: '[cdkTrapFocus]',
+ exportAs: 'cdkTrapFocus'
+ }]
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.ElementRef
+ }, {
+ type: FocusTrapFactory
+ }, {
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT]
+ }]
+ }];
+ }, {
+ enabled: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Input,
+ args: ['cdkTrapFocus']
+ }],
+ autoCapture: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Input,
+ args: ['cdkTrapFocusAutoCapture']
+ }]
+ });
+})();
+/**
+ * @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.io/license
+ */
+
+/**
+ * Class that allows for trapping focus within a DOM element.
+ *
+ * This class uses a strategy pattern that determines how it traps focus.
+ * See FocusTrapInertStrategy.
+ */
+
+
+class ConfigurableFocusTrap extends FocusTrap {
+ constructor(_element, _checker, _ngZone, _document, _focusTrapManager, _inertStrategy, config) {
+ super(_element, _checker, _ngZone, _document, config.defer);
+ this._focusTrapManager = _focusTrapManager;
+ this._inertStrategy = _inertStrategy;
+
+ this._focusTrapManager.register(this);
+ }
+ /** Whether the FocusTrap is enabled. */
+
+
+ get enabled() {
+ return this._enabled;
+ }
+
+ set enabled(value) {
+ this._enabled = value;
+
+ if (this._enabled) {
+ this._focusTrapManager.register(this);
+ } else {
+ this._focusTrapManager.deregister(this);
+ }
+ }
+ /** Notifies the FocusTrapManager that this FocusTrap will be destroyed. */
+
+
+ destroy() {
+ this._focusTrapManager.deregister(this);
+
+ super.destroy();
+ }
+ /** @docs-private Implemented as part of ManagedFocusTrap. */
+
+
+ _enable() {
+ this._inertStrategy.preventFocus(this);
+
+ this.toggleAnchors(true);
+ }
+ /** @docs-private Implemented as part of ManagedFocusTrap. */
+
+
+ _disable() {
+ this._inertStrategy.allowFocus(this);
+
+ this.toggleAnchors(false);
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/** The injection token used to specify the inert strategy. */
+
+
+const FOCUS_TRAP_INERT_STRATEGY = new _angular_core__WEBPACK_IMPORTED_MODULE_0__.InjectionToken('FOCUS_TRAP_INERT_STRATEGY');
+/**
+ * @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.io/license
+ */
+
+/**
+ * Lightweight FocusTrapInertStrategy that adds a document focus event
+ * listener to redirect focus back inside the FocusTrap.
+ */
+
+class EventListenerFocusTrapInertStrategy {
+ constructor() {
+ /** Focus event handler. */
+ this._listener = null;
+ }
+ /** Adds a document event listener that keeps focus inside the FocusTrap. */
+
+
+ preventFocus(focusTrap) {
+ // Ensure there's only one listener per document
+ if (this._listener) {
+ focusTrap._document.removeEventListener('focus', this._listener, true);
+ }
+
+ this._listener = e => this._trapFocus(focusTrap, e);
+
+ focusTrap._ngZone.runOutsideAngular(() => {
+ focusTrap._document.addEventListener('focus', this._listener, true);
+ });
+ }
+ /** Removes the event listener added in preventFocus. */
+
+
+ allowFocus(focusTrap) {
+ if (!this._listener) {
+ return;
+ }
+
+ focusTrap._document.removeEventListener('focus', this._listener, true);
+
+ this._listener = null;
+ }
+ /**
+ * Refocuses the first element in the FocusTrap if the focus event target was outside
+ * the FocusTrap.
+ *
+ * This is an event listener callback. The event listener is added in runOutsideAngular,
+ * so all this code runs outside Angular as well.
+ */
+
+
+ _trapFocus(focusTrap, event) {
+ const target = event.target;
+ const focusTrapRoot = focusTrap._element; // Don't refocus if target was in an overlay, because the overlay might be associated
+ // with an element inside the FocusTrap, ex. mat-select.
+
+ if (target && !focusTrapRoot.contains(target) && !target.closest?.('div.cdk-overlay-pane')) {
+ // Some legacy FocusTrap usages have logic that focuses some element on the page
+ // just before FocusTrap is destroyed. For backwards compatibility, wait
+ // to be sure FocusTrap is still enabled before refocusing.
+ setTimeout(() => {
+ // Check whether focus wasn't put back into the focus trap while the timeout was pending.
+ if (focusTrap.enabled && !focusTrapRoot.contains(focusTrap._document.activeElement)) {
+ focusTrap.focusFirstTabbableElement();
+ }
+ });
+ }
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+/** Injectable that ensures only the most recently enabled FocusTrap is active. */
+
+
+class FocusTrapManager {
+ constructor() {
+ // A stack of the FocusTraps on the page. Only the FocusTrap at the
+ // top of the stack is active.
+ this._focusTrapStack = [];
+ }
+ /**
+ * Disables the FocusTrap at the top of the stack, and then pushes
+ * the new FocusTrap onto the stack.
+ */
+
+
+ register(focusTrap) {
+ // Dedupe focusTraps that register multiple times.
+ this._focusTrapStack = this._focusTrapStack.filter(ft => ft !== focusTrap);
+ let stack = this._focusTrapStack;
+
+ if (stack.length) {
+ stack[stack.length - 1]._disable();
+ }
+
+ stack.push(focusTrap);
+
+ focusTrap._enable();
+ }
+ /**
+ * Removes the FocusTrap from the stack, and activates the
+ * FocusTrap that is the new top of the stack.
+ */
+
+
+ deregister(focusTrap) {
+ focusTrap._disable();
+
+ const stack = this._focusTrapStack;
+ const i = stack.indexOf(focusTrap);
+
+ if (i !== -1) {
+ stack.splice(i, 1);
+
+ if (stack.length) {
+ stack[stack.length - 1]._enable();
+ }
+ }
+ }
+
+}
+
+FocusTrapManager.ɵfac = function FocusTrapManager_Factory(t) {
+ return new (t || FocusTrapManager)();
+};
+
+FocusTrapManager.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjectable"]({
+ token: FocusTrapManager,
+ factory: FocusTrapManager.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](FocusTrapManager, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], null, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/** Factory that allows easy instantiation of configurable focus traps. */
+
+
+class ConfigurableFocusTrapFactory {
+ constructor(_checker, _ngZone, _focusTrapManager, _document, _inertStrategy) {
+ this._checker = _checker;
+ this._ngZone = _ngZone;
+ this._focusTrapManager = _focusTrapManager;
+ this._document = _document; // TODO split up the strategies into different modules, similar to DateAdapter.
+
+ this._inertStrategy = _inertStrategy || new EventListenerFocusTrapInertStrategy();
+ }
+
+ create(element, config = {
+ defer: false
+ }) {
+ let configObject;
+
+ if (typeof config === 'boolean') {
+ configObject = {
+ defer: config
+ };
+ } else {
+ configObject = config;
+ }
+
+ return new ConfigurableFocusTrap(element, this._checker, this._ngZone, this._document, this._focusTrapManager, this._inertStrategy, configObject);
+ }
+
+}
+
+ConfigurableFocusTrapFactory.ɵfac = function ConfigurableFocusTrapFactory_Factory(t) {
+ return new (t || ConfigurableFocusTrapFactory)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](InteractivityChecker), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](FocusTrapManager), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](FOCUS_TRAP_INERT_STRATEGY, 8));
+};
+
+ConfigurableFocusTrapFactory.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjectable"]({
+ token: ConfigurableFocusTrapFactory,
+ factory: ConfigurableFocusTrapFactory.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](ConfigurableFocusTrapFactory, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: InteractivityChecker
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone
+ }, {
+ type: FocusTrapManager
+ }, {
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT]
+ }]
+ }, {
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Optional
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [FOCUS_TRAP_INERT_STRATEGY]
+ }]
+ }];
+ }, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/** Gets whether an event could be a faked `mousedown` event dispatched by a screen reader. */
+
+
+function isFakeMousedownFromScreenReader(event) {
+ // Some screen readers will dispatch a fake `mousedown` event when pressing enter or space on
+ // a clickable element. We can distinguish these events when both `offsetX` and `offsetY` are
+ // zero. Note that there's an edge case where the user could click the 0x0 spot of the screen
+ // themselves, but that is unlikely to contain interaction elements. Historically we used to
+ // check `event.buttons === 0`, however that no longer works on recent versions of NVDA.
+ return event.offsetX === 0 && event.offsetY === 0;
+}
+/** Gets whether an event could be a faked `touchstart` event dispatched by a screen reader. */
+
+
+function isFakeTouchstartFromScreenReader(event) {
+ const touch = event.touches && event.touches[0] || event.changedTouches && event.changedTouches[0]; // A fake `touchstart` can be distinguished from a real one by looking at the `identifier`
+ // which is typically >= 0 on a real device versus -1 from a screen reader. Just to be safe,
+ // we can also look at `radiusX` and `radiusY`. This behavior was observed against a Windows 10
+ // device with a touch screen running NVDA v2020.4 and Firefox 85 or Chrome 88.
+
+ return !!touch && touch.identifier === -1 && (touch.radiusX == null || touch.radiusX === 1) && (touch.radiusY == null || touch.radiusY === 1);
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * Injectable options for the InputModalityDetector. These are shallowly merged with the default
+ * options.
+ */
+
+
+const INPUT_MODALITY_DETECTOR_OPTIONS = new _angular_core__WEBPACK_IMPORTED_MODULE_0__.InjectionToken('cdk-input-modality-detector-options');
+/**
+ * Default options for the InputModalityDetector.
+ *
+ * Modifier keys are ignored by default (i.e. when pressed won't cause the service to detect
+ * keyboard input modality) for two reasons:
+ *
+ * 1. Modifier keys are commonly used with mouse to perform actions such as 'right click' or 'open
+ * in new tab', and are thus less representative of actual keyboard interaction.
+ * 2. VoiceOver triggers some keyboard events when linearly navigating with Control + Option (but
+ * confusingly not with Caps Lock). Thus, to have parity with other screen readers, we ignore
+ * these keys so as to not update the input modality.
+ *
+ * Note that we do not by default ignore the right Meta key on Safari because it has the same key
+ * code as the ContextMenu key on other browsers. When we switch to using event.key, we can
+ * distinguish between the two.
+ */
+
+const INPUT_MODALITY_DETECTOR_DEFAULT_OPTIONS = {
+ ignoreKeys: [_angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_8__.ALT, _angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_8__.CONTROL, _angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_8__.MAC_META, _angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_8__.META, _angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_8__.SHIFT]
+};
+/**
+ * The amount of time needed to pass after a touchstart event in order for a subsequent mousedown
+ * event to be attributed as mouse and not touch.
+ *
+ * This is the value used by AngularJS Material. Through trial and error (on iPhone 6S) they found
+ * that a value of around 650ms seems appropriate.
+ */
+
+const TOUCH_BUFFER_MS = 650;
+/**
+ * Event listener options that enable capturing and also mark the listener as passive if the browser
+ * supports it.
+ */
+
+const modalityEventListenerOptions = (0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.normalizePassiveListenerOptions)({
+ passive: true,
+ capture: true
+});
+/**
+ * Service that detects the user's input modality.
+ *
+ * This service does not update the input modality when a user navigates with a screen reader
+ * (e.g. linear navigation with VoiceOver, object navigation / browse mode with NVDA, virtual PC
+ * cursor mode with JAWS). This is in part due to technical limitations (i.e. keyboard events do not
+ * fire as expected in these modes) but is also arguably the correct behavior. Navigating with a
+ * screen reader is akin to visually scanning a page, and should not be interpreted as actual user
+ * input interaction.
+ *
+ * When a user is not navigating but *interacting* with a screen reader, this service attempts to
+ * update the input modality to keyboard, but in general this service's behavior is largely
+ * undefined.
+ */
+
+class InputModalityDetector {
+ constructor(_platform, ngZone, document, options) {
+ this._platform = _platform;
+ /**
+ * The most recently detected input modality event target. Is null if no input modality has been
+ * detected or if the associated event target is null for some unknown reason.
+ */
+
+ this._mostRecentTarget = null;
+ /** The underlying BehaviorSubject that emits whenever an input modality is detected. */
+
+ this._modality = new rxjs__WEBPACK_IMPORTED_MODULE_12__.BehaviorSubject(null);
+ /**
+ * The timestamp of the last touch input modality. Used to determine whether mousedown events
+ * should be attributed to mouse or touch.
+ */
+
+ this._lastTouchMs = 0;
+ /**
+ * Handles keydown events. Must be an arrow function in order to preserve the context when it gets
+ * bound.
+ */
+
+ this._onKeydown = event => {
+ // If this is one of the keys we should ignore, then ignore it and don't update the input
+ // modality to keyboard.
+ if (this._options?.ignoreKeys?.some(keyCode => keyCode === event.keyCode)) {
+ return;
+ }
+
+ this._modality.next('keyboard');
+
+ this._mostRecentTarget = (0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__._getEventTarget)(event);
+ };
+ /**
+ * Handles mousedown events. Must be an arrow function in order to preserve the context when it
+ * gets bound.
+ */
+
+
+ this._onMousedown = event => {
+ // Touches trigger both touch and mouse events, so we need to distinguish between mouse events
+ // that were triggered via mouse vs touch. To do so, check if the mouse event occurs closely
+ // after the previous touch event.
+ if (Date.now() - this._lastTouchMs < TOUCH_BUFFER_MS) {
+ return;
+ } // Fake mousedown events are fired by some screen readers when controls are activated by the
+ // screen reader. Attribute them to keyboard input modality.
+
+
+ this._modality.next(isFakeMousedownFromScreenReader(event) ? 'keyboard' : 'mouse');
+
+ this._mostRecentTarget = (0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__._getEventTarget)(event);
+ };
+ /**
+ * Handles touchstart events. Must be an arrow function in order to preserve the context when it
+ * gets bound.
+ */
+
+
+ this._onTouchstart = event => {
+ // Same scenario as mentioned in _onMousedown, but on touch screen devices, fake touchstart
+ // events are fired. Again, attribute to keyboard input modality.
+ if (isFakeTouchstartFromScreenReader(event)) {
+ this._modality.next('keyboard');
+
+ return;
+ } // Store the timestamp of this touch event, as it's used to distinguish between mouse events
+ // triggered via mouse vs touch.
+
+
+ this._lastTouchMs = Date.now();
+
+ this._modality.next('touch');
+
+ this._mostRecentTarget = (0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__._getEventTarget)(event);
+ };
+
+ this._options = { ...INPUT_MODALITY_DETECTOR_DEFAULT_OPTIONS,
+ ...options
+ }; // Skip the first emission as it's null.
+
+ this.modalityDetected = this._modality.pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_13__.skip)(1));
+ this.modalityChanged = this.modalityDetected.pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_14__.distinctUntilChanged)()); // If we're not in a browser, this service should do nothing, as there's no relevant input
+ // modality to detect.
+
+ if (_platform.isBrowser) {
+ ngZone.runOutsideAngular(() => {
+ document.addEventListener('keydown', this._onKeydown, modalityEventListenerOptions);
+ document.addEventListener('mousedown', this._onMousedown, modalityEventListenerOptions);
+ document.addEventListener('touchstart', this._onTouchstart, modalityEventListenerOptions);
+ });
+ }
+ }
+ /** The most recently detected input modality. */
+
+
+ get mostRecentModality() {
+ return this._modality.value;
+ }
+
+ ngOnDestroy() {
+ this._modality.complete();
+
+ if (this._platform.isBrowser) {
+ document.removeEventListener('keydown', this._onKeydown, modalityEventListenerOptions);
+ document.removeEventListener('mousedown', this._onMousedown, modalityEventListenerOptions);
+ document.removeEventListener('touchstart', this._onTouchstart, modalityEventListenerOptions);
+ }
+ }
+
+}
+
+InputModalityDetector.ɵfac = function InputModalityDetector_Factory(t) {
+ return new (t || InputModalityDetector)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.Platform), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](INPUT_MODALITY_DETECTOR_OPTIONS, 8));
+};
+
+InputModalityDetector.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjectable"]({
+ token: InputModalityDetector,
+ factory: InputModalityDetector.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](InputModalityDetector, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: _angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.Platform
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone
+ }, {
+ type: Document,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT]
+ }]
+ }, {
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Optional
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [INPUT_MODALITY_DETECTOR_OPTIONS]
+ }]
+ }];
+ }, null);
+})();
+/**
+ * @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.io/license
+ */
+
+
+const LIVE_ANNOUNCER_ELEMENT_TOKEN = new _angular_core__WEBPACK_IMPORTED_MODULE_0__.InjectionToken('liveAnnouncerElement', {
+ providedIn: 'root',
+ factory: LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY
+});
+/** @docs-private */
+
+function LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY() {
+ return null;
+}
+/** Injection token that can be used to configure the default options for the LiveAnnouncer. */
+
+
+const LIVE_ANNOUNCER_DEFAULT_OPTIONS = new _angular_core__WEBPACK_IMPORTED_MODULE_0__.InjectionToken('LIVE_ANNOUNCER_DEFAULT_OPTIONS');
+/**
+ * @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.io/license
+ */
+
+class LiveAnnouncer {
+ constructor(elementToken, _ngZone, _document, _defaultOptions) {
+ this._ngZone = _ngZone;
+ this._defaultOptions = _defaultOptions; // We inject the live element and document as `any` because the constructor signature cannot
+ // reference browser globals (HTMLElement, Document) on non-browser environments, since having
+ // a class decorator causes TypeScript to preserve the constructor signature types.
+
+ this._document = _document;
+ this._liveElement = elementToken || this._createLiveElement();
+ }
+
+ announce(message, ...args) {
+ const defaultOptions = this._defaultOptions;
+ let politeness;
+ let duration;
+
+ if (args.length === 1 && typeof args[0] === 'number') {
+ duration = args[0];
+ } else {
+ [politeness, duration] = args;
+ }
+
+ this.clear();
+ clearTimeout(this._previousTimeout);
+
+ if (!politeness) {
+ politeness = defaultOptions && defaultOptions.politeness ? defaultOptions.politeness : 'polite';
+ }
+
+ if (duration == null && defaultOptions) {
+ duration = defaultOptions.duration;
+ } // TODO: ensure changing the politeness works on all environments we support.
+
+
+ this._liveElement.setAttribute('aria-live', politeness); // This 100ms timeout is necessary for some browser + screen-reader combinations:
+ // - Both JAWS and NVDA over IE11 will not announce anything without a non-zero timeout.
+ // - With Chrome and IE11 with NVDA or JAWS, a repeated (identical) message won't be read a
+ // second time without clearing and then using a non-zero delay.
+ // (using JAWS 17 at time of this writing).
+
+
+ return this._ngZone.runOutsideAngular(() => {
+ return new Promise(resolve => {
+ clearTimeout(this._previousTimeout);
+ this._previousTimeout = setTimeout(() => {
+ this._liveElement.textContent = message;
+ resolve();
+
+ if (typeof duration === 'number') {
+ this._previousTimeout = setTimeout(() => this.clear(), duration);
+ }
+ }, 100);
+ });
+ });
+ }
+ /**
+ * Clears the current text from the announcer element. Can be used to prevent
+ * screen readers from reading the text out again while the user is going
+ * through the page landmarks.
+ */
+
+
+ clear() {
+ if (this._liveElement) {
+ this._liveElement.textContent = '';
+ }
+ }
+
+ ngOnDestroy() {
+ clearTimeout(this._previousTimeout);
+ this._liveElement?.remove();
+ this._liveElement = null;
+ }
+
+ _createLiveElement() {
+ const elementClass = 'cdk-live-announcer-element';
+
+ const previousElements = this._document.getElementsByClassName(elementClass);
+
+ const liveEl = this._document.createElement('div'); // Remove any old containers. This can happen when coming in from a server-side-rendered page.
+
+
+ for (let i = 0; i < previousElements.length; i++) {
+ previousElements[i].remove();
+ }
+
+ liveEl.classList.add(elementClass);
+ liveEl.classList.add('cdk-visually-hidden');
+ liveEl.setAttribute('aria-atomic', 'true');
+ liveEl.setAttribute('aria-live', 'polite');
+
+ this._document.body.appendChild(liveEl);
+
+ return liveEl;
+ }
+
+}
+
+LiveAnnouncer.ɵfac = function LiveAnnouncer_Factory(t) {
+ return new (t || LiveAnnouncer)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](LIVE_ANNOUNCER_ELEMENT_TOKEN, 8), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](LIVE_ANNOUNCER_DEFAULT_OPTIONS, 8));
+};
+
+LiveAnnouncer.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjectable"]({
+ token: LiveAnnouncer,
+ factory: LiveAnnouncer.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](LiveAnnouncer, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Optional
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [LIVE_ANNOUNCER_ELEMENT_TOKEN]
+ }]
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone
+ }, {
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT]
+ }]
+ }, {
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Optional
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [LIVE_ANNOUNCER_DEFAULT_OPTIONS]
+ }]
+ }];
+ }, null);
+})();
+/**
+ * A directive that works similarly to aria-live, but uses the LiveAnnouncer to ensure compatibility
+ * with a wider range of browsers and screen readers.
+ */
+
+
+class CdkAriaLive {
+ constructor(_elementRef, _liveAnnouncer, _contentObserver, _ngZone) {
+ this._elementRef = _elementRef;
+ this._liveAnnouncer = _liveAnnouncer;
+ this._contentObserver = _contentObserver;
+ this._ngZone = _ngZone;
+ this._politeness = 'polite';
+ }
+ /** The aria-live politeness level to use when announcing messages. */
+
+
+ get politeness() {
+ return this._politeness;
+ }
+
+ set politeness(value) {
+ this._politeness = value === 'off' || value === 'assertive' ? value : 'polite';
+
+ if (this._politeness === 'off') {
+ if (this._subscription) {
+ this._subscription.unsubscribe();
+
+ this._subscription = null;
+ }
+ } else if (!this._subscription) {
+ this._subscription = this._ngZone.runOutsideAngular(() => {
+ return this._contentObserver.observe(this._elementRef).subscribe(() => {
+ // Note that we use textContent here, rather than innerText, in order to avoid a reflow.
+ const elementText = this._elementRef.nativeElement.textContent; // The `MutationObserver` fires also for attribute
+ // changes which we don't want to announce.
+
+ if (elementText !== this._previousAnnouncedText) {
+ this._liveAnnouncer.announce(elementText, this._politeness);
+
+ this._previousAnnouncedText = elementText;
+ }
+ });
+ });
+ }
+ }
+
+ ngOnDestroy() {
+ if (this._subscription) {
+ this._subscription.unsubscribe();
+ }
+ }
+
+}
+
+CdkAriaLive.ɵfac = function CdkAriaLive_Factory(t) {
+ return new (t || CdkAriaLive)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.ElementRef), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](LiveAnnouncer), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_cdk_observers__WEBPACK_IMPORTED_MODULE_15__.ContentObserver), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone));
+};
+
+CdkAriaLive.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineDirective"]({
+ type: CdkAriaLive,
+ selectors: [["", "cdkAriaLive", ""]],
+ inputs: {
+ politeness: ["cdkAriaLive", "politeness"]
+ },
+ exportAs: ["cdkAriaLive"]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](CdkAriaLive, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Directive,
+ args: [{
+ selector: '[cdkAriaLive]',
+ exportAs: 'cdkAriaLive'
+ }]
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.ElementRef
+ }, {
+ type: LiveAnnouncer
+ }, {
+ type: _angular_cdk_observers__WEBPACK_IMPORTED_MODULE_15__.ContentObserver
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone
+ }];
+ }, {
+ politeness: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Input,
+ args: ['cdkAriaLive']
+ }]
+ });
+})();
+/**
+ * @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.io/license
+ */
+
+/** InjectionToken for FocusMonitorOptions. */
+
+
+const FOCUS_MONITOR_DEFAULT_OPTIONS = new _angular_core__WEBPACK_IMPORTED_MODULE_0__.InjectionToken('cdk-focus-monitor-default-options');
+/**
+ * Event listener options that enable capturing and also
+ * mark the listener as passive if the browser supports it.
+ */
+
+const captureEventListenerOptions = (0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.normalizePassiveListenerOptions)({
+ passive: true,
+ capture: true
+});
+/** Monitors mouse and keyboard events to determine the cause of focus events. */
+
+class FocusMonitor {
+ constructor(_ngZone, _platform, _inputModalityDetector,
+ /** @breaking-change 11.0.0 make document required */
+ document, options) {
+ this._ngZone = _ngZone;
+ this._platform = _platform;
+ this._inputModalityDetector = _inputModalityDetector;
+ /** The focus origin that the next focus event is a result of. */
+
+ this._origin = null;
+ /** Whether the window has just been focused. */
+
+ this._windowFocused = false;
+ /**
+ * Whether the origin was determined via a touch interaction. Necessary as properly attributing
+ * focus events to touch interactions requires special logic.
+ */
+
+ this._originFromTouchInteraction = false;
+ /** Map of elements being monitored to their info. */
+
+ this._elementInfo = new Map();
+ /** The number of elements currently being monitored. */
+
+ this._monitoredElementCount = 0;
+ /**
+ * Keeps track of the root nodes to which we've currently bound a focus/blur handler,
+ * as well as the number of monitored elements that they contain. We have to treat focus/blur
+ * handlers differently from the rest of the events, because the browser won't emit events
+ * to the document when focus moves inside of a shadow root.
+ */
+
+ this._rootNodeFocusListenerCount = new Map();
+ /**
+ * Event listener for `focus` events on the window.
+ * Needs to be an arrow function in order to preserve the context when it gets bound.
+ */
+
+ this._windowFocusListener = () => {
+ // Make a note of when the window regains focus, so we can
+ // restore the origin info for the focused element.
+ this._windowFocused = true;
+ this._windowFocusTimeoutId = setTimeout(() => this._windowFocused = false);
+ };
+ /** Subject for stopping our InputModalityDetector subscription. */
+
+
+ this._stopInputModalityDetector = new rxjs__WEBPACK_IMPORTED_MODULE_2__.Subject();
+ /**
+ * Event listener for `focus` and 'blur' events on the document.
+ * Needs to be an arrow function in order to preserve the context when it gets bound.
+ */
+
+ this._rootNodeFocusAndBlurListener = event => {
+ const target = (0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__._getEventTarget)(event);
+
+ const handler = event.type === 'focus' ? this._onFocus : this._onBlur; // We need to walk up the ancestor chain in order to support `checkChildren`.
+
+ for (let element = target; element; element = element.parentElement) {
+ handler.call(this, event, element);
+ }
+ };
+
+ this._document = document;
+ this._detectionMode = options?.detectionMode || 0
+ /* IMMEDIATE */
+ ;
+ }
+
+ monitor(element, checkChildren = false) {
+ const nativeElement = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_11__.coerceElement)(element); // Do nothing if we're not on the browser platform or the passed in node isn't an element.
+
+ if (!this._platform.isBrowser || nativeElement.nodeType !== 1) {
+ return (0,rxjs__WEBPACK_IMPORTED_MODULE_16__.of)(null);
+ } // If the element is inside the shadow DOM, we need to bind our focus/blur listeners to
+ // the shadow root, rather than the `document`, because the browser won't emit focus events
+ // to the `document`, if focus is moving within the same shadow root.
+
+
+ const rootNode = (0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__._getShadowRoot)(nativeElement) || this._getDocument();
+
+ const cachedInfo = this._elementInfo.get(nativeElement); // Check if we're already monitoring this element.
+
+
+ if (cachedInfo) {
+ if (checkChildren) {
+ // TODO(COMP-318): this can be problematic, because it'll turn all non-checkChildren
+ // observers into ones that behave as if `checkChildren` was turned on. We need a more
+ // robust solution.
+ cachedInfo.checkChildren = true;
+ }
+
+ return cachedInfo.subject;
+ } // Create monitored element info.
+
+
+ const info = {
+ checkChildren: checkChildren,
+ subject: new rxjs__WEBPACK_IMPORTED_MODULE_2__.Subject(),
+ rootNode
+ };
+
+ this._elementInfo.set(nativeElement, info);
+
+ this._registerGlobalListeners(info);
+
+ return info.subject;
+ }
+
+ stopMonitoring(element) {
+ const nativeElement = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_11__.coerceElement)(element);
+
+ const elementInfo = this._elementInfo.get(nativeElement);
+
+ if (elementInfo) {
+ elementInfo.subject.complete();
+
+ this._setClasses(nativeElement);
+
+ this._elementInfo.delete(nativeElement);
+
+ this._removeGlobalListeners(elementInfo);
+ }
+ }
+
+ focusVia(element, origin, options) {
+ const nativeElement = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_11__.coerceElement)(element);
+
+ const focusedElement = this._getDocument().activeElement; // If the element is focused already, calling `focus` again won't trigger the event listener
+ // which means that the focus classes won't be updated. If that's the case, update the classes
+ // directly without waiting for an event.
+
+
+ if (nativeElement === focusedElement) {
+ this._getClosestElementsInfo(nativeElement).forEach(([currentElement, info]) => this._originChanged(currentElement, origin, info));
+ } else {
+ this._setOrigin(origin); // `focus` isn't available on the server
+
+
+ if (typeof nativeElement.focus === 'function') {
+ nativeElement.focus(options);
+ }
+ }
+ }
+
+ ngOnDestroy() {
+ this._elementInfo.forEach((_info, element) => this.stopMonitoring(element));
+ }
+ /** Access injected document if available or fallback to global document reference */
+
+
+ _getDocument() {
+ return this._document || document;
+ }
+ /** Use defaultView of injected document if available or fallback to global window reference */
+
+
+ _getWindow() {
+ const doc = this._getDocument();
+
+ return doc.defaultView || window;
+ }
+
+ _getFocusOrigin(focusEventTarget) {
+ if (this._origin) {
+ // If the origin was realized via a touch interaction, we need to perform additional checks
+ // to determine whether the focus origin should be attributed to touch or program.
+ if (this._originFromTouchInteraction) {
+ return this._shouldBeAttributedToTouch(focusEventTarget) ? 'touch' : 'program';
+ } else {
+ return this._origin;
+ }
+ } // If the window has just regained focus, we can restore the most recent origin from before the
+ // window blurred. Otherwise, we've reached the point where we can't identify the source of the
+ // focus. This typically means one of two things happened:
+ //
+ // 1) The element was programmatically focused, or
+ // 2) The element was focused via screen reader navigation (which generally doesn't fire
+ // events).
+ //
+ // Because we can't distinguish between these two cases, we default to setting `program`.
+
+
+ return this._windowFocused && this._lastFocusOrigin ? this._lastFocusOrigin : 'program';
+ }
+ /**
+ * Returns whether the focus event should be attributed to touch. Recall that in IMMEDIATE mode, a
+ * touch origin isn't immediately reset at the next tick (see _setOrigin). This means that when we
+ * handle a focus event following a touch interaction, we need to determine whether (1) the focus
+ * event was directly caused by the touch interaction or (2) the focus event was caused by a
+ * subsequent programmatic focus call triggered by the touch interaction.
+ * @param focusEventTarget The target of the focus event under examination.
+ */
+
+
+ _shouldBeAttributedToTouch(focusEventTarget) {
+ // Please note that this check is not perfect. Consider the following edge case:
+ //
+ //
+ * {{ item }}
+ *
+ *
+ //
+ //
+ //
+ // Suppose there is a FocusMonitor in IMMEDIATE mode attached to #parent. When the user touches
+ // #child, #parent is programmatically focused. This code will attribute the focus to touch
+ // instead of program. This is a relatively minor edge-case that can be worked around by using
+ // focusVia(parent, 'program') to focus #parent.
+ return this._detectionMode === 1
+ /* EVENTUAL */
+ || !!focusEventTarget?.contains(this._inputModalityDetector._mostRecentTarget);
+ }
+ /**
+ * Sets the focus classes on the element based on the given focus origin.
+ * @param element The element to update the classes on.
+ * @param origin The focus origin.
+ */
+
+
+ _setClasses(element, origin) {
+ element.classList.toggle('cdk-focused', !!origin);
+ element.classList.toggle('cdk-touch-focused', origin === 'touch');
+ element.classList.toggle('cdk-keyboard-focused', origin === 'keyboard');
+ element.classList.toggle('cdk-mouse-focused', origin === 'mouse');
+ element.classList.toggle('cdk-program-focused', origin === 'program');
+ }
+ /**
+ * Updates the focus origin. If we're using immediate detection mode, we schedule an async
+ * function to clear the origin at the end of a timeout. The duration of the timeout depends on
+ * the origin being set.
+ * @param origin The origin to set.
+ * @param isFromInteraction Whether we are setting the origin from an interaction event.
+ */
+
+
+ _setOrigin(origin, isFromInteraction = false) {
+ this._ngZone.runOutsideAngular(() => {
+ this._origin = origin;
+ this._originFromTouchInteraction = origin === 'touch' && isFromInteraction; // If we're in IMMEDIATE mode, reset the origin at the next tick (or in `TOUCH_BUFFER_MS` ms
+ // for a touch event). We reset the origin at the next tick because Firefox focuses one tick
+ // after the interaction event. We wait `TOUCH_BUFFER_MS` ms before resetting the origin for
+ // a touch event because when a touch event is fired, the associated focus event isn't yet in
+ // the event queue. Before doing so, clear any pending timeouts.
+
+ if (this._detectionMode === 0
+ /* IMMEDIATE */
+ ) {
+ clearTimeout(this._originTimeoutId);
+ const ms = this._originFromTouchInteraction ? TOUCH_BUFFER_MS : 1;
+ this._originTimeoutId = setTimeout(() => this._origin = null, ms);
+ }
+ });
+ }
+ /**
+ * Handles focus events on a registered element.
+ * @param event The focus event.
+ * @param element The monitored element.
+ */
+
+
+ _onFocus(event, element) {
+ // NOTE(mmalerba): We currently set the classes based on the focus origin of the most recent
+ // focus event affecting the monitored element. If we want to use the origin of the first event
+ // instead we should check for the cdk-focused class here and return if the element already has
+ // it. (This only matters for elements that have includesChildren = true).
+ // If we are not counting child-element-focus as focused, make sure that the event target is the
+ // monitored element itself.
+ const elementInfo = this._elementInfo.get(element);
+
+ const focusEventTarget = (0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__._getEventTarget)(event);
+
+ if (!elementInfo || !elementInfo.checkChildren && element !== focusEventTarget) {
+ return;
+ }
+
+ this._originChanged(element, this._getFocusOrigin(focusEventTarget), elementInfo);
+ }
+ /**
+ * Handles blur events on a registered element.
+ * @param event The blur event.
+ * @param element The monitored element.
+ */
+
+
+ _onBlur(event, element) {
+ // If we are counting child-element-focus as focused, make sure that we aren't just blurring in
+ // order to focus another child of the monitored element.
+ const elementInfo = this._elementInfo.get(element);
+
+ if (!elementInfo || elementInfo.checkChildren && event.relatedTarget instanceof Node && element.contains(event.relatedTarget)) {
+ return;
+ }
+
+ this._setClasses(element);
+
+ this._emitOrigin(elementInfo.subject, null);
+ }
+
+ _emitOrigin(subject, origin) {
+ this._ngZone.run(() => subject.next(origin));
+ }
+
+ _registerGlobalListeners(elementInfo) {
+ if (!this._platform.isBrowser) {
+ return;
+ }
+
+ const rootNode = elementInfo.rootNode;
+ const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode) || 0;
+
+ if (!rootNodeFocusListeners) {
+ this._ngZone.runOutsideAngular(() => {
+ rootNode.addEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+ rootNode.addEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+ });
+ }
+
+ this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners + 1); // Register global listeners when first element is monitored.
+
+
+ if (++this._monitoredElementCount === 1) {
+ // Note: we listen to events in the capture phase so we
+ // can detect them even if the user stops propagation.
+ this._ngZone.runOutsideAngular(() => {
+ const window = this._getWindow();
+
+ window.addEventListener('focus', this._windowFocusListener);
+ }); // The InputModalityDetector is also just a collection of global listeners.
+
+
+ this._inputModalityDetector.modalityDetected.pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_17__.takeUntil)(this._stopInputModalityDetector)).subscribe(modality => {
+ this._setOrigin(modality, true
+ /* isFromInteraction */
+ );
+ });
+ }
+ }
+
+ _removeGlobalListeners(elementInfo) {
+ const rootNode = elementInfo.rootNode;
+
+ if (this._rootNodeFocusListenerCount.has(rootNode)) {
+ const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode);
+
+ if (rootNodeFocusListeners > 1) {
+ this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners - 1);
+ } else {
+ rootNode.removeEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+ rootNode.removeEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+
+ this._rootNodeFocusListenerCount.delete(rootNode);
+ }
+ } // Unregister global listeners when last element is unmonitored.
+
+
+ if (! --this._monitoredElementCount) {
+ const window = this._getWindow();
+
+ window.removeEventListener('focus', this._windowFocusListener); // Equivalently, stop our InputModalityDetector subscription.
+
+ this._stopInputModalityDetector.next(); // Clear timeouts for all potentially pending timeouts to prevent the leaks.
+
+
+ clearTimeout(this._windowFocusTimeoutId);
+ clearTimeout(this._originTimeoutId);
+ }
+ }
+ /** Updates all the state on an element once its focus origin has changed. */
+
+
+ _originChanged(element, origin, elementInfo) {
+ this._setClasses(element, origin);
+
+ this._emitOrigin(elementInfo.subject, origin);
+
+ this._lastFocusOrigin = origin;
+ }
+ /**
+ * Collects the `MonitoredElementInfo` of a particular element and
+ * all of its ancestors that have enabled `checkChildren`.
+ * @param element Element from which to start the search.
+ */
+
+
+ _getClosestElementsInfo(element) {
+ const results = [];
+
+ this._elementInfo.forEach((info, currentElement) => {
+ if (currentElement === element || info.checkChildren && currentElement.contains(element)) {
+ results.push([currentElement, info]);
+ }
+ });
+
+ return results;
+ }
+
+}
+
+FocusMonitor.ɵfac = function FocusMonitor_Factory(t) {
+ return new (t || FocusMonitor)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.Platform), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](InputModalityDetector), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT, 8), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](FOCUS_MONITOR_DEFAULT_OPTIONS, 8));
+};
+
+FocusMonitor.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjectable"]({
+ token: FocusMonitor,
+ factory: FocusMonitor.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](FocusMonitor, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone
+ }, {
+ type: _angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.Platform
+ }, {
+ type: InputModalityDetector
+ }, {
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Optional
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT]
+ }]
+ }, {
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Optional
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [FOCUS_MONITOR_DEFAULT_OPTIONS]
+ }]
+ }];
+ }, null);
+})();
+/**
+ * Directive that determines how a particular element was focused (via keyboard, mouse, touch, or
+ * programmatically) and adds corresponding classes to the element.
+ *
+ * There are two variants of this directive:
+ * 1) cdkMonitorElementFocus: does not consider an element to be focused if one of its children is
+ * focused.
+ * 2) cdkMonitorSubtreeFocus: considers an element focused if it or any of its children are focused.
+ */
+
+
+class CdkMonitorFocus {
+ constructor(_elementRef, _focusMonitor) {
+ this._elementRef = _elementRef;
+ this._focusMonitor = _focusMonitor;
+ this.cdkFocusChange = new _angular_core__WEBPACK_IMPORTED_MODULE_0__.EventEmitter();
+ }
+
+ ngAfterViewInit() {
+ const element = this._elementRef.nativeElement;
+ this._monitorSubscription = this._focusMonitor.monitor(element, element.nodeType === 1 && element.hasAttribute('cdkMonitorSubtreeFocus')).subscribe(origin => this.cdkFocusChange.emit(origin));
+ }
+
+ ngOnDestroy() {
+ this._focusMonitor.stopMonitoring(this._elementRef);
+
+ if (this._monitorSubscription) {
+ this._monitorSubscription.unsubscribe();
+ }
+ }
+
+}
+
+CdkMonitorFocus.ɵfac = function CdkMonitorFocus_Factory(t) {
+ return new (t || CdkMonitorFocus)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.ElementRef), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](FocusMonitor));
+};
+
+CdkMonitorFocus.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineDirective"]({
+ type: CdkMonitorFocus,
+ selectors: [["", "cdkMonitorElementFocus", ""], ["", "cdkMonitorSubtreeFocus", ""]],
+ outputs: {
+ cdkFocusChange: "cdkFocusChange"
+ }
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](CdkMonitorFocus, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Directive,
+ args: [{
+ selector: '[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]'
+ }]
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.ElementRef
+ }, {
+ type: FocusMonitor
+ }];
+ }, {
+ cdkFocusChange: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Output
+ }]
+ });
+})();
+/**
+ * @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.io/license
+ */
+
+/** CSS class applied to the document body when in black-on-white high-contrast mode. */
+
+
+const BLACK_ON_WHITE_CSS_CLASS = 'cdk-high-contrast-black-on-white';
+/** CSS class applied to the document body when in white-on-black high-contrast mode. */
+
+const WHITE_ON_BLACK_CSS_CLASS = 'cdk-high-contrast-white-on-black';
+/** CSS class applied to the document body when in high-contrast mode. */
+
+const HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS = 'cdk-high-contrast-active';
+/**
+ * Service to determine whether the browser is currently in a high-contrast-mode environment.
+ *
+ * Microsoft Windows supports an accessibility feature called "High Contrast Mode". This mode
+ * changes the appearance of all applications, including web applications, to dramatically increase
+ * contrast.
+ *
+ * IE, Edge, and Firefox currently support this mode. Chrome does not support Windows High Contrast
+ * Mode. This service does not detect high-contrast mode as added by the Chrome "High Contrast"
+ * browser extension.
+ */
+
+class HighContrastModeDetector {
+ constructor(_platform, document) {
+ this._platform = _platform;
+ this._document = document;
+ }
+ /** Gets the current high-contrast-mode for the page. */
+
+
+ getHighContrastMode() {
+ if (!this._platform.isBrowser) {
+ return 0
+ /* NONE */
+ ;
+ } // Create a test element with an arbitrary background-color that is neither black nor
+ // white; high-contrast mode will coerce the color to either black or white. Also ensure that
+ // appending the test element to the DOM does not affect layout by absolutely positioning it
+
+
+ const testElement = this._document.createElement('div');
+
+ testElement.style.backgroundColor = 'rgb(1,2,3)';
+ testElement.style.position = 'absolute';
+
+ this._document.body.appendChild(testElement); // Get the computed style for the background color, collapsing spaces to normalize between
+ // browsers. Once we get this color, we no longer need the test element. Access the `window`
+ // via the document so we can fake it in tests. Note that we have extra null checks, because
+ // this logic will likely run during app bootstrap and throwing can break the entire app.
+
+
+ const documentWindow = this._document.defaultView || window;
+ const computedStyle = documentWindow && documentWindow.getComputedStyle ? documentWindow.getComputedStyle(testElement) : null;
+ const computedColor = (computedStyle && computedStyle.backgroundColor || '').replace(/ /g, '');
+ testElement.remove();
+
+ switch (computedColor) {
+ case 'rgb(0,0,0)':
+ return 2
+ /* WHITE_ON_BLACK */
+ ;
+
+ case 'rgb(255,255,255)':
+ return 1
+ /* BLACK_ON_WHITE */
+ ;
+ }
+
+ return 0
+ /* NONE */
+ ;
+ }
+ /** Applies CSS classes indicating high-contrast mode to document body (browser-only). */
+
+
+ _applyBodyHighContrastModeCssClasses() {
+ if (!this._hasCheckedHighContrastMode && this._platform.isBrowser && this._document.body) {
+ const bodyClasses = this._document.body.classList; // IE11 doesn't support `classList` operations with multiple arguments
+
+ bodyClasses.remove(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS);
+ bodyClasses.remove(BLACK_ON_WHITE_CSS_CLASS);
+ bodyClasses.remove(WHITE_ON_BLACK_CSS_CLASS);
+ this._hasCheckedHighContrastMode = true;
+ const mode = this.getHighContrastMode();
+
+ if (mode === 1
+ /* BLACK_ON_WHITE */
+ ) {
+ bodyClasses.add(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS);
+ bodyClasses.add(BLACK_ON_WHITE_CSS_CLASS);
+ } else if (mode === 2
+ /* WHITE_ON_BLACK */
+ ) {
+ bodyClasses.add(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS);
+ bodyClasses.add(WHITE_ON_BLACK_CSS_CLASS);
+ }
+ }
+ }
+
+}
+
+HighContrastModeDetector.ɵfac = function HighContrastModeDetector_Factory(t) {
+ return new (t || HighContrastModeDetector)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.Platform), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT));
+};
+
+HighContrastModeDetector.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjectable"]({
+ token: HighContrastModeDetector,
+ factory: HighContrastModeDetector.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](HighContrastModeDetector, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: _angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.Platform
+ }, {
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT]
+ }]
+ }];
+ }, null);
+})();
+/**
+ * @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.io/license
+ */
+
+
+class A11yModule {
+ constructor(highContrastModeDetector) {
+ highContrastModeDetector._applyBodyHighContrastModeCssClasses();
+ }
+
+}
+
+A11yModule.ɵfac = function A11yModule_Factory(t) {
+ return new (t || A11yModule)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](HighContrastModeDetector));
+};
+
+A11yModule.ɵmod = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineNgModule"]({
+ type: A11yModule
+});
+A11yModule.ɵinj = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjector"]({
+ imports: [[_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.PlatformModule, _angular_cdk_observers__WEBPACK_IMPORTED_MODULE_15__.ObserversModule]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](A11yModule, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgModule,
+ args: [{
+ imports: [_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.PlatformModule, _angular_cdk_observers__WEBPACK_IMPORTED_MODULE_15__.ObserversModule],
+ declarations: [CdkAriaLive, CdkTrapFocus, CdkMonitorFocus],
+ exports: [CdkAriaLive, CdkTrapFocus, CdkMonitorFocus]
+ }]
+ }], function () {
+ return [{
+ type: HighContrastModeDetector
+ }];
+ }, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+
+
+
+/***/ }),
+
+/***/ 2867:
+/*!*****************************************************!*\
+ !*** ./node_modules/@angular/cdk/fesm2020/bidi.mjs ***!
+ \*****************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "BidiModule": () => (/* binding */ BidiModule),
+/* harmony export */ "DIR_DOCUMENT": () => (/* binding */ DIR_DOCUMENT),
+/* harmony export */ "Dir": () => (/* binding */ Dir),
+/* harmony export */ "Directionality": () => (/* binding */ Directionality)
+/* harmony export */ });
+/* harmony import */ var _angular_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @angular/core */ 2560);
+/* harmony import */ var _angular_common__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @angular/common */ 4666);
+
+
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * Injection token used to inject the document into Directionality.
+ * This is used so that the value can be faked in tests.
+ *
+ * We can't use the real document in tests because changing the real `dir` causes geometry-based
+ * tests in Safari to fail.
+ *
+ * We also can't re-provide the DOCUMENT token from platform-brower because the unit tests
+ * themselves use things like `querySelector` in test code.
+ *
+ * This token is defined in a separate file from Directionality as a workaround for
+ * https://github.com/angular/angular/issues/22559
+ *
+ * @docs-private
+ */
+
+const DIR_DOCUMENT = new _angular_core__WEBPACK_IMPORTED_MODULE_0__.InjectionToken('cdk-dir-doc', {
+ providedIn: 'root',
+ factory: DIR_DOCUMENT_FACTORY
+});
+/** @docs-private */
+
+function DIR_DOCUMENT_FACTORY() {
+ return (0,_angular_core__WEBPACK_IMPORTED_MODULE_0__.inject)(_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT);
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * The directionality (LTR / RTL) context for the application (or a subtree of it).
+ * Exposes the current direction and a stream of direction changes.
+ */
+
+
+class Directionality {
+ constructor(_document) {
+ /** The current 'ltr' or 'rtl' value. */
+ this.value = 'ltr';
+ /** Stream that emits whenever the 'ltr' / 'rtl' state changes. */
+
+ this.change = new _angular_core__WEBPACK_IMPORTED_MODULE_0__.EventEmitter();
+
+ if (_document) {
+ // TODO: handle 'auto' value -
+ // We still need to account for dir="auto".
+ // It looks like HTMLElemenet.dir is also "auto" when that's set to the attribute,
+ // but getComputedStyle return either "ltr" or "rtl". avoiding getComputedStyle for now
+ const bodyDir = _document.body ? _document.body.dir : null;
+ const htmlDir = _document.documentElement ? _document.documentElement.dir : null;
+ const value = bodyDir || htmlDir;
+ this.value = value === 'ltr' || value === 'rtl' ? value : 'ltr';
+ }
+ }
+
+ ngOnDestroy() {
+ this.change.complete();
+ }
+
+}
+
+Directionality.ɵfac = function Directionality_Factory(t) {
+ return new (t || Directionality)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](DIR_DOCUMENT, 8));
+};
+
+Directionality.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjectable"]({
+ token: Directionality,
+ factory: Directionality.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](Directionality, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Optional
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [DIR_DOCUMENT]
+ }]
+ }];
+ }, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/**
+ * Directive to listen for changes of direction of part of the DOM.
+ *
+ * Provides itself as Directionality such that descendant directives only need to ever inject
+ * Directionality to get the closest direction.
+ */
+
+
+class Dir {
+ constructor() {
+ /** Normalized direction that accounts for invalid/unsupported values. */
+ this._dir = 'ltr';
+ /** Whether the `value` has been set to its initial value. */
+
+ this._isInitialized = false;
+ /** Event emitted when the direction changes. */
+
+ this.change = new _angular_core__WEBPACK_IMPORTED_MODULE_0__.EventEmitter();
+ }
+ /** @docs-private */
+
+
+ get dir() {
+ return this._dir;
+ }
+
+ set dir(value) {
+ const old = this._dir;
+ const normalizedValue = value ? value.toLowerCase() : value;
+ this._rawDir = value;
+ this._dir = normalizedValue === 'ltr' || normalizedValue === 'rtl' ? normalizedValue : 'ltr';
+
+ if (old !== this._dir && this._isInitialized) {
+ this.change.emit(this._dir);
+ }
+ }
+ /** Current layout direction of the element. */
+
+
+ get value() {
+ return this.dir;
+ }
+ /** Initialize once default value has been set. */
+
+
+ ngAfterContentInit() {
+ this._isInitialized = true;
+ }
+
+ ngOnDestroy() {
+ this.change.complete();
+ }
+
+}
+
+Dir.ɵfac = function Dir_Factory(t) {
+ return new (t || Dir)();
+};
+
+Dir.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineDirective"]({
+ type: Dir,
+ selectors: [["", "dir", ""]],
+ hostVars: 1,
+ hostBindings: function Dir_HostBindings(rf, ctx) {
+ if (rf & 2) {
+ _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵattribute"]("dir", ctx._rawDir);
+ }
+ },
+ inputs: {
+ dir: "dir"
+ },
+ outputs: {
+ change: "dirChange"
+ },
+ exportAs: ["dir"],
+ features: [_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵProvidersFeature"]([{
+ provide: Directionality,
+ useExisting: Dir
+ }])]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](Dir, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Directive,
+ args: [{
+ selector: '[dir]',
+ providers: [{
+ provide: Directionality,
+ useExisting: Dir
+ }],
+ host: {
+ '[attr.dir]': '_rawDir'
+ },
+ exportAs: 'dir'
+ }]
+ }], null, {
+ change: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Output,
+ args: ['dirChange']
+ }],
+ dir: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Input
+ }]
+ });
+})();
+/**
+ * @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.io/license
+ */
+
+
+class BidiModule {}
+
+BidiModule.ɵfac = function BidiModule_Factory(t) {
+ return new (t || BidiModule)();
+};
+
+BidiModule.ɵmod = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineNgModule"]({
+ type: BidiModule
+});
+BidiModule.ɵinj = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjector"]({});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](BidiModule, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgModule,
+ args: [{
+ exports: [Dir],
+ declarations: [Dir]
+ }]
+ }], null, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+
+
+
+/***/ }),
+
+/***/ 6507:
+/*!****************************************************!*\
+ !*** ./node_modules/@angular/cdk/fesm2020/cdk.mjs ***!
+ \****************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "VERSION": () => (/* binding */ VERSION)
+/* harmony export */ });
+/* harmony import */ var _angular_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @angular/core */ 2560);
+
+/**
+ * @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.io/license
+ */
+
+/** Current version of the Angular Component Development Kit. */
+
+const VERSION = new _angular_core__WEBPACK_IMPORTED_MODULE_0__.Version('13.0.0');
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+
+
+/***/ }),
+
+/***/ 8971:
+/*!*********************************************************!*\
+ !*** ./node_modules/@angular/cdk/fesm2020/coercion.mjs ***!
+ \*********************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "_isNumberValue": () => (/* binding */ _isNumberValue),
+/* harmony export */ "coerceArray": () => (/* binding */ coerceArray),
+/* harmony export */ "coerceBooleanProperty": () => (/* binding */ coerceBooleanProperty),
+/* harmony export */ "coerceCssPixelValue": () => (/* binding */ coerceCssPixelValue),
+/* harmony export */ "coerceElement": () => (/* binding */ coerceElement),
+/* harmony export */ "coerceNumberProperty": () => (/* binding */ coerceNumberProperty),
+/* harmony export */ "coerceStringArray": () => (/* binding */ coerceStringArray)
+/* harmony export */ });
+/* harmony import */ var _angular_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @angular/core */ 2560);
+
+/**
+ * @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.io/license
+ */
+
+/** Coerces a data-bound value (typically a string) to a boolean. */
+
+function coerceBooleanProperty(value) {
+ return value != null && `${value}` !== 'false';
+}
+/**
+ * @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.io/license
+ */
+
+
+function coerceNumberProperty(value, fallbackValue = 0) {
+ return _isNumberValue(value) ? Number(value) : fallbackValue;
+}
+/**
+ * Whether the provided value is considered a number.
+ * @docs-private
+ */
+
+
+function _isNumberValue(value) {
+ // parseFloat(value) handles most of the cases we're interested in (it treats null, empty string,
+ // and other non-number values as NaN, where Number just uses 0) but it considers the string
+ // '123hello' to be a valid number. Therefore we also check if Number(value) is NaN.
+ return !isNaN(parseFloat(value)) && !isNaN(Number(value));
+}
+/**
+ * @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.io/license
+ */
+
+
+function coerceArray(value) {
+ return Array.isArray(value) ? value : [value];
+}
+/**
+ * @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.io/license
+ */
+
+/** Coerces a value to a CSS pixel value. */
+
+
+function coerceCssPixelValue(value) {
+ if (value == null) {
+ return '';
+ }
+
+ return typeof value === 'string' ? value : `${value}px`;
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * Coerces an ElementRef or an Element into an element.
+ * Useful for APIs that can accept either a ref or the native element itself.
+ */
+
+
+function coerceElement(elementOrRef) {
+ return elementOrRef instanceof _angular_core__WEBPACK_IMPORTED_MODULE_0__.ElementRef ? elementOrRef.nativeElement : elementOrRef;
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * Coerces a value to an array of trimmed non-empty strings.
+ * Any input that is not an array, `null` or `undefined` will be turned into a string
+ * via `toString()` and subsequently split with the given separator.
+ * `null` and `undefined` will result in an empty array.
+ * This results in the following outcomes:
+ * - `null` -> `[]`
+ * - `[null]` -> `["null"]`
+ * - `["a", "b ", " "]` -> `["a", "b"]`
+ * - `[1, [2, 3]]` -> `["1", "2,3"]`
+ * - `[{ a: 0 }]` -> `["[object Object]"]`
+ * - `{ a: 0 }` -> `["[object", "Object]"]`
+ *
+ * Useful for defining CSS classes or table columns.
+ * @param value the value to coerce into an array of strings
+ * @param separator split-separator if value isn't an array
+ */
+
+
+function coerceStringArray(value, separator = /\s+/) {
+ const result = [];
+
+ if (value != null) {
+ const sourceValues = Array.isArray(value) ? value : `${value}`.split(separator);
+
+ for (const sourceValue of sourceValues) {
+ const trimmedString = `${sourceValue}`.trim();
+
+ if (trimmedString) {
+ result.push(trimmedString);
+ }
+ }
+ }
+
+ return result;
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+
+
+
+/***/ }),
+
+/***/ 1755:
+/*!************************************************************!*\
+ !*** ./node_modules/@angular/cdk/fesm2020/collections.mjs ***!
+ \************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "ArrayDataSource": () => (/* binding */ ArrayDataSource),
+/* harmony export */ "DataSource": () => (/* binding */ DataSource),
+/* harmony export */ "SelectionModel": () => (/* binding */ SelectionModel),
+/* harmony export */ "UniqueSelectionDispatcher": () => (/* binding */ UniqueSelectionDispatcher),
+/* harmony export */ "_DisposeViewRepeaterStrategy": () => (/* binding */ _DisposeViewRepeaterStrategy),
+/* harmony export */ "_RecycleViewRepeaterStrategy": () => (/* binding */ _RecycleViewRepeaterStrategy),
+/* harmony export */ "_VIEW_REPEATER_STRATEGY": () => (/* binding */ _VIEW_REPEATER_STRATEGY),
+/* harmony export */ "getMultipleValuesInSingleSelectionError": () => (/* binding */ getMultipleValuesInSingleSelectionError),
+/* harmony export */ "isDataSource": () => (/* binding */ isDataSource)
+/* harmony export */ });
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! rxjs */ 4437);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! rxjs */ 745);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! rxjs */ 228);
+/* harmony import */ var _angular_core__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @angular/core */ 2560);
+
+
+
+/**
+ * @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.io/license
+ */
+
+class DataSource {}
+/** Checks whether an object is a data source. */
+
+
+function isDataSource(value) {
+ // Check if the value is a DataSource by observing if it has a connect function. Cannot
+ // be checked as an `instanceof DataSource` since people could create their own sources
+ // that match the interface, but don't extend DataSource.
+ return value && typeof value.connect === 'function';
+}
+/**
+ * @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.io/license
+ */
+
+/** DataSource wrapper for a native array. */
+
+
+class ArrayDataSource extends DataSource {
+ constructor(_data) {
+ super();
+ this._data = _data;
+ }
+
+ connect() {
+ return (0,rxjs__WEBPACK_IMPORTED_MODULE_0__.isObservable)(this._data) ? this._data : (0,rxjs__WEBPACK_IMPORTED_MODULE_1__.of)(this._data);
+ }
+
+ disconnect() {}
+
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * A repeater that destroys views when they are removed from a
+ * {@link ViewContainerRef}. When new items are inserted into the container,
+ * the repeater will always construct a new embedded view for each item.
+ *
+ * @template T The type for the embedded view's $implicit property.
+ * @template R The type for the item in each IterableDiffer change record.
+ * @template C The type for the context passed to each embedded view.
+ */
+
+
+class _DisposeViewRepeaterStrategy {
+ applyChanges(changes, viewContainerRef, itemContextFactory, itemValueResolver, itemViewChanged) {
+ changes.forEachOperation((record, adjustedPreviousIndex, currentIndex) => {
+ let view;
+ let operation;
+
+ if (record.previousIndex == null) {
+ const insertContext = itemContextFactory(record, adjustedPreviousIndex, currentIndex);
+ view = viewContainerRef.createEmbeddedView(insertContext.templateRef, insertContext.context, insertContext.index);
+ operation = 1
+ /* INSERTED */
+ ;
+ } else if (currentIndex == null) {
+ viewContainerRef.remove(adjustedPreviousIndex);
+ operation = 3
+ /* REMOVED */
+ ;
+ } else {
+ view = viewContainerRef.get(adjustedPreviousIndex);
+ viewContainerRef.move(view, currentIndex);
+ operation = 2
+ /* MOVED */
+ ;
+ }
+
+ if (itemViewChanged) {
+ itemViewChanged({
+ context: view?.context,
+ operation,
+ record
+ });
+ }
+ });
+ }
+
+ detach() {}
+
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * A repeater that caches views when they are removed from a
+ * {@link ViewContainerRef}. When new items are inserted into the container,
+ * the repeater will reuse one of the cached views instead of creating a new
+ * embedded view. Recycling cached views reduces the quantity of expensive DOM
+ * inserts.
+ *
+ * @template T The type for the embedded view's $implicit property.
+ * @template R The type for the item in each IterableDiffer change record.
+ * @template C The type for the context passed to each embedded view.
+ */
+
+
+class _RecycleViewRepeaterStrategy {
+ constructor() {
+ /**
+ * The size of the cache used to store unused views.
+ * Setting the cache size to `0` will disable caching. Defaults to 20 views.
+ */
+ this.viewCacheSize = 20;
+ /**
+ * View cache that stores embedded view instances that have been previously stamped out,
+ * but don't are not currently rendered. The view repeater will reuse these views rather than
+ * creating brand new ones.
+ *
+ * TODO(michaeljamesparsons) Investigate whether using a linked list would improve performance.
+ */
+
+ this._viewCache = [];
+ }
+ /** Apply changes to the DOM. */
+
+
+ applyChanges(changes, viewContainerRef, itemContextFactory, itemValueResolver, itemViewChanged) {
+ // Rearrange the views to put them in the right location.
+ changes.forEachOperation((record, adjustedPreviousIndex, currentIndex) => {
+ let view;
+ let operation;
+
+ if (record.previousIndex == null) {
+ // Item added.
+ const viewArgsFactory = () => itemContextFactory(record, adjustedPreviousIndex, currentIndex);
+
+ view = this._insertView(viewArgsFactory, currentIndex, viewContainerRef, itemValueResolver(record));
+ operation = view ? 1
+ /* INSERTED */
+ : 0
+ /* REPLACED */
+ ;
+ } else if (currentIndex == null) {
+ // Item removed.
+ this._detachAndCacheView(adjustedPreviousIndex, viewContainerRef);
+
+ operation = 3
+ /* REMOVED */
+ ;
+ } else {
+ // Item moved.
+ view = this._moveView(adjustedPreviousIndex, currentIndex, viewContainerRef, itemValueResolver(record));
+ operation = 2
+ /* MOVED */
+ ;
+ }
+
+ if (itemViewChanged) {
+ itemViewChanged({
+ context: view?.context,
+ operation,
+ record
+ });
+ }
+ });
+ }
+
+ detach() {
+ for (const view of this._viewCache) {
+ view.destroy();
+ }
+
+ this._viewCache = [];
+ }
+ /**
+ * Inserts a view for a new item, either from the cache or by creating a new
+ * one. Returns `undefined` if the item was inserted into a cached view.
+ */
+
+
+ _insertView(viewArgsFactory, currentIndex, viewContainerRef, value) {
+ const cachedView = this._insertViewFromCache(currentIndex, viewContainerRef);
+
+ if (cachedView) {
+ cachedView.context.$implicit = value;
+ return undefined;
+ }
+
+ const viewArgs = viewArgsFactory();
+ return viewContainerRef.createEmbeddedView(viewArgs.templateRef, viewArgs.context, viewArgs.index);
+ }
+ /** Detaches the view at the given index and inserts into the view cache. */
+
+
+ _detachAndCacheView(index, viewContainerRef) {
+ const detachedView = viewContainerRef.detach(index);
+
+ this._maybeCacheView(detachedView, viewContainerRef);
+ }
+ /** Moves view at the previous index to the current index. */
+
+
+ _moveView(adjustedPreviousIndex, currentIndex, viewContainerRef, value) {
+ const view = viewContainerRef.get(adjustedPreviousIndex);
+ viewContainerRef.move(view, currentIndex);
+ view.context.$implicit = value;
+ return view;
+ }
+ /**
+ * Cache the given detached view. If the cache is full, the view will be
+ * destroyed.
+ */
+
+
+ _maybeCacheView(view, viewContainerRef) {
+ if (this._viewCache.length < this.viewCacheSize) {
+ this._viewCache.push(view);
+ } else {
+ const index = viewContainerRef.indexOf(view); // The host component could remove views from the container outside of
+ // the view repeater. It's unlikely this will occur, but just in case,
+ // destroy the view on its own, otherwise destroy it through the
+ // container to ensure that all the references are removed.
+
+ if (index === -1) {
+ view.destroy();
+ } else {
+ viewContainerRef.remove(index);
+ }
+ }
+ }
+ /** Inserts a recycled view from the cache at the given index. */
+
+
+ _insertViewFromCache(index, viewContainerRef) {
+ const cachedView = this._viewCache.pop();
+
+ if (cachedView) {
+ viewContainerRef.insert(cachedView, index);
+ }
+
+ return cachedView || null;
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * Class to be used to power selecting one or more options from a list.
+ */
+
+
+class SelectionModel {
+ constructor(_multiple = false, initiallySelectedValues, _emitChanges = true) {
+ this._multiple = _multiple;
+ this._emitChanges = _emitChanges;
+ /** Currently-selected values. */
+
+ this._selection = new Set();
+ /** Keeps track of the deselected options that haven't been emitted by the change event. */
+
+ this._deselectedToEmit = [];
+ /** Keeps track of the selected options that haven't been emitted by the change event. */
+
+ this._selectedToEmit = [];
+ /** Event emitted when the value has changed. */
+
+ this.changed = new rxjs__WEBPACK_IMPORTED_MODULE_2__.Subject();
+
+ if (initiallySelectedValues && initiallySelectedValues.length) {
+ if (_multiple) {
+ initiallySelectedValues.forEach(value => this._markSelected(value));
+ } else {
+ this._markSelected(initiallySelectedValues[0]);
+ } // Clear the array in order to avoid firing the change event for preselected values.
+
+
+ this._selectedToEmit.length = 0;
+ }
+ }
+ /** Selected values. */
+
+
+ get selected() {
+ if (!this._selected) {
+ this._selected = Array.from(this._selection.values());
+ }
+
+ return this._selected;
+ }
+ /**
+ * Selects a value or an array of values.
+ */
+
+
+ select(...values) {
+ this._verifyValueAssignment(values);
+
+ values.forEach(value => this._markSelected(value));
+
+ this._emitChangeEvent();
+ }
+ /**
+ * Deselects a value or an array of values.
+ */
+
+
+ deselect(...values) {
+ this._verifyValueAssignment(values);
+
+ values.forEach(value => this._unmarkSelected(value));
+
+ this._emitChangeEvent();
+ }
+ /**
+ * Toggles a value between selected and deselected.
+ */
+
+
+ toggle(value) {
+ this.isSelected(value) ? this.deselect(value) : this.select(value);
+ }
+ /**
+ * Clears all of the selected values.
+ */
+
+
+ clear() {
+ this._unmarkAll();
+
+ this._emitChangeEvent();
+ }
+ /**
+ * Determines whether a value is selected.
+ */
+
+
+ isSelected(value) {
+ return this._selection.has(value);
+ }
+ /**
+ * Determines whether the model does not have a value.
+ */
+
+
+ isEmpty() {
+ return this._selection.size === 0;
+ }
+ /**
+ * Determines whether the model has a value.
+ */
+
+
+ hasValue() {
+ return !this.isEmpty();
+ }
+ /**
+ * Sorts the selected values based on a predicate function.
+ */
+
+
+ sort(predicate) {
+ if (this._multiple && this.selected) {
+ this._selected.sort(predicate);
+ }
+ }
+ /**
+ * Gets whether multiple values can be selected.
+ */
+
+
+ isMultipleSelection() {
+ return this._multiple;
+ }
+ /** Emits a change event and clears the records of selected and deselected values. */
+
+
+ _emitChangeEvent() {
+ // Clear the selected values so they can be re-cached.
+ this._selected = null;
+
+ if (this._selectedToEmit.length || this._deselectedToEmit.length) {
+ this.changed.next({
+ source: this,
+ added: this._selectedToEmit,
+ removed: this._deselectedToEmit
+ });
+ this._deselectedToEmit = [];
+ this._selectedToEmit = [];
+ }
+ }
+ /** Selects a value. */
+
+
+ _markSelected(value) {
+ if (!this.isSelected(value)) {
+ if (!this._multiple) {
+ this._unmarkAll();
+ }
+
+ this._selection.add(value);
+
+ if (this._emitChanges) {
+ this._selectedToEmit.push(value);
+ }
+ }
+ }
+ /** Deselects a value. */
+
+
+ _unmarkSelected(value) {
+ if (this.isSelected(value)) {
+ this._selection.delete(value);
+
+ if (this._emitChanges) {
+ this._deselectedToEmit.push(value);
+ }
+ }
+ }
+ /** Clears out the selected values. */
+
+
+ _unmarkAll() {
+ if (!this.isEmpty()) {
+ this._selection.forEach(value => this._unmarkSelected(value));
+ }
+ }
+ /**
+ * Verifies the value assignment and throws an error if the specified value array is
+ * including multiple values while the selection model is not supporting multiple values.
+ */
+
+
+ _verifyValueAssignment(values) {
+ if (values.length > 1 && !this._multiple && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+ throw getMultipleValuesInSingleSelectionError();
+ }
+ }
+
+}
+/**
+ * Returns an error that reports that multiple values are passed into a selection model
+ * with a single value.
+ * @docs-private
+ */
+
+
+function getMultipleValuesInSingleSelectionError() {
+ return Error('Cannot pass multiple values into SelectionModel with single-value mode.');
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * Class to coordinate unique selection based on name.
+ * Intended to be consumed as an Angular service.
+ * This service is needed because native radio change events are only fired on the item currently
+ * being selected, and we still need to uncheck the previous selection.
+ *
+ * This service does not *store* any IDs and names because they may change at any time, so it is
+ * less error-prone if they are simply passed through when the events occur.
+ */
+
+
+class UniqueSelectionDispatcher {
+ constructor() {
+ this._listeners = [];
+ }
+ /**
+ * Notify other items that selection for the given name has been set.
+ * @param id ID of the item.
+ * @param name Name of the item.
+ */
+
+
+ notify(id, name) {
+ for (let listener of this._listeners) {
+ listener(id, name);
+ }
+ }
+ /**
+ * Listen for future changes to item selection.
+ * @return Function used to deregister listener
+ */
+
+
+ listen(listener) {
+ this._listeners.push(listener);
+
+ return () => {
+ this._listeners = this._listeners.filter(registered => {
+ return listener !== registered;
+ });
+ };
+ }
+
+ ngOnDestroy() {
+ this._listeners = [];
+ }
+
+}
+
+UniqueSelectionDispatcher.ɵfac = function UniqueSelectionDispatcher_Factory(t) {
+ return new (t || UniqueSelectionDispatcher)();
+};
+
+UniqueSelectionDispatcher.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdefineInjectable"]({
+ token: UniqueSelectionDispatcher,
+ factory: UniqueSelectionDispatcher.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵsetClassMetadata"](UniqueSelectionDispatcher, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], null, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * Injection token for {@link _ViewRepeater}. This token is for use by Angular Material only.
+ * @docs-private
+ */
+
+
+const _VIEW_REPEATER_STRATEGY = new _angular_core__WEBPACK_IMPORTED_MODULE_3__.InjectionToken('_ViewRepeater');
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+
+
+
+/***/ }),
+
+/***/ 8456:
+/*!*********************************************************!*\
+ !*** ./node_modules/@angular/cdk/fesm2020/keycodes.mjs ***!
+ \*********************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "A": () => (/* binding */ A),
+/* harmony export */ "ALT": () => (/* binding */ ALT),
+/* harmony export */ "APOSTROPHE": () => (/* binding */ APOSTROPHE),
+/* harmony export */ "AT_SIGN": () => (/* binding */ AT_SIGN),
+/* harmony export */ "B": () => (/* binding */ B),
+/* harmony export */ "BACKSLASH": () => (/* binding */ BACKSLASH),
+/* harmony export */ "BACKSPACE": () => (/* binding */ BACKSPACE),
+/* harmony export */ "C": () => (/* binding */ C),
+/* harmony export */ "CAPS_LOCK": () => (/* binding */ CAPS_LOCK),
+/* harmony export */ "CLOSE_SQUARE_BRACKET": () => (/* binding */ CLOSE_SQUARE_BRACKET),
+/* harmony export */ "COMMA": () => (/* binding */ COMMA),
+/* harmony export */ "CONTEXT_MENU": () => (/* binding */ CONTEXT_MENU),
+/* harmony export */ "CONTROL": () => (/* binding */ CONTROL),
+/* harmony export */ "D": () => (/* binding */ D),
+/* harmony export */ "DASH": () => (/* binding */ DASH),
+/* harmony export */ "DELETE": () => (/* binding */ DELETE),
+/* harmony export */ "DOWN_ARROW": () => (/* binding */ DOWN_ARROW),
+/* harmony export */ "E": () => (/* binding */ E),
+/* harmony export */ "EIGHT": () => (/* binding */ EIGHT),
+/* harmony export */ "END": () => (/* binding */ END),
+/* harmony export */ "ENTER": () => (/* binding */ ENTER),
+/* harmony export */ "EQUALS": () => (/* binding */ EQUALS),
+/* harmony export */ "ESCAPE": () => (/* binding */ ESCAPE),
+/* harmony export */ "F": () => (/* binding */ F),
+/* harmony export */ "F1": () => (/* binding */ F1),
+/* harmony export */ "F10": () => (/* binding */ F10),
+/* harmony export */ "F11": () => (/* binding */ F11),
+/* harmony export */ "F12": () => (/* binding */ F12),
+/* harmony export */ "F2": () => (/* binding */ F2),
+/* harmony export */ "F3": () => (/* binding */ F3),
+/* harmony export */ "F4": () => (/* binding */ F4),
+/* harmony export */ "F5": () => (/* binding */ F5),
+/* harmony export */ "F6": () => (/* binding */ F6),
+/* harmony export */ "F7": () => (/* binding */ F7),
+/* harmony export */ "F8": () => (/* binding */ F8),
+/* harmony export */ "F9": () => (/* binding */ F9),
+/* harmony export */ "FF_EQUALS": () => (/* binding */ FF_EQUALS),
+/* harmony export */ "FF_MINUS": () => (/* binding */ FF_MINUS),
+/* harmony export */ "FF_MUTE": () => (/* binding */ FF_MUTE),
+/* harmony export */ "FF_SEMICOLON": () => (/* binding */ FF_SEMICOLON),
+/* harmony export */ "FF_VOLUME_DOWN": () => (/* binding */ FF_VOLUME_DOWN),
+/* harmony export */ "FF_VOLUME_UP": () => (/* binding */ FF_VOLUME_UP),
+/* harmony export */ "FIRST_MEDIA": () => (/* binding */ FIRST_MEDIA),
+/* harmony export */ "FIVE": () => (/* binding */ FIVE),
+/* harmony export */ "FOUR": () => (/* binding */ FOUR),
+/* harmony export */ "G": () => (/* binding */ G),
+/* harmony export */ "H": () => (/* binding */ H),
+/* harmony export */ "HOME": () => (/* binding */ HOME),
+/* harmony export */ "I": () => (/* binding */ I),
+/* harmony export */ "INSERT": () => (/* binding */ INSERT),
+/* harmony export */ "J": () => (/* binding */ J),
+/* harmony export */ "K": () => (/* binding */ K),
+/* harmony export */ "L": () => (/* binding */ L),
+/* harmony export */ "LAST_MEDIA": () => (/* binding */ LAST_MEDIA),
+/* harmony export */ "LEFT_ARROW": () => (/* binding */ LEFT_ARROW),
+/* harmony export */ "M": () => (/* binding */ M),
+/* harmony export */ "MAC_ENTER": () => (/* binding */ MAC_ENTER),
+/* harmony export */ "MAC_META": () => (/* binding */ MAC_META),
+/* harmony export */ "MAC_WK_CMD_LEFT": () => (/* binding */ MAC_WK_CMD_LEFT),
+/* harmony export */ "MAC_WK_CMD_RIGHT": () => (/* binding */ MAC_WK_CMD_RIGHT),
+/* harmony export */ "META": () => (/* binding */ META),
+/* harmony export */ "MUTE": () => (/* binding */ MUTE),
+/* harmony export */ "N": () => (/* binding */ N),
+/* harmony export */ "NINE": () => (/* binding */ NINE),
+/* harmony export */ "NUMPAD_DIVIDE": () => (/* binding */ NUMPAD_DIVIDE),
+/* harmony export */ "NUMPAD_EIGHT": () => (/* binding */ NUMPAD_EIGHT),
+/* harmony export */ "NUMPAD_FIVE": () => (/* binding */ NUMPAD_FIVE),
+/* harmony export */ "NUMPAD_FOUR": () => (/* binding */ NUMPAD_FOUR),
+/* harmony export */ "NUMPAD_MINUS": () => (/* binding */ NUMPAD_MINUS),
+/* harmony export */ "NUMPAD_MULTIPLY": () => (/* binding */ NUMPAD_MULTIPLY),
+/* harmony export */ "NUMPAD_NINE": () => (/* binding */ NUMPAD_NINE),
+/* harmony export */ "NUMPAD_ONE": () => (/* binding */ NUMPAD_ONE),
+/* harmony export */ "NUMPAD_PERIOD": () => (/* binding */ NUMPAD_PERIOD),
+/* harmony export */ "NUMPAD_PLUS": () => (/* binding */ NUMPAD_PLUS),
+/* harmony export */ "NUMPAD_SEVEN": () => (/* binding */ NUMPAD_SEVEN),
+/* harmony export */ "NUMPAD_SIX": () => (/* binding */ NUMPAD_SIX),
+/* harmony export */ "NUMPAD_THREE": () => (/* binding */ NUMPAD_THREE),
+/* harmony export */ "NUMPAD_TWO": () => (/* binding */ NUMPAD_TWO),
+/* harmony export */ "NUMPAD_ZERO": () => (/* binding */ NUMPAD_ZERO),
+/* harmony export */ "NUM_CENTER": () => (/* binding */ NUM_CENTER),
+/* harmony export */ "NUM_LOCK": () => (/* binding */ NUM_LOCK),
+/* harmony export */ "O": () => (/* binding */ O),
+/* harmony export */ "ONE": () => (/* binding */ ONE),
+/* harmony export */ "OPEN_SQUARE_BRACKET": () => (/* binding */ OPEN_SQUARE_BRACKET),
+/* harmony export */ "P": () => (/* binding */ P),
+/* harmony export */ "PAGE_DOWN": () => (/* binding */ PAGE_DOWN),
+/* harmony export */ "PAGE_UP": () => (/* binding */ PAGE_UP),
+/* harmony export */ "PAUSE": () => (/* binding */ PAUSE),
+/* harmony export */ "PERIOD": () => (/* binding */ PERIOD),
+/* harmony export */ "PLUS_SIGN": () => (/* binding */ PLUS_SIGN),
+/* harmony export */ "PRINT_SCREEN": () => (/* binding */ PRINT_SCREEN),
+/* harmony export */ "Q": () => (/* binding */ Q),
+/* harmony export */ "QUESTION_MARK": () => (/* binding */ QUESTION_MARK),
+/* harmony export */ "R": () => (/* binding */ R),
+/* harmony export */ "RIGHT_ARROW": () => (/* binding */ RIGHT_ARROW),
+/* harmony export */ "S": () => (/* binding */ S),
+/* harmony export */ "SCROLL_LOCK": () => (/* binding */ SCROLL_LOCK),
+/* harmony export */ "SEMICOLON": () => (/* binding */ SEMICOLON),
+/* harmony export */ "SEVEN": () => (/* binding */ SEVEN),
+/* harmony export */ "SHIFT": () => (/* binding */ SHIFT),
+/* harmony export */ "SINGLE_QUOTE": () => (/* binding */ SINGLE_QUOTE),
+/* harmony export */ "SIX": () => (/* binding */ SIX),
+/* harmony export */ "SLASH": () => (/* binding */ SLASH),
+/* harmony export */ "SPACE": () => (/* binding */ SPACE),
+/* harmony export */ "T": () => (/* binding */ T),
+/* harmony export */ "TAB": () => (/* binding */ TAB),
+/* harmony export */ "THREE": () => (/* binding */ THREE),
+/* harmony export */ "TILDE": () => (/* binding */ TILDE),
+/* harmony export */ "TWO": () => (/* binding */ TWO),
+/* harmony export */ "U": () => (/* binding */ U),
+/* harmony export */ "UP_ARROW": () => (/* binding */ UP_ARROW),
+/* harmony export */ "V": () => (/* binding */ V),
+/* harmony export */ "VOLUME_DOWN": () => (/* binding */ VOLUME_DOWN),
+/* harmony export */ "VOLUME_UP": () => (/* binding */ VOLUME_UP),
+/* harmony export */ "W": () => (/* binding */ W),
+/* harmony export */ "X": () => (/* binding */ X),
+/* harmony export */ "Y": () => (/* binding */ Y),
+/* harmony export */ "Z": () => (/* binding */ Z),
+/* harmony export */ "ZERO": () => (/* binding */ ZERO),
+/* harmony export */ "hasModifierKey": () => (/* binding */ hasModifierKey)
+/* harmony export */ });
+/**
+ * @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.io/license
+ */
+const MAC_ENTER = 3;
+const BACKSPACE = 8;
+const TAB = 9;
+const NUM_CENTER = 12;
+const ENTER = 13;
+const SHIFT = 16;
+const CONTROL = 17;
+const ALT = 18;
+const PAUSE = 19;
+const CAPS_LOCK = 20;
+const ESCAPE = 27;
+const SPACE = 32;
+const PAGE_UP = 33;
+const PAGE_DOWN = 34;
+const END = 35;
+const HOME = 36;
+const LEFT_ARROW = 37;
+const UP_ARROW = 38;
+const RIGHT_ARROW = 39;
+const DOWN_ARROW = 40;
+const PLUS_SIGN = 43;
+const PRINT_SCREEN = 44;
+const INSERT = 45;
+const DELETE = 46;
+const ZERO = 48;
+const ONE = 49;
+const TWO = 50;
+const THREE = 51;
+const FOUR = 52;
+const FIVE = 53;
+const SIX = 54;
+const SEVEN = 55;
+const EIGHT = 56;
+const NINE = 57;
+const FF_SEMICOLON = 59; // Firefox (Gecko) fires this for semicolon instead of 186
+
+const FF_EQUALS = 61; // Firefox (Gecko) fires this for equals instead of 187
+
+const QUESTION_MARK = 63;
+const AT_SIGN = 64;
+const A = 65;
+const B = 66;
+const C = 67;
+const D = 68;
+const E = 69;
+const F = 70;
+const G = 71;
+const H = 72;
+const I = 73;
+const J = 74;
+const K = 75;
+const L = 76;
+const M = 77;
+const N = 78;
+const O = 79;
+const P = 80;
+const Q = 81;
+const R = 82;
+const S = 83;
+const T = 84;
+const U = 85;
+const V = 86;
+const W = 87;
+const X = 88;
+const Y = 89;
+const Z = 90;
+const META = 91; // WIN_KEY_LEFT
+
+const MAC_WK_CMD_LEFT = 91;
+const MAC_WK_CMD_RIGHT = 93;
+const CONTEXT_MENU = 93;
+const NUMPAD_ZERO = 96;
+const NUMPAD_ONE = 97;
+const NUMPAD_TWO = 98;
+const NUMPAD_THREE = 99;
+const NUMPAD_FOUR = 100;
+const NUMPAD_FIVE = 101;
+const NUMPAD_SIX = 102;
+const NUMPAD_SEVEN = 103;
+const NUMPAD_EIGHT = 104;
+const NUMPAD_NINE = 105;
+const NUMPAD_MULTIPLY = 106;
+const NUMPAD_PLUS = 107;
+const NUMPAD_MINUS = 109;
+const NUMPAD_PERIOD = 110;
+const NUMPAD_DIVIDE = 111;
+const F1 = 112;
+const F2 = 113;
+const F3 = 114;
+const F4 = 115;
+const F5 = 116;
+const F6 = 117;
+const F7 = 118;
+const F8 = 119;
+const F9 = 120;
+const F10 = 121;
+const F11 = 122;
+const F12 = 123;
+const NUM_LOCK = 144;
+const SCROLL_LOCK = 145;
+const FIRST_MEDIA = 166;
+const FF_MINUS = 173;
+const MUTE = 173; // Firefox (Gecko) fires 181 for MUTE
+
+const VOLUME_DOWN = 174; // Firefox (Gecko) fires 182 for VOLUME_DOWN
+
+const VOLUME_UP = 175; // Firefox (Gecko) fires 183 for VOLUME_UP
+
+const FF_MUTE = 181;
+const FF_VOLUME_DOWN = 182;
+const LAST_MEDIA = 183;
+const FF_VOLUME_UP = 183;
+const SEMICOLON = 186; // Firefox (Gecko) fires 59 for SEMICOLON
+
+const EQUALS = 187; // Firefox (Gecko) fires 61 for EQUALS
+
+const COMMA = 188;
+const DASH = 189; // Firefox (Gecko) fires 173 for DASH/MINUS
+
+const PERIOD = 190;
+const SLASH = 191;
+const APOSTROPHE = 192;
+const TILDE = 192;
+const OPEN_SQUARE_BRACKET = 219;
+const BACKSLASH = 220;
+const CLOSE_SQUARE_BRACKET = 221;
+const SINGLE_QUOTE = 222;
+const MAC_META = 224;
+/**
+ * @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.io/license
+ */
+
+/**
+ * Checks whether a modifier key is pressed.
+ * @param event Event to be checked.
+ */
+
+function hasModifierKey(event, ...modifiers) {
+ if (modifiers.length) {
+ return modifiers.some(modifier => event[modifier]);
+ }
+
+ return event.altKey || event.shiftKey || event.ctrlKey || event.metaKey;
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+
+
+
+/***/ }),
+
+/***/ 3278:
+/*!*******************************************************!*\
+ !*** ./node_modules/@angular/cdk/fesm2020/layout.mjs ***!
+ \*******************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "BreakpointObserver": () => (/* binding */ BreakpointObserver),
+/* harmony export */ "Breakpoints": () => (/* binding */ Breakpoints),
+/* harmony export */ "LayoutModule": () => (/* binding */ LayoutModule),
+/* harmony export */ "MediaMatcher": () => (/* binding */ MediaMatcher)
+/* harmony export */ });
+/* harmony import */ var _angular_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @angular/core */ 2560);
+/* harmony import */ var _angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @angular/cdk/coercion */ 8971);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! rxjs */ 228);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! rxjs */ 6562);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! rxjs */ 4240);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! rxjs */ 833);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! rxjs/operators */ 9295);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! rxjs/operators */ 7260);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! rxjs/operators */ 1989);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! rxjs/operators */ 635);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! rxjs/operators */ 4874);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! rxjs/operators */ 8951);
+/* harmony import */ var _angular_cdk_platform__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @angular/cdk/platform */ 9107);
+
+
+
+
+
+
+/**
+ * @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.io/license
+ */
+
+class LayoutModule {}
+
+LayoutModule.ɵfac = function LayoutModule_Factory(t) {
+ return new (t || LayoutModule)();
+};
+
+LayoutModule.ɵmod = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineNgModule"]({
+ type: LayoutModule
+});
+LayoutModule.ɵinj = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjector"]({});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](LayoutModule, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgModule,
+ args: [{}]
+ }], null, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/** Global registry for all dynamically-created, injected media queries. */
+
+
+const mediaQueriesForWebkitCompatibility = new Set();
+/** Style tag that holds all of the dynamically-created media queries. */
+
+let mediaQueryStyleNode;
+/** A utility for calling matchMedia queries. */
+
+class MediaMatcher {
+ constructor(_platform) {
+ this._platform = _platform;
+ this._matchMedia = this._platform.isBrowser && window.matchMedia ? // matchMedia is bound to the window scope intentionally as it is an illegal invocation to
+ // call it from a different scope.
+ window.matchMedia.bind(window) : noopMatchMedia;
+ }
+ /**
+ * Evaluates the given media query and returns the native MediaQueryList from which results
+ * can be retrieved.
+ * Confirms the layout engine will trigger for the selector query provided and returns the
+ * MediaQueryList for the query provided.
+ */
+
+
+ matchMedia(query) {
+ if (this._platform.WEBKIT || this._platform.BLINK) {
+ createEmptyStyleRule(query);
+ }
+
+ return this._matchMedia(query);
+ }
+
+}
+
+MediaMatcher.ɵfac = function MediaMatcher_Factory(t) {
+ return new (t || MediaMatcher)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_1__.Platform));
+};
+
+MediaMatcher.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjectable"]({
+ token: MediaMatcher,
+ factory: MediaMatcher.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](MediaMatcher, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: _angular_cdk_platform__WEBPACK_IMPORTED_MODULE_1__.Platform
+ }];
+ }, null);
+})();
+/**
+ * Creates an empty stylesheet that is used to work around browser inconsistencies related to
+ * `matchMedia`. At the time of writing, it handles the following cases:
+ * 1. On WebKit browsers, a media query has to have at least one rule in order for `matchMedia`
+ * to fire. We work around it by declaring a dummy stylesheet with a `@media` declaration.
+ * 2. In some cases Blink browsers will stop firing the `matchMedia` listener if none of the rules
+ * inside the `@media` match existing elements on the page. We work around it by having one rule
+ * targeting the `body`. See https://github.com/angular/components/issues/23546.
+ */
+
+
+function createEmptyStyleRule(query) {
+ if (mediaQueriesForWebkitCompatibility.has(query)) {
+ return;
+ }
+
+ try {
+ if (!mediaQueryStyleNode) {
+ mediaQueryStyleNode = document.createElement('style');
+ mediaQueryStyleNode.setAttribute('type', 'text/css');
+ document.head.appendChild(mediaQueryStyleNode);
+ }
+
+ if (mediaQueryStyleNode.sheet) {
+ mediaQueryStyleNode.sheet.insertRule(`@media ${query} {body{ }}`, 0);
+ mediaQueriesForWebkitCompatibility.add(query);
+ }
+ } catch (e) {
+ console.error(e);
+ }
+}
+/** No-op matchMedia replacement for non-browser platforms. */
+
+
+function noopMatchMedia(query) {
+ // Use `as any` here to avoid adding additional necessary properties for
+ // the noop matcher.
+ return {
+ matches: query === 'all' || query === '',
+ media: query,
+ addListener: () => {},
+ removeListener: () => {}
+ };
+}
+/**
+ * @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.io/license
+ */
+
+/** Utility for checking the matching state of @media queries. */
+
+
+class BreakpointObserver {
+ constructor(_mediaMatcher, _zone) {
+ this._mediaMatcher = _mediaMatcher;
+ this._zone = _zone;
+ /** A map of all media queries currently being listened for. */
+
+ this._queries = new Map();
+ /** A subject for all other observables to takeUntil based on. */
+
+ this._destroySubject = new rxjs__WEBPACK_IMPORTED_MODULE_2__.Subject();
+ }
+ /** Completes the active subject, signalling to all other observables to complete. */
+
+
+ ngOnDestroy() {
+ this._destroySubject.next();
+
+ this._destroySubject.complete();
+ }
+ /**
+ * Whether one or more media queries match the current viewport size.
+ * @param value One or more media queries to check.
+ * @returns Whether any of the media queries match.
+ */
+
+
+ isMatched(value) {
+ const queries = splitQueries((0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_3__.coerceArray)(value));
+ return queries.some(mediaQuery => this._registerQuery(mediaQuery).mql.matches);
+ }
+ /**
+ * Gets an observable of results for the given queries that will emit new results for any changes
+ * in matching of the given queries.
+ * @param value One or more media queries to check.
+ * @returns A stream of matches for the given queries.
+ */
+
+
+ observe(value) {
+ const queries = splitQueries((0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_3__.coerceArray)(value));
+ const observables = queries.map(query => this._registerQuery(query).observable);
+ let stateObservable = (0,rxjs__WEBPACK_IMPORTED_MODULE_4__.combineLatest)(observables); // Emit the first state immediately, and then debounce the subsequent emissions.
+
+ stateObservable = (0,rxjs__WEBPACK_IMPORTED_MODULE_5__.concat)(stateObservable.pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_6__.take)(1)), stateObservable.pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_7__.skip)(1), (0,rxjs_operators__WEBPACK_IMPORTED_MODULE_8__.debounceTime)(0)));
+ return stateObservable.pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_9__.map)(breakpointStates => {
+ const response = {
+ matches: false,
+ breakpoints: {}
+ };
+ breakpointStates.forEach(({
+ matches,
+ query
+ }) => {
+ response.matches = response.matches || matches;
+ response.breakpoints[query] = matches;
+ });
+ return response;
+ }));
+ }
+ /** Registers a specific query to be listened for. */
+
+
+ _registerQuery(query) {
+ // Only set up a new MediaQueryList if it is not already being listened for.
+ if (this._queries.has(query)) {
+ return this._queries.get(query);
+ }
+
+ const mql = this._mediaMatcher.matchMedia(query); // Create callback for match changes and add it is as a listener.
+
+
+ const queryObservable = new rxjs__WEBPACK_IMPORTED_MODULE_10__.Observable(observer => {
+ // Listener callback methods are wrapped to be placed back in ngZone. Callbacks must be placed
+ // back into the zone because matchMedia is only included in Zone.js by loading the
+ // webapis-media-query.js file alongside the zone.js file. Additionally, some browsers do not
+ // have MediaQueryList inherit from EventTarget, which causes inconsistencies in how Zone.js
+ // patches it.
+ const handler = e => this._zone.run(() => observer.next(e));
+
+ mql.addListener(handler);
+ return () => {
+ mql.removeListener(handler);
+ };
+ }).pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_11__.startWith)(mql), (0,rxjs_operators__WEBPACK_IMPORTED_MODULE_9__.map)(({
+ matches
+ }) => ({
+ query,
+ matches
+ })), (0,rxjs_operators__WEBPACK_IMPORTED_MODULE_12__.takeUntil)(this._destroySubject)); // Add the MediaQueryList to the set of queries.
+
+ const output = {
+ observable: queryObservable,
+ mql
+ };
+
+ this._queries.set(query, output);
+
+ return output;
+ }
+
+}
+
+BreakpointObserver.ɵfac = function BreakpointObserver_Factory(t) {
+ return new (t || BreakpointObserver)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](MediaMatcher), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone));
+};
+
+BreakpointObserver.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjectable"]({
+ token: BreakpointObserver,
+ factory: BreakpointObserver.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](BreakpointObserver, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: MediaMatcher
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone
+ }];
+ }, null);
+})();
+/**
+ * Split each query string into separate query strings if two queries are provided as comma
+ * separated.
+ */
+
+
+function splitQueries(queries) {
+ return queries.map(query => query.split(',')).reduce((a1, a2) => a1.concat(a2)).map(query => query.trim());
+}
+/**
+ * @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.io/license
+ */
+// PascalCase is being used as Breakpoints is used like an enum.
+// tslint:disable-next-line:variable-name
+
+
+const Breakpoints = {
+ XSmall: '(max-width: 599.98px)',
+ Small: '(min-width: 600px) and (max-width: 959.98px)',
+ Medium: '(min-width: 960px) and (max-width: 1279.98px)',
+ Large: '(min-width: 1280px) and (max-width: 1919.98px)',
+ XLarge: '(min-width: 1920px)',
+ Handset: '(max-width: 599.98px) and (orientation: portrait), ' + '(max-width: 959.98px) and (orientation: landscape)',
+ Tablet: '(min-width: 600px) and (max-width: 839.98px) and (orientation: portrait), ' + '(min-width: 960px) and (max-width: 1279.98px) and (orientation: landscape)',
+ Web: '(min-width: 840px) and (orientation: portrait), ' + '(min-width: 1280px) and (orientation: landscape)',
+ HandsetPortrait: '(max-width: 599.98px) and (orientation: portrait)',
+ TabletPortrait: '(min-width: 600px) and (max-width: 839.98px) and (orientation: portrait)',
+ WebPortrait: '(min-width: 840px) and (orientation: portrait)',
+ HandsetLandscape: '(max-width: 959.98px) and (orientation: landscape)',
+ TabletLandscape: '(min-width: 960px) and (max-width: 1279.98px) and (orientation: landscape)',
+ WebLandscape: '(min-width: 1280px) and (orientation: landscape)'
+};
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+
+
+/***/ }),
+
+/***/ 3773:
+/*!**********************************************************!*\
+ !*** ./node_modules/@angular/cdk/fesm2020/observers.mjs ***!
+ \**********************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "CdkObserveContent": () => (/* binding */ CdkObserveContent),
+/* harmony export */ "ContentObserver": () => (/* binding */ ContentObserver),
+/* harmony export */ "MutationObserverFactory": () => (/* binding */ MutationObserverFactory),
+/* harmony export */ "ObserversModule": () => (/* binding */ ObserversModule)
+/* harmony export */ });
+/* harmony import */ var _angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @angular/cdk/coercion */ 8971);
+/* harmony import */ var _angular_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @angular/core */ 2560);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! rxjs */ 833);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! rxjs */ 228);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! rxjs/operators */ 1989);
+
+
+
+
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * Factory that creates a new MutationObserver and allows us to stub it out in unit tests.
+ * @docs-private
+ */
+
+class MutationObserverFactory {
+ create(callback) {
+ return typeof MutationObserver === 'undefined' ? null : new MutationObserver(callback);
+ }
+
+}
+
+MutationObserverFactory.ɵfac = function MutationObserverFactory_Factory(t) {
+ return new (t || MutationObserverFactory)();
+};
+
+MutationObserverFactory.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjectable"]({
+ token: MutationObserverFactory,
+ factory: MutationObserverFactory.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](MutationObserverFactory, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], null, null);
+})();
+/** An injectable service that allows watching elements for changes to their content. */
+
+
+class ContentObserver {
+ constructor(_mutationObserverFactory) {
+ this._mutationObserverFactory = _mutationObserverFactory;
+ /** Keeps track of the existing MutationObservers so they can be reused. */
+
+ this._observedElements = new Map();
+ }
+
+ ngOnDestroy() {
+ this._observedElements.forEach((_, element) => this._cleanupObserver(element));
+ }
+
+ observe(elementOrRef) {
+ const element = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_1__.coerceElement)(elementOrRef);
+ return new rxjs__WEBPACK_IMPORTED_MODULE_2__.Observable(observer => {
+ const stream = this._observeElement(element);
+
+ const subscription = stream.subscribe(observer);
+ return () => {
+ subscription.unsubscribe();
+
+ this._unobserveElement(element);
+ };
+ });
+ }
+ /**
+ * Observes the given element by using the existing MutationObserver if available, or creating a
+ * new one if not.
+ */
+
+
+ _observeElement(element) {
+ if (!this._observedElements.has(element)) {
+ const stream = new rxjs__WEBPACK_IMPORTED_MODULE_3__.Subject();
+
+ const observer = this._mutationObserverFactory.create(mutations => stream.next(mutations));
+
+ if (observer) {
+ observer.observe(element, {
+ characterData: true,
+ childList: true,
+ subtree: true
+ });
+ }
+
+ this._observedElements.set(element, {
+ observer,
+ stream,
+ count: 1
+ });
+ } else {
+ this._observedElements.get(element).count++;
+ }
+
+ return this._observedElements.get(element).stream;
+ }
+ /**
+ * Un-observes the given element and cleans up the underlying MutationObserver if nobody else is
+ * observing this element.
+ */
+
+
+ _unobserveElement(element) {
+ if (this._observedElements.has(element)) {
+ this._observedElements.get(element).count--;
+
+ if (!this._observedElements.get(element).count) {
+ this._cleanupObserver(element);
+ }
+ }
+ }
+ /** Clean up the underlying MutationObserver for the specified element. */
+
+
+ _cleanupObserver(element) {
+ if (this._observedElements.has(element)) {
+ const {
+ observer,
+ stream
+ } = this._observedElements.get(element);
+
+ if (observer) {
+ observer.disconnect();
+ }
+
+ stream.complete();
+
+ this._observedElements.delete(element);
+ }
+ }
+
+}
+
+ContentObserver.ɵfac = function ContentObserver_Factory(t) {
+ return new (t || ContentObserver)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](MutationObserverFactory));
+};
+
+ContentObserver.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjectable"]({
+ token: ContentObserver,
+ factory: ContentObserver.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](ContentObserver, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: MutationObserverFactory
+ }];
+ }, null);
+})();
+/**
+ * Directive that triggers a callback whenever the content of
+ * its associated element has changed.
+ */
+
+
+class CdkObserveContent {
+ constructor(_contentObserver, _elementRef, _ngZone) {
+ this._contentObserver = _contentObserver;
+ this._elementRef = _elementRef;
+ this._ngZone = _ngZone;
+ /** Event emitted for each change in the element's content. */
+
+ this.event = new _angular_core__WEBPACK_IMPORTED_MODULE_0__.EventEmitter();
+ this._disabled = false;
+ this._currentSubscription = null;
+ }
+ /**
+ * Whether observing content is disabled. This option can be used
+ * to disconnect the underlying MutationObserver until it is needed.
+ */
+
+
+ get disabled() {
+ return this._disabled;
+ }
+
+ set disabled(value) {
+ this._disabled = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_1__.coerceBooleanProperty)(value);
+ this._disabled ? this._unsubscribe() : this._subscribe();
+ }
+ /** Debounce interval for emitting the changes. */
+
+
+ get debounce() {
+ return this._debounce;
+ }
+
+ set debounce(value) {
+ this._debounce = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_1__.coerceNumberProperty)(value);
+
+ this._subscribe();
+ }
+
+ ngAfterContentInit() {
+ if (!this._currentSubscription && !this.disabled) {
+ this._subscribe();
+ }
+ }
+
+ ngOnDestroy() {
+ this._unsubscribe();
+ }
+
+ _subscribe() {
+ this._unsubscribe();
+
+ const stream = this._contentObserver.observe(this._elementRef); // TODO(mmalerba): We shouldn't be emitting on this @Output() outside the zone.
+ // Consider brining it back inside the zone next time we're making breaking changes.
+ // Bringing it back inside can cause things like infinite change detection loops and changed
+ // after checked errors if people's code isn't handling it properly.
+
+
+ this._ngZone.runOutsideAngular(() => {
+ this._currentSubscription = (this.debounce ? stream.pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_4__.debounceTime)(this.debounce)) : stream).subscribe(this.event);
+ });
+ }
+
+ _unsubscribe() {
+ this._currentSubscription?.unsubscribe();
+ }
+
+}
+
+CdkObserveContent.ɵfac = function CdkObserveContent_Factory(t) {
+ return new (t || CdkObserveContent)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](ContentObserver), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.ElementRef), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone));
+};
+
+CdkObserveContent.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineDirective"]({
+ type: CdkObserveContent,
+ selectors: [["", "cdkObserveContent", ""]],
+ inputs: {
+ disabled: ["cdkObserveContentDisabled", "disabled"],
+ debounce: "debounce"
+ },
+ outputs: {
+ event: "cdkObserveContent"
+ },
+ exportAs: ["cdkObserveContent"]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](CdkObserveContent, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Directive,
+ args: [{
+ selector: '[cdkObserveContent]',
+ exportAs: 'cdkObserveContent'
+ }]
+ }], function () {
+ return [{
+ type: ContentObserver
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.ElementRef
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone
+ }];
+ }, {
+ event: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Output,
+ args: ['cdkObserveContent']
+ }],
+ disabled: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Input,
+ args: ['cdkObserveContentDisabled']
+ }],
+ debounce: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Input
+ }]
+ });
+})();
+
+class ObserversModule {}
+
+ObserversModule.ɵfac = function ObserversModule_Factory(t) {
+ return new (t || ObserversModule)();
+};
+
+ObserversModule.ɵmod = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineNgModule"]({
+ type: ObserversModule
+});
+ObserversModule.ɵinj = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjector"]({
+ providers: [MutationObserverFactory]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](ObserversModule, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgModule,
+ args: [{
+ exports: [CdkObserveContent],
+ declarations: [CdkObserveContent],
+ providers: [MutationObserverFactory]
+ }]
+ }], null, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+
+
+
+/***/ }),
+
+/***/ 5895:
+/*!********************************************************!*\
+ !*** ./node_modules/@angular/cdk/fesm2020/overlay.mjs ***!
+ \********************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "BlockScrollStrategy": () => (/* binding */ BlockScrollStrategy),
+/* harmony export */ "CdkConnectedOverlay": () => (/* binding */ CdkConnectedOverlay),
+/* harmony export */ "CdkOverlayOrigin": () => (/* binding */ CdkOverlayOrigin),
+/* harmony export */ "CdkScrollable": () => (/* reexport safe */ _angular_cdk_scrolling__WEBPACK_IMPORTED_MODULE_0__.CdkScrollable),
+/* harmony export */ "CloseScrollStrategy": () => (/* binding */ CloseScrollStrategy),
+/* harmony export */ "ConnectedOverlayPositionChange": () => (/* binding */ ConnectedOverlayPositionChange),
+/* harmony export */ "ConnectionPositionPair": () => (/* binding */ ConnectionPositionPair),
+/* harmony export */ "FlexibleConnectedPositionStrategy": () => (/* binding */ FlexibleConnectedPositionStrategy),
+/* harmony export */ "FullscreenOverlayContainer": () => (/* binding */ FullscreenOverlayContainer),
+/* harmony export */ "GlobalPositionStrategy": () => (/* binding */ GlobalPositionStrategy),
+/* harmony export */ "NoopScrollStrategy": () => (/* binding */ NoopScrollStrategy),
+/* harmony export */ "Overlay": () => (/* binding */ Overlay),
+/* harmony export */ "OverlayConfig": () => (/* binding */ OverlayConfig),
+/* harmony export */ "OverlayContainer": () => (/* binding */ OverlayContainer),
+/* harmony export */ "OverlayKeyboardDispatcher": () => (/* binding */ OverlayKeyboardDispatcher),
+/* harmony export */ "OverlayModule": () => (/* binding */ OverlayModule),
+/* harmony export */ "OverlayOutsideClickDispatcher": () => (/* binding */ OverlayOutsideClickDispatcher),
+/* harmony export */ "OverlayPositionBuilder": () => (/* binding */ OverlayPositionBuilder),
+/* harmony export */ "OverlayRef": () => (/* binding */ OverlayRef),
+/* harmony export */ "RepositionScrollStrategy": () => (/* binding */ RepositionScrollStrategy),
+/* harmony export */ "ScrollDispatcher": () => (/* reexport safe */ _angular_cdk_scrolling__WEBPACK_IMPORTED_MODULE_0__.ScrollDispatcher),
+/* harmony export */ "ScrollStrategyOptions": () => (/* binding */ ScrollStrategyOptions),
+/* harmony export */ "ScrollingVisibility": () => (/* binding */ ScrollingVisibility),
+/* harmony export */ "ViewportRuler": () => (/* reexport safe */ _angular_cdk_scrolling__WEBPACK_IMPORTED_MODULE_0__.ViewportRuler),
+/* harmony export */ "validateHorizontalPosition": () => (/* binding */ validateHorizontalPosition),
+/* harmony export */ "validateVerticalPosition": () => (/* binding */ validateVerticalPosition)
+/* harmony export */ });
+/* harmony import */ var _angular_cdk_scrolling__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @angular/cdk/scrolling */ 6328);
+/* harmony import */ var _angular_common__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @angular/common */ 4666);
+/* harmony import */ var _angular_core__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @angular/core */ 2560);
+/* harmony import */ var _angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @angular/cdk/coercion */ 8971);
+/* harmony import */ var _angular_cdk_platform__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @angular/cdk/platform */ 9107);
+/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! tslib */ 2321);
+/* harmony import */ var _angular_cdk_bidi__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! @angular/cdk/bidi */ 2867);
+/* harmony import */ var _angular_cdk_portal__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! @angular/cdk/portal */ 7520);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! rxjs */ 228);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! rxjs */ 6078);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! rxjs */ 6646);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! rxjs/operators */ 9295);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! rxjs/operators */ 8951);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! rxjs/operators */ 2566);
+/* harmony import */ var _angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! @angular/cdk/keycodes */ 8456);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * @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.io/license
+ */
+
+const scrollBehaviorSupported = (0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_1__.supportsScrollBehavior)();
+/**
+ * Strategy that will prevent the user from scrolling while the overlay is visible.
+ */
+
+class BlockScrollStrategy {
+ constructor(_viewportRuler, document) {
+ this._viewportRuler = _viewportRuler;
+ this._previousHTMLStyles = {
+ top: '',
+ left: ''
+ };
+ this._isEnabled = false;
+ this._document = document;
+ }
+ /** Attaches this scroll strategy to an overlay. */
+
+
+ attach() {}
+ /** Blocks page-level scroll while the attached overlay is open. */
+
+
+ enable() {
+ if (this._canBeEnabled()) {
+ const root = this._document.documentElement;
+ this._previousScrollPosition = this._viewportRuler.getViewportScrollPosition(); // Cache the previous inline styles in case the user had set them.
+
+ this._previousHTMLStyles.left = root.style.left || '';
+ this._previousHTMLStyles.top = root.style.top || ''; // Note: we're using the `html` node, instead of the `body`, because the `body` may
+ // have the user agent margin, whereas the `html` is guaranteed not to have one.
+
+ root.style.left = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(-this._previousScrollPosition.left);
+ root.style.top = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(-this._previousScrollPosition.top);
+ root.classList.add('cdk-global-scrollblock');
+ this._isEnabled = true;
+ }
+ }
+ /** Unblocks page-level scroll while the attached overlay is open. */
+
+
+ disable() {
+ if (this._isEnabled) {
+ const html = this._document.documentElement;
+ const body = this._document.body;
+ const htmlStyle = html.style;
+ const bodyStyle = body.style;
+ const previousHtmlScrollBehavior = htmlStyle.scrollBehavior || '';
+ const previousBodyScrollBehavior = bodyStyle.scrollBehavior || '';
+ this._isEnabled = false;
+ htmlStyle.left = this._previousHTMLStyles.left;
+ htmlStyle.top = this._previousHTMLStyles.top;
+ html.classList.remove('cdk-global-scrollblock'); // Disable user-defined smooth scrolling temporarily while we restore the scroll position.
+ // See https://developer.mozilla.org/en-US/docs/Web/CSS/scroll-behavior
+ // Note that we don't mutate the property if the browser doesn't support `scroll-behavior`,
+ // because it can throw off feature detections in `supportsScrollBehavior` which
+ // checks for `'scrollBehavior' in documentElement.style`.
+
+ if (scrollBehaviorSupported) {
+ htmlStyle.scrollBehavior = bodyStyle.scrollBehavior = 'auto';
+ }
+
+ window.scroll(this._previousScrollPosition.left, this._previousScrollPosition.top);
+
+ if (scrollBehaviorSupported) {
+ htmlStyle.scrollBehavior = previousHtmlScrollBehavior;
+ bodyStyle.scrollBehavior = previousBodyScrollBehavior;
+ }
+ }
+ }
+
+ _canBeEnabled() {
+ // Since the scroll strategies can't be singletons, we have to use a global CSS class
+ // (`cdk-global-scrollblock`) to make sure that we don't try to disable global
+ // scrolling multiple times.
+ const html = this._document.documentElement;
+
+ if (html.classList.contains('cdk-global-scrollblock') || this._isEnabled) {
+ return false;
+ }
+
+ const body = this._document.body;
+
+ const viewport = this._viewportRuler.getViewportSize();
+
+ return body.scrollHeight > viewport.height || body.scrollWidth > viewport.width;
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * Returns an error to be thrown when attempting to attach an already-attached scroll strategy.
+ */
+
+
+function getMatScrollStrategyAlreadyAttachedError() {
+ return Error(`Scroll strategy has already been attached.`);
+}
+/**
+ * Strategy that will close the overlay as soon as the user starts scrolling.
+ */
+
+
+class CloseScrollStrategy {
+ constructor(_scrollDispatcher, _ngZone, _viewportRuler, _config) {
+ this._scrollDispatcher = _scrollDispatcher;
+ this._ngZone = _ngZone;
+ this._viewportRuler = _viewportRuler;
+ this._config = _config;
+ this._scrollSubscription = null;
+ /** Detaches the overlay ref and disables the scroll strategy. */
+
+ this._detach = () => {
+ this.disable();
+
+ if (this._overlayRef.hasAttached()) {
+ this._ngZone.run(() => this._overlayRef.detach());
+ }
+ };
+ }
+ /** Attaches this scroll strategy to an overlay. */
+
+
+ attach(overlayRef) {
+ if (this._overlayRef && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+ throw getMatScrollStrategyAlreadyAttachedError();
+ }
+
+ this._overlayRef = overlayRef;
+ }
+ /** Enables the closing of the attached overlay on scroll. */
+
+
+ enable() {
+ if (this._scrollSubscription) {
+ return;
+ }
+
+ const stream = this._scrollDispatcher.scrolled(0);
+
+ if (this._config && this._config.threshold && this._config.threshold > 1) {
+ this._initialScrollPosition = this._viewportRuler.getViewportScrollPosition().top;
+ this._scrollSubscription = stream.subscribe(() => {
+ const scrollPosition = this._viewportRuler.getViewportScrollPosition().top;
+
+ if (Math.abs(scrollPosition - this._initialScrollPosition) > this._config.threshold) {
+ this._detach();
+ } else {
+ this._overlayRef.updatePosition();
+ }
+ });
+ } else {
+ this._scrollSubscription = stream.subscribe(this._detach);
+ }
+ }
+ /** Disables the closing the attached overlay on scroll. */
+
+
+ disable() {
+ if (this._scrollSubscription) {
+ this._scrollSubscription.unsubscribe();
+
+ this._scrollSubscription = null;
+ }
+ }
+
+ detach() {
+ this.disable();
+ this._overlayRef = null;
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+/** Scroll strategy that doesn't do anything. */
+
+
+class NoopScrollStrategy {
+ /** Does nothing, as this scroll strategy is a no-op. */
+ enable() {}
+ /** Does nothing, as this scroll strategy is a no-op. */
+
+
+ disable() {}
+ /** Does nothing, as this scroll strategy is a no-op. */
+
+
+ attach() {}
+
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * Gets whether an element is scrolled outside of view by any of its parent scrolling containers.
+ * @param element Dimensions of the element (from getBoundingClientRect)
+ * @param scrollContainers Dimensions of element's scrolling containers (from getBoundingClientRect)
+ * @returns Whether the element is scrolled out of view
+ * @docs-private
+ */
+
+
+function isElementScrolledOutsideView(element, scrollContainers) {
+ return scrollContainers.some(containerBounds => {
+ const outsideAbove = element.bottom < containerBounds.top;
+ const outsideBelow = element.top > containerBounds.bottom;
+ const outsideLeft = element.right < containerBounds.left;
+ const outsideRight = element.left > containerBounds.right;
+ return outsideAbove || outsideBelow || outsideLeft || outsideRight;
+ });
+}
+/**
+ * Gets whether an element is clipped by any of its scrolling containers.
+ * @param element Dimensions of the element (from getBoundingClientRect)
+ * @param scrollContainers Dimensions of element's scrolling containers (from getBoundingClientRect)
+ * @returns Whether the element is clipped
+ * @docs-private
+ */
+
+
+function isElementClippedByScrolling(element, scrollContainers) {
+ return scrollContainers.some(scrollContainerRect => {
+ const clippedAbove = element.top < scrollContainerRect.top;
+ const clippedBelow = element.bottom > scrollContainerRect.bottom;
+ const clippedLeft = element.left < scrollContainerRect.left;
+ const clippedRight = element.right > scrollContainerRect.right;
+ return clippedAbove || clippedBelow || clippedLeft || clippedRight;
+ });
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * Strategy that will update the element position as the user is scrolling.
+ */
+
+
+class RepositionScrollStrategy {
+ constructor(_scrollDispatcher, _viewportRuler, _ngZone, _config) {
+ this._scrollDispatcher = _scrollDispatcher;
+ this._viewportRuler = _viewportRuler;
+ this._ngZone = _ngZone;
+ this._config = _config;
+ this._scrollSubscription = null;
+ }
+ /** Attaches this scroll strategy to an overlay. */
+
+
+ attach(overlayRef) {
+ if (this._overlayRef && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+ throw getMatScrollStrategyAlreadyAttachedError();
+ }
+
+ this._overlayRef = overlayRef;
+ }
+ /** Enables repositioning of the attached overlay on scroll. */
+
+
+ enable() {
+ if (!this._scrollSubscription) {
+ const throttle = this._config ? this._config.scrollThrottle : 0;
+ this._scrollSubscription = this._scrollDispatcher.scrolled(throttle).subscribe(() => {
+ this._overlayRef.updatePosition(); // TODO(crisbeto): make `close` on by default once all components can handle it.
+
+
+ if (this._config && this._config.autoClose) {
+ const overlayRect = this._overlayRef.overlayElement.getBoundingClientRect();
+
+ const {
+ width,
+ height
+ } = this._viewportRuler.getViewportSize(); // TODO(crisbeto): include all ancestor scroll containers here once
+ // we have a way of exposing the trigger element to the scroll strategy.
+
+
+ const parentRects = [{
+ width,
+ height,
+ bottom: height,
+ right: width,
+ top: 0,
+ left: 0
+ }];
+
+ if (isElementScrolledOutsideView(overlayRect, parentRects)) {
+ this.disable();
+
+ this._ngZone.run(() => this._overlayRef.detach());
+ }
+ }
+ });
+ }
+ }
+ /** Disables repositioning of the attached overlay on scroll. */
+
+
+ disable() {
+ if (this._scrollSubscription) {
+ this._scrollSubscription.unsubscribe();
+
+ this._scrollSubscription = null;
+ }
+ }
+
+ detach() {
+ this.disable();
+ this._overlayRef = null;
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * 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.
+ */
+
+
+class ScrollStrategyOptions {
+ constructor(_scrollDispatcher, _viewportRuler, _ngZone, document) {
+ this._scrollDispatcher = _scrollDispatcher;
+ this._viewportRuler = _viewportRuler;
+ this._ngZone = _ngZone;
+ /** Do nothing on scroll. */
+
+ this.noop = () => new NoopScrollStrategy();
+ /**
+ * Close the overlay as soon as the user scrolls.
+ * @param config Configuration to be used inside the scroll strategy.
+ */
+
+
+ this.close = config => new CloseScrollStrategy(this._scrollDispatcher, this._ngZone, this._viewportRuler, config);
+ /** Block scrolling. */
+
+
+ this.block = () => new BlockScrollStrategy(this._viewportRuler, this._document);
+ /**
+ * Update the overlay's position on scroll.
+ * @param config Configuration to be used inside the scroll strategy.
+ * Allows debouncing the reposition calls.
+ */
+
+
+ this.reposition = config => new RepositionScrollStrategy(this._scrollDispatcher, this._viewportRuler, this._ngZone, config);
+
+ this._document = document;
+ }
+
+}
+
+ScrollStrategyOptions.ɵfac = function ScrollStrategyOptions_Factory(t) {
+ return new (t || ScrollStrategyOptions)(_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_cdk_scrolling__WEBPACK_IMPORTED_MODULE_0__.ScrollDispatcher), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_cdk_scrolling__WEBPACK_IMPORTED_MODULE_0__.ViewportRuler), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_core__WEBPACK_IMPORTED_MODULE_3__.NgZone), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_common__WEBPACK_IMPORTED_MODULE_4__.DOCUMENT));
+};
+
+ScrollStrategyOptions.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdefineInjectable"]({
+ token: ScrollStrategyOptions,
+ factory: ScrollStrategyOptions.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵsetClassMetadata"](ScrollStrategyOptions, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: _angular_cdk_scrolling__WEBPACK_IMPORTED_MODULE_0__.ScrollDispatcher
+ }, {
+ type: _angular_cdk_scrolling__WEBPACK_IMPORTED_MODULE_0__.ViewportRuler
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.NgZone
+ }, {
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_4__.DOCUMENT]
+ }]
+ }];
+ }, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/** Initial configuration used when creating an overlay. */
+
+
+class OverlayConfig {
+ constructor(config) {
+ /** Strategy to be used when handling scroll events while the overlay is open. */
+ this.scrollStrategy = new NoopScrollStrategy();
+ /** Custom class to add to the overlay pane. */
+
+ this.panelClass = '';
+ /** Whether the overlay has a backdrop. */
+
+ this.hasBackdrop = false;
+ /** Custom class to add to the backdrop */
+
+ this.backdropClass = 'cdk-overlay-dark-backdrop';
+ /**
+ * Whether the overlay should be disposed of when the user goes backwards/forwards in history.
+ * Note that this usually doesn't include clicking on links (unless the user is using
+ * the `HashLocationStrategy`).
+ */
+
+ this.disposeOnNavigation = false;
+
+ if (config) {
+ // Use `Iterable` instead of `Array` because TypeScript, as of 3.6.3,
+ // loses the array generic type in the `for of`. But we *also* have to use `Array` because
+ // typescript won't iterate over an `Iterable` unless you compile with `--downlevelIteration`
+ const configKeys = Object.keys(config);
+
+ for (const key of configKeys) {
+ if (config[key] !== undefined) {
+ // TypeScript, as of version 3.5, sees the left-hand-side of this expression
+ // as "I don't know *which* key this is, so the only valid value is the intersection
+ // of all the posible values." In this case, that happens to be `undefined`. TypeScript
+ // is not smart enough to see that the right-hand-side is actually an access of the same
+ // exact type with the same exact key, meaning that the value type must be identical.
+ // So we use `any` to work around this.
+ this[key] = config[key];
+ }
+ }
+ }
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+/** The points of the origin element and the overlay element to connect. */
+
+
+class ConnectionPositionPair {
+ constructor(origin, overlay,
+ /** Offset along the X axis. */
+ offsetX,
+ /** Offset along the Y axis. */
+ offsetY,
+ /** Class(es) to be applied to the panel while this position is active. */
+ panelClass) {
+ this.offsetX = offsetX;
+ this.offsetY = offsetY;
+ this.panelClass = panelClass;
+ this.originX = origin.originX;
+ this.originY = origin.originY;
+ this.overlayX = overlay.overlayX;
+ this.overlayY = overlay.overlayY;
+ }
+
+}
+/**
+ * Set of properties regarding the position of the origin and overlay relative to the viewport
+ * with respect to the containing Scrollable elements.
+ *
+ * The overlay and origin are clipped if any part of their bounding client rectangle exceeds the
+ * bounds of any one of the strategy's Scrollable's bounding client rectangle.
+ *
+ * The overlay and origin are outside view if there is no overlap between their bounding client
+ * rectangle and any one of the strategy's Scrollable's bounding client rectangle.
+ *
+ * ----------- -----------
+ * | outside | | clipped |
+ * | view | --------------------------
+ * | | | | | |
+ * ---------- | ----------- |
+ * -------------------------- | |
+ * | | | Scrollable |
+ * | | | |
+ * | | --------------------------
+ * | Scrollable |
+ * | |
+ * --------------------------
+ *
+ * @docs-private
+ */
+
+
+class ScrollingVisibility {}
+/** The change event emitted by the strategy when a fallback position is used. */
+
+
+let ConnectedOverlayPositionChange = class ConnectedOverlayPositionChange {
+ constructor(
+ /** The position used as a result of this change. */
+ connectionPair,
+ /** @docs-private */
+ scrollableViewProperties) {
+ this.connectionPair = connectionPair;
+ this.scrollableViewProperties = scrollableViewProperties;
+ }
+
+};
+ConnectedOverlayPositionChange = (0,tslib__WEBPACK_IMPORTED_MODULE_5__.__decorate)([(0,tslib__WEBPACK_IMPORTED_MODULE_5__.__param)(1, (0,_angular_core__WEBPACK_IMPORTED_MODULE_3__.Optional)()), (0,tslib__WEBPACK_IMPORTED_MODULE_5__.__metadata)("design:paramtypes", [ConnectionPositionPair, ScrollingVisibility])], ConnectedOverlayPositionChange);
+/**
+ * Validates whether a vertical position property matches the expected values.
+ * @param property Name of the property being validated.
+ * @param value Value of the property being validated.
+ * @docs-private
+ */
+
+function validateVerticalPosition(property, value) {
+ if (value !== 'top' && value !== 'bottom' && value !== 'center') {
+ throw Error(`ConnectedPosition: Invalid ${property} "${value}". ` + `Expected "top", "bottom" or "center".`);
+ }
+}
+/**
+ * Validates whether a horizontal position property matches the expected values.
+ * @param property Name of the property being validated.
+ * @param value Value of the property being validated.
+ * @docs-private
+ */
+
+
+function validateHorizontalPosition(property, value) {
+ if (value !== 'start' && value !== 'end' && value !== 'center') {
+ throw Error(`ConnectedPosition: Invalid ${property} "${value}". ` + `Expected "start", "end" or "center".`);
+ }
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * Service for dispatching events that land on the body to appropriate overlay ref,
+ * if any. It maintains a list of attached overlays to determine best suited overlay based
+ * on event target and order of overlay opens.
+ */
+
+
+class BaseOverlayDispatcher {
+ constructor(document) {
+ /** Currently attached overlays in the order they were attached. */
+ this._attachedOverlays = [];
+ this._document = document;
+ }
+
+ ngOnDestroy() {
+ this.detach();
+ }
+ /** Add a new overlay to the list of attached overlay refs. */
+
+
+ add(overlayRef) {
+ // Ensure that we don't get the same overlay multiple times.
+ this.remove(overlayRef);
+
+ this._attachedOverlays.push(overlayRef);
+ }
+ /** Remove an overlay from the list of attached overlay refs. */
+
+
+ remove(overlayRef) {
+ const index = this._attachedOverlays.indexOf(overlayRef);
+
+ if (index > -1) {
+ this._attachedOverlays.splice(index, 1);
+ } // Remove the global listener once there are no more overlays.
+
+
+ if (this._attachedOverlays.length === 0) {
+ this.detach();
+ }
+ }
+
+}
+
+BaseOverlayDispatcher.ɵfac = function BaseOverlayDispatcher_Factory(t) {
+ return new (t || BaseOverlayDispatcher)(_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_common__WEBPACK_IMPORTED_MODULE_4__.DOCUMENT));
+};
+
+BaseOverlayDispatcher.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdefineInjectable"]({
+ token: BaseOverlayDispatcher,
+ factory: BaseOverlayDispatcher.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵsetClassMetadata"](BaseOverlayDispatcher, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_4__.DOCUMENT]
+ }]
+ }];
+ }, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/**
+ * Service for dispatching keyboard events that land on the body to appropriate overlay ref,
+ * if any. It maintains a list of attached overlays to determine best suited overlay based
+ * on event target and order of overlay opens.
+ */
+
+
+class OverlayKeyboardDispatcher extends BaseOverlayDispatcher {
+ constructor(document) {
+ super(document);
+ /** Keyboard event listener that will be attached to the body. */
+
+ this._keydownListener = event => {
+ const overlays = this._attachedOverlays;
+
+ for (let i = overlays.length - 1; i > -1; i--) {
+ // Dispatch the keydown event to the top overlay which has subscribers to its keydown events.
+ // We want to target the most recent overlay, rather than trying to match where the event came
+ // from, because some components might open an overlay, but keep focus on a trigger element
+ // (e.g. for select and autocomplete). We skip overlays without keydown event subscriptions,
+ // because we don't want overlays that don't handle keyboard events to block the ones below
+ // them that do.
+ if (overlays[i]._keydownEvents.observers.length > 0) {
+ overlays[i]._keydownEvents.next(event);
+
+ break;
+ }
+ }
+ };
+ }
+ /** Add a new overlay to the list of attached overlay refs. */
+
+
+ add(overlayRef) {
+ super.add(overlayRef); // Lazily start dispatcher once first overlay is added
+
+ if (!this._isAttached) {
+ this._document.body.addEventListener('keydown', this._keydownListener);
+
+ this._isAttached = true;
+ }
+ }
+ /** Detaches the global keyboard event listener. */
+
+
+ detach() {
+ if (this._isAttached) {
+ this._document.body.removeEventListener('keydown', this._keydownListener);
+
+ this._isAttached = false;
+ }
+ }
+
+}
+
+OverlayKeyboardDispatcher.ɵfac = function OverlayKeyboardDispatcher_Factory(t) {
+ return new (t || OverlayKeyboardDispatcher)(_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_common__WEBPACK_IMPORTED_MODULE_4__.DOCUMENT));
+};
+
+OverlayKeyboardDispatcher.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdefineInjectable"]({
+ token: OverlayKeyboardDispatcher,
+ factory: OverlayKeyboardDispatcher.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵsetClassMetadata"](OverlayKeyboardDispatcher, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_4__.DOCUMENT]
+ }]
+ }];
+ }, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/**
+ * Service for dispatching mouse click events that land on the body to appropriate overlay ref,
+ * if any. It maintains a list of attached overlays to determine best suited overlay based
+ * on event target and order of overlay opens.
+ */
+
+
+class OverlayOutsideClickDispatcher extends BaseOverlayDispatcher {
+ constructor(document, _platform) {
+ super(document);
+ this._platform = _platform;
+ this._cursorStyleIsSet = false;
+ /** Store pointerdown event target to track origin of click. */
+
+ this._pointerDownListener = event => {
+ this._pointerDownEventTarget = (0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_1__._getEventTarget)(event);
+ };
+ /** Click event listener that will be attached to the body propagate phase. */
+
+
+ this._clickListener = event => {
+ const target = (0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_1__._getEventTarget)(event); // In case of a click event, we want to check the origin of the click
+ // (e.g. in case where a user starts a click inside the overlay and
+ // releases the click outside of it).
+ // This is done by using the event target of the preceding pointerdown event.
+ // Every click event caused by a pointer device has a preceding pointerdown
+ // event, unless the click was programmatically triggered (e.g. in a unit test).
+
+
+ const origin = event.type === 'click' && this._pointerDownEventTarget ? this._pointerDownEventTarget : target; // Reset the stored pointerdown event target, to avoid having it interfere
+ // in subsequent events.
+
+ this._pointerDownEventTarget = null; // We copy the array because the original may be modified asynchronously if the
+ // outsidePointerEvents listener decides to detach overlays resulting in index errors inside
+ // the for loop.
+
+ const overlays = this._attachedOverlays.slice(); // Dispatch the mouse event to the top overlay which has subscribers to its mouse events.
+ // We want to target all overlays for which the click could be considered as outside click.
+ // As soon as we reach an overlay for which the click is not outside click we break off
+ // the loop.
+
+
+ for (let i = overlays.length - 1; i > -1; i--) {
+ const overlayRef = overlays[i];
+
+ if (overlayRef._outsidePointerEvents.observers.length < 1 || !overlayRef.hasAttached()) {
+ continue;
+ } // If it's a click inside the overlay, just break - we should do nothing
+ // If it's an outside click (both origin and target of the click) dispatch the mouse event,
+ // and proceed with the next overlay
+
+
+ if (overlayRef.overlayElement.contains(target) || overlayRef.overlayElement.contains(origin)) {
+ break;
+ }
+
+ overlayRef._outsidePointerEvents.next(event);
+ }
+ };
+ }
+ /** Add a new overlay to the list of attached overlay refs. */
+
+
+ add(overlayRef) {
+ super.add(overlayRef); // Safari on iOS does not generate click events for non-interactive
+ // elements. However, we want to receive a click for any element outside
+ // the overlay. We can force a "clickable" state by setting
+ // `cursor: pointer` on the document body. See:
+ // https://developer.mozilla.org/en-US/docs/Web/API/Element/click_event#Safari_Mobile
+ // https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariWebContent/HandlingEvents/HandlingEvents.html
+
+ if (!this._isAttached) {
+ const body = this._document.body;
+ body.addEventListener('pointerdown', this._pointerDownListener, true);
+ body.addEventListener('click', this._clickListener, true);
+ body.addEventListener('auxclick', this._clickListener, true);
+ body.addEventListener('contextmenu', this._clickListener, true); // click event is not fired on iOS. To make element "clickable" we are
+ // setting the cursor to pointer
+
+ if (this._platform.IOS && !this._cursorStyleIsSet) {
+ this._cursorOriginalValue = body.style.cursor;
+ body.style.cursor = 'pointer';
+ this._cursorStyleIsSet = true;
+ }
+
+ this._isAttached = true;
+ }
+ }
+ /** Detaches the global keyboard event listener. */
+
+
+ detach() {
+ if (this._isAttached) {
+ const body = this._document.body;
+ body.removeEventListener('pointerdown', this._pointerDownListener, true);
+ body.removeEventListener('click', this._clickListener, true);
+ body.removeEventListener('auxclick', this._clickListener, true);
+ body.removeEventListener('contextmenu', this._clickListener, true);
+
+ if (this._platform.IOS && this._cursorStyleIsSet) {
+ body.style.cursor = this._cursorOriginalValue;
+ this._cursorStyleIsSet = false;
+ }
+
+ this._isAttached = false;
+ }
+ }
+
+}
+
+OverlayOutsideClickDispatcher.ɵfac = function OverlayOutsideClickDispatcher_Factory(t) {
+ return new (t || OverlayOutsideClickDispatcher)(_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_common__WEBPACK_IMPORTED_MODULE_4__.DOCUMENT), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_1__.Platform));
+};
+
+OverlayOutsideClickDispatcher.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdefineInjectable"]({
+ token: OverlayOutsideClickDispatcher,
+ factory: OverlayOutsideClickDispatcher.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵsetClassMetadata"](OverlayOutsideClickDispatcher, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_4__.DOCUMENT]
+ }]
+ }, {
+ type: _angular_cdk_platform__WEBPACK_IMPORTED_MODULE_1__.Platform
+ }];
+ }, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/** Container inside which all overlays will render. */
+
+
+class OverlayContainer {
+ constructor(document, _platform) {
+ this._platform = _platform;
+ this._document = document;
+ }
+
+ ngOnDestroy() {
+ this._containerElement?.remove();
+ }
+ /**
+ * This method returns the overlay container element. It will lazily
+ * create the element the first time it is called to facilitate using
+ * the container in non-browser environments.
+ * @returns the container element
+ */
+
+
+ getContainerElement() {
+ if (!this._containerElement) {
+ this._createContainer();
+ }
+
+ return this._containerElement;
+ }
+ /**
+ * Create the overlay container element, which is simply a div
+ * with the 'cdk-overlay-container' class on the document body.
+ */
+
+
+ _createContainer() {
+ const containerClass = 'cdk-overlay-container'; // TODO(crisbeto): remove the testing check once we have an overlay testing
+ // module or Angular starts tearing down the testing `NgModule`. See:
+ // https://github.com/angular/angular/issues/18831
+
+ if (this._platform.isBrowser || (0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_1__._isTestEnvironment)()) {
+ const oppositePlatformContainers = this._document.querySelectorAll(`.${containerClass}[platform="server"], ` + `.${containerClass}[platform="test"]`); // Remove any old containers from the opposite platform.
+ // This can happen when transitioning from the server to the client.
+
+
+ for (let i = 0; i < oppositePlatformContainers.length; i++) {
+ oppositePlatformContainers[i].remove();
+ }
+ }
+
+ const container = this._document.createElement('div');
+
+ container.classList.add(containerClass); // A long time ago we kept adding new overlay containers whenever a new app was instantiated,
+ // but at some point we added logic which clears the duplicate ones in order to avoid leaks.
+ // The new logic was a little too aggressive since it was breaking some legitimate use cases.
+ // To mitigate the problem we made it so that only containers from a different platform are
+ // cleared, but the side-effect was that people started depending on the overly-aggressive
+ // logic to clean up their tests for them. Until we can introduce an overlay-specific testing
+ // module which does the cleanup, we try to detect that we're in a test environment and we
+ // always clear the container. See #17006.
+ // TODO(crisbeto): remove the test environment check once we have an overlay testing module.
+
+ if ((0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_1__._isTestEnvironment)()) {
+ container.setAttribute('platform', 'test');
+ } else if (!this._platform.isBrowser) {
+ container.setAttribute('platform', 'server');
+ }
+
+ this._document.body.appendChild(container);
+
+ this._containerElement = container;
+ }
+
+}
+
+OverlayContainer.ɵfac = function OverlayContainer_Factory(t) {
+ return new (t || OverlayContainer)(_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_common__WEBPACK_IMPORTED_MODULE_4__.DOCUMENT), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_1__.Platform));
+};
+
+OverlayContainer.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdefineInjectable"]({
+ token: OverlayContainer,
+ factory: OverlayContainer.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵsetClassMetadata"](OverlayContainer, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_4__.DOCUMENT]
+ }]
+ }, {
+ type: _angular_cdk_platform__WEBPACK_IMPORTED_MODULE_1__.Platform
+ }];
+ }, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/**
+ * Reference to an overlay that has been created with the Overlay service.
+ * Used to manipulate or dispose of said overlay.
+ */
+
+
+class OverlayRef {
+ constructor(_portalOutlet, _host, _pane, _config, _ngZone, _keyboardDispatcher, _document, _location, _outsideClickDispatcher) {
+ this._portalOutlet = _portalOutlet;
+ this._host = _host;
+ this._pane = _pane;
+ this._config = _config;
+ this._ngZone = _ngZone;
+ this._keyboardDispatcher = _keyboardDispatcher;
+ this._document = _document;
+ this._location = _location;
+ this._outsideClickDispatcher = _outsideClickDispatcher;
+ this._backdropElement = null;
+ this._backdropClick = new rxjs__WEBPACK_IMPORTED_MODULE_6__.Subject();
+ this._attachments = new rxjs__WEBPACK_IMPORTED_MODULE_6__.Subject();
+ this._detachments = new rxjs__WEBPACK_IMPORTED_MODULE_6__.Subject();
+ this._locationChanges = rxjs__WEBPACK_IMPORTED_MODULE_7__.Subscription.EMPTY;
+
+ this._backdropClickHandler = event => this._backdropClick.next(event);
+ /** Stream of keydown events dispatched to this overlay. */
+
+
+ this._keydownEvents = new rxjs__WEBPACK_IMPORTED_MODULE_6__.Subject();
+ /** Stream of mouse outside events dispatched to this overlay. */
+
+ this._outsidePointerEvents = new rxjs__WEBPACK_IMPORTED_MODULE_6__.Subject();
+
+ if (_config.scrollStrategy) {
+ this._scrollStrategy = _config.scrollStrategy;
+
+ this._scrollStrategy.attach(this);
+ }
+
+ this._positionStrategy = _config.positionStrategy;
+ }
+ /** The overlay's HTML element */
+
+
+ get overlayElement() {
+ return this._pane;
+ }
+ /** The overlay's backdrop HTML element. */
+
+
+ get backdropElement() {
+ return this._backdropElement;
+ }
+ /**
+ * Wrapper around the panel element. Can be used for advanced
+ * positioning where a wrapper with specific styling is
+ * required around the overlay pane.
+ */
+
+
+ get hostElement() {
+ return this._host;
+ }
+ /**
+ * Attaches content, given via a Portal, to the overlay.
+ * If the overlay is configured to have a backdrop, it will be created.
+ *
+ * @param portal Portal instance to which to attach the overlay.
+ * @returns The portal attachment result.
+ */
+
+
+ attach(portal) {
+ let attachResult = this._portalOutlet.attach(portal); // Update the pane element with the given configuration.
+
+
+ if (!this._host.parentElement && this._previousHostParent) {
+ this._previousHostParent.appendChild(this._host);
+ }
+
+ if (this._positionStrategy) {
+ this._positionStrategy.attach(this);
+ }
+
+ this._updateStackingOrder();
+
+ this._updateElementSize();
+
+ this._updateElementDirection();
+
+ if (this._scrollStrategy) {
+ this._scrollStrategy.enable();
+ } // Update the position once the zone is stable so that the overlay will be fully rendered
+ // before attempting to position it, as the position may depend on the size of the rendered
+ // content.
+
+
+ this._ngZone.onStable.pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_8__.take)(1)).subscribe(() => {
+ // The overlay could've been detached before the zone has stabilized.
+ if (this.hasAttached()) {
+ this.updatePosition();
+ }
+ }); // Enable pointer events for the overlay pane element.
+
+
+ this._togglePointerEvents(true);
+
+ if (this._config.hasBackdrop) {
+ this._attachBackdrop();
+ }
+
+ if (this._config.panelClass) {
+ this._toggleClasses(this._pane, this._config.panelClass, true);
+ } // Only emit the `attachments` event once all other setup is done.
+
+
+ this._attachments.next(); // Track this overlay by the keyboard dispatcher
+
+
+ this._keyboardDispatcher.add(this);
+
+ if (this._config.disposeOnNavigation) {
+ this._locationChanges = this._location.subscribe(() => this.dispose());
+ }
+
+ this._outsideClickDispatcher.add(this);
+
+ return attachResult;
+ }
+ /**
+ * Detaches an overlay from a portal.
+ * @returns The portal detachment result.
+ */
+
+
+ detach() {
+ if (!this.hasAttached()) {
+ return;
+ }
+
+ this.detachBackdrop(); // When the overlay is detached, the pane element should disable pointer events.
+ // This is necessary because otherwise the pane element will cover the page and disable
+ // pointer events therefore. Depends on the position strategy and the applied pane boundaries.
+
+ this._togglePointerEvents(false);
+
+ if (this._positionStrategy && this._positionStrategy.detach) {
+ this._positionStrategy.detach();
+ }
+
+ if (this._scrollStrategy) {
+ this._scrollStrategy.disable();
+ }
+
+ const detachmentResult = this._portalOutlet.detach(); // Only emit after everything is detached.
+
+
+ this._detachments.next(); // Remove this overlay from keyboard dispatcher tracking.
+
+
+ this._keyboardDispatcher.remove(this); // Keeping the host element in the DOM can cause scroll jank, because it still gets
+ // rendered, even though it's transparent and unclickable which is why we remove it.
+
+
+ this._detachContentWhenStable();
+
+ this._locationChanges.unsubscribe();
+
+ this._outsideClickDispatcher.remove(this);
+
+ return detachmentResult;
+ }
+ /** Cleans up the overlay from the DOM. */
+
+
+ dispose() {
+ const isAttached = this.hasAttached();
+
+ if (this._positionStrategy) {
+ this._positionStrategy.dispose();
+ }
+
+ this._disposeScrollStrategy();
+
+ this._disposeBackdrop(this._backdropElement);
+
+ this._locationChanges.unsubscribe();
+
+ this._keyboardDispatcher.remove(this);
+
+ this._portalOutlet.dispose();
+
+ this._attachments.complete();
+
+ this._backdropClick.complete();
+
+ this._keydownEvents.complete();
+
+ this._outsidePointerEvents.complete();
+
+ this._outsideClickDispatcher.remove(this);
+
+ this._host?.remove();
+ this._previousHostParent = this._pane = this._host = null;
+
+ if (isAttached) {
+ this._detachments.next();
+ }
+
+ this._detachments.complete();
+ }
+ /** Whether the overlay has attached content. */
+
+
+ hasAttached() {
+ return this._portalOutlet.hasAttached();
+ }
+ /** Gets an observable that emits when the backdrop has been clicked. */
+
+
+ backdropClick() {
+ return this._backdropClick;
+ }
+ /** Gets an observable that emits when the overlay has been attached. */
+
+
+ attachments() {
+ return this._attachments;
+ }
+ /** Gets an observable that emits when the overlay has been detached. */
+
+
+ detachments() {
+ return this._detachments;
+ }
+ /** Gets an observable of keydown events targeted to this overlay. */
+
+
+ keydownEvents() {
+ return this._keydownEvents;
+ }
+ /** Gets an observable of pointer events targeted outside this overlay. */
+
+
+ outsidePointerEvents() {
+ return this._outsidePointerEvents;
+ }
+ /** Gets the current overlay configuration, which is immutable. */
+
+
+ getConfig() {
+ return this._config;
+ }
+ /** Updates the position of the overlay based on the position strategy. */
+
+
+ updatePosition() {
+ if (this._positionStrategy) {
+ this._positionStrategy.apply();
+ }
+ }
+ /** Switches to a new position strategy and updates the overlay position. */
+
+
+ updatePositionStrategy(strategy) {
+ if (strategy === this._positionStrategy) {
+ return;
+ }
+
+ if (this._positionStrategy) {
+ this._positionStrategy.dispose();
+ }
+
+ this._positionStrategy = strategy;
+
+ if (this.hasAttached()) {
+ strategy.attach(this);
+ this.updatePosition();
+ }
+ }
+ /** Update the size properties of the overlay. */
+
+
+ updateSize(sizeConfig) {
+ this._config = { ...this._config,
+ ...sizeConfig
+ };
+
+ this._updateElementSize();
+ }
+ /** Sets the LTR/RTL direction for the overlay. */
+
+
+ setDirection(dir) {
+ this._config = { ...this._config,
+ direction: dir
+ };
+
+ this._updateElementDirection();
+ }
+ /** Add a CSS class or an array of classes to the overlay pane. */
+
+
+ addPanelClass(classes) {
+ if (this._pane) {
+ this._toggleClasses(this._pane, classes, true);
+ }
+ }
+ /** Remove a CSS class or an array of classes from the overlay pane. */
+
+
+ removePanelClass(classes) {
+ if (this._pane) {
+ this._toggleClasses(this._pane, classes, false);
+ }
+ }
+ /**
+ * Returns the layout direction of the overlay panel.
+ */
+
+
+ getDirection() {
+ const direction = this._config.direction;
+
+ if (!direction) {
+ return 'ltr';
+ }
+
+ return typeof direction === 'string' ? direction : direction.value;
+ }
+ /** Switches to a new scroll strategy. */
+
+
+ updateScrollStrategy(strategy) {
+ if (strategy === this._scrollStrategy) {
+ return;
+ }
+
+ this._disposeScrollStrategy();
+
+ this._scrollStrategy = strategy;
+
+ if (this.hasAttached()) {
+ strategy.attach(this);
+ strategy.enable();
+ }
+ }
+ /** Updates the text direction of the overlay panel. */
+
+
+ _updateElementDirection() {
+ this._host.setAttribute('dir', this.getDirection());
+ }
+ /** Updates the size of the overlay element based on the overlay config. */
+
+
+ _updateElementSize() {
+ if (!this._pane) {
+ return;
+ }
+
+ const style = this._pane.style;
+ style.width = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(this._config.width);
+ style.height = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(this._config.height);
+ style.minWidth = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(this._config.minWidth);
+ style.minHeight = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(this._config.minHeight);
+ style.maxWidth = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(this._config.maxWidth);
+ style.maxHeight = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(this._config.maxHeight);
+ }
+ /** Toggles the pointer events for the overlay pane element. */
+
+
+ _togglePointerEvents(enablePointer) {
+ this._pane.style.pointerEvents = enablePointer ? '' : 'none';
+ }
+ /** Attaches a backdrop for this overlay. */
+
+
+ _attachBackdrop() {
+ const showingClass = 'cdk-overlay-backdrop-showing';
+ this._backdropElement = this._document.createElement('div');
+
+ this._backdropElement.classList.add('cdk-overlay-backdrop');
+
+ if (this._config.backdropClass) {
+ this._toggleClasses(this._backdropElement, this._config.backdropClass, true);
+ } // Insert the backdrop before the pane in the DOM order,
+ // in order to handle stacked overlays properly.
+
+
+ this._host.parentElement.insertBefore(this._backdropElement, this._host); // Forward backdrop clicks such that the consumer of the overlay can perform whatever
+ // action desired when such a click occurs (usually closing the overlay).
+
+
+ this._backdropElement.addEventListener('click', this._backdropClickHandler); // Add class to fade-in the backdrop after one frame.
+
+
+ if (typeof requestAnimationFrame !== 'undefined') {
+ this._ngZone.runOutsideAngular(() => {
+ requestAnimationFrame(() => {
+ if (this._backdropElement) {
+ this._backdropElement.classList.add(showingClass);
+ }
+ });
+ });
+ } else {
+ this._backdropElement.classList.add(showingClass);
+ }
+ }
+ /**
+ * Updates the stacking order of the element, moving it to the top if necessary.
+ * This is required in cases where one overlay was detached, while another one,
+ * that should be behind it, was destroyed. The next time both of them are opened,
+ * the stacking will be wrong, because the detached element's pane will still be
+ * in its original DOM position.
+ */
+
+
+ _updateStackingOrder() {
+ if (this._host.nextSibling) {
+ this._host.parentNode.appendChild(this._host);
+ }
+ }
+ /** Detaches the backdrop (if any) associated with the overlay. */
+
+
+ detachBackdrop() {
+ const backdropToDetach = this._backdropElement;
+
+ if (!backdropToDetach) {
+ return;
+ }
+
+ let timeoutId;
+
+ const finishDetach = () => {
+ // It may not be attached to anything in certain cases (e.g. unit tests).
+ if (backdropToDetach) {
+ backdropToDetach.removeEventListener('click', this._backdropClickHandler);
+ backdropToDetach.removeEventListener('transitionend', finishDetach);
+
+ this._disposeBackdrop(backdropToDetach);
+ }
+
+ if (this._config.backdropClass) {
+ this._toggleClasses(backdropToDetach, this._config.backdropClass, false);
+ }
+
+ clearTimeout(timeoutId);
+ };
+
+ backdropToDetach.classList.remove('cdk-overlay-backdrop-showing');
+
+ this._ngZone.runOutsideAngular(() => {
+ backdropToDetach.addEventListener('transitionend', finishDetach);
+ }); // If the backdrop doesn't have a transition, the `transitionend` event won't fire.
+ // In this case we make it unclickable and we try to remove it after a delay.
+
+
+ backdropToDetach.style.pointerEvents = 'none'; // Run this outside the Angular zone because there's nothing that Angular cares about.
+ // If it were to run inside the Angular zone, every test that used Overlay would have to be
+ // either async or fakeAsync.
+
+ timeoutId = this._ngZone.runOutsideAngular(() => setTimeout(finishDetach, 500));
+ }
+ /** Toggles a single CSS class or an array of classes on an element. */
+
+
+ _toggleClasses(element, cssClasses, isAdd) {
+ const classes = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceArray)(cssClasses || []).filter(c => !!c);
+
+ if (classes.length) {
+ isAdd ? element.classList.add(...classes) : element.classList.remove(...classes);
+ }
+ }
+ /** Detaches the overlay content next time the zone stabilizes. */
+
+
+ _detachContentWhenStable() {
+ // Normally we wouldn't have to explicitly run this outside the `NgZone`, however
+ // if the consumer is using `zone-patch-rxjs`, the `Subscription.unsubscribe` call will
+ // be patched to run inside the zone, which will throw us into an infinite loop.
+ this._ngZone.runOutsideAngular(() => {
+ // We can't remove the host here immediately, because the overlay pane's content
+ // might still be animating. This stream helps us avoid interrupting the animation
+ // by waiting for the pane to become empty.
+ const subscription = this._ngZone.onStable.pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_9__.takeUntil)((0,rxjs__WEBPACK_IMPORTED_MODULE_10__.merge)(this._attachments, this._detachments))).subscribe(() => {
+ // Needs a couple of checks for the pane and host, because
+ // they may have been removed by the time the zone stabilizes.
+ if (!this._pane || !this._host || this._pane.children.length === 0) {
+ if (this._pane && this._config.panelClass) {
+ this._toggleClasses(this._pane, this._config.panelClass, false);
+ }
+
+ if (this._host && this._host.parentElement) {
+ this._previousHostParent = this._host.parentElement;
+
+ this._host.remove();
+ }
+
+ subscription.unsubscribe();
+ }
+ });
+ });
+ }
+ /** Disposes of a scroll strategy. */
+
+
+ _disposeScrollStrategy() {
+ const scrollStrategy = this._scrollStrategy;
+
+ if (scrollStrategy) {
+ scrollStrategy.disable();
+
+ if (scrollStrategy.detach) {
+ scrollStrategy.detach();
+ }
+ }
+ }
+ /** Removes a backdrop element from the DOM. */
+
+
+ _disposeBackdrop(backdrop) {
+ if (backdrop) {
+ backdrop.remove(); // It is possible that a new portal has been attached to this overlay since we started
+ // removing the backdrop. If that is the case, only clear the backdrop reference if it
+ // is still the same instance that we started to remove.
+
+ if (this._backdropElement === backdrop) {
+ this._backdropElement = null;
+ }
+ }
+ }
+
+}
+/**
+ * @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.io/license
+ */
+// TODO: refactor clipping detection into a separate thing (part of scrolling module)
+// TODO: doesn't handle both flexible width and height when it has to scroll along both axis.
+
+/** Class to be added to the overlay bounding box. */
+
+
+const boundingBoxClass = 'cdk-overlay-connected-position-bounding-box';
+/** Regex used to split a string on its CSS units. */
+
+const cssUnitPattern = /([A-Za-z%]+)$/;
+/**
+ * A strategy for positioning overlays. Using this strategy, an overlay is given an
+ * implicit position relative some origin element. The relative position is defined in terms of
+ * a point on the origin element that is connected to a point on the overlay element. For example,
+ * a basic dropdown is connecting the bottom-left corner of the origin to the top-left corner
+ * of the overlay.
+ */
+
+class FlexibleConnectedPositionStrategy {
+ constructor(connectedTo, _viewportRuler, _document, _platform, _overlayContainer) {
+ this._viewportRuler = _viewportRuler;
+ this._document = _document;
+ this._platform = _platform;
+ this._overlayContainer = _overlayContainer;
+ /** Last size used for the bounding box. Used to avoid resizing the overlay after open. */
+
+ this._lastBoundingBoxSize = {
+ width: 0,
+ height: 0
+ };
+ /** Whether the overlay was pushed in a previous positioning. */
+
+ this._isPushed = false;
+ /** Whether the overlay can be pushed on-screen on the initial open. */
+
+ this._canPush = true;
+ /** Whether the overlay can grow via flexible width/height after the initial open. */
+
+ this._growAfterOpen = false;
+ /** Whether the overlay's width and height can be constrained to fit within the viewport. */
+
+ this._hasFlexibleDimensions = true;
+ /** Whether the overlay position is locked. */
+
+ this._positionLocked = false;
+ /** Amount of space that must be maintained between the overlay and the edge of the viewport. */
+
+ this._viewportMargin = 0;
+ /** The Scrollable containers used to check scrollable view properties on position change. */
+
+ this._scrollables = [];
+ /** Ordered list of preferred positions, from most to least desirable. */
+
+ this._preferredPositions = [];
+ /** Subject that emits whenever the position changes. */
+
+ this._positionChanges = new rxjs__WEBPACK_IMPORTED_MODULE_6__.Subject();
+ /** Subscription to viewport size changes. */
+
+ this._resizeSubscription = rxjs__WEBPACK_IMPORTED_MODULE_7__.Subscription.EMPTY;
+ /** Default offset for the overlay along the x axis. */
+
+ this._offsetX = 0;
+ /** Default offset for the overlay along the y axis. */
+
+ this._offsetY = 0;
+ /** Keeps track of the CSS classes that the position strategy has applied on the overlay panel. */
+
+ this._appliedPanelClasses = [];
+ /** Observable sequence of position changes. */
+
+ this.positionChanges = this._positionChanges;
+ this.setOrigin(connectedTo);
+ }
+ /** Ordered list of preferred positions, from most to least desirable. */
+
+
+ get positions() {
+ return this._preferredPositions;
+ }
+ /** Attaches this position strategy to an overlay. */
+
+
+ attach(overlayRef) {
+ if (this._overlayRef && overlayRef !== this._overlayRef && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+ throw Error('This position strategy is already attached to an overlay');
+ }
+
+ this._validatePositions();
+
+ overlayRef.hostElement.classList.add(boundingBoxClass);
+ this._overlayRef = overlayRef;
+ this._boundingBox = overlayRef.hostElement;
+ this._pane = overlayRef.overlayElement;
+ this._isDisposed = false;
+ this._isInitialRender = true;
+ this._lastPosition = null;
+
+ this._resizeSubscription.unsubscribe();
+
+ this._resizeSubscription = this._viewportRuler.change().subscribe(() => {
+ // When the window is resized, we want to trigger the next reposition as if it
+ // was an initial render, in order for the strategy to pick a new optimal position,
+ // otherwise position locking will cause it to stay at the old one.
+ this._isInitialRender = true;
+ this.apply();
+ });
+ }
+ /**
+ * Updates the position of the overlay element, using whichever preferred position relative
+ * to the origin best fits on-screen.
+ *
+ * The selection of a position goes as follows:
+ * - If any positions fit completely within the viewport as-is,
+ * choose the first position that does so.
+ * - If flexible dimensions are enabled and at least one satifies the given minimum width/height,
+ * choose the position with the greatest available size modified by the positions' weight.
+ * - If pushing is enabled, take the position that went off-screen the least and push it
+ * on-screen.
+ * - If none of the previous criteria were met, use the position that goes off-screen the least.
+ * @docs-private
+ */
+
+
+ apply() {
+ // We shouldn't do anything if the strategy was disposed or we're on the server.
+ if (this._isDisposed || !this._platform.isBrowser) {
+ return;
+ } // If the position has been applied already (e.g. when the overlay was opened) and the
+ // consumer opted into locking in the position, re-use the old position, in order to
+ // prevent the overlay from jumping around.
+
+
+ if (!this._isInitialRender && this._positionLocked && this._lastPosition) {
+ this.reapplyLastPosition();
+ return;
+ }
+
+ this._clearPanelClasses();
+
+ this._resetOverlayElementStyles();
+
+ this._resetBoundingBoxStyles(); // We need the bounding rects for the origin and the overlay to determine how to position
+ // the overlay relative to the origin.
+ // We use the viewport rect to determine whether a position would go off-screen.
+
+
+ this._viewportRect = this._getNarrowedViewportRect();
+ this._originRect = this._getOriginRect();
+ this._overlayRect = this._pane.getBoundingClientRect();
+ const originRect = this._originRect;
+ const overlayRect = this._overlayRect;
+ const viewportRect = this._viewportRect; // Positions where the overlay will fit with flexible dimensions.
+
+ const flexibleFits = []; // Fallback if none of the preferred positions fit within the viewport.
+
+ let fallback; // Go through each of the preferred positions looking for a good fit.
+ // If a good fit is found, it will be applied immediately.
+
+ for (let pos of this._preferredPositions) {
+ // Get the exact (x, y) coordinate for the point-of-origin on the origin element.
+ let originPoint = this._getOriginPoint(originRect, pos); // From that point-of-origin, get the exact (x, y) coordinate for the top-left corner of the
+ // overlay in this position. We use the top-left corner for calculations and later translate
+ // this into an appropriate (top, left, bottom, right) style.
+
+
+ let overlayPoint = this._getOverlayPoint(originPoint, overlayRect, pos); // Calculate how well the overlay would fit into the viewport with this point.
+
+
+ let overlayFit = this._getOverlayFit(overlayPoint, overlayRect, viewportRect, pos); // If the overlay, without any further work, fits into the viewport, use this position.
+
+
+ if (overlayFit.isCompletelyWithinViewport) {
+ this._isPushed = false;
+
+ this._applyPosition(pos, originPoint);
+
+ return;
+ } // If the overlay has flexible dimensions, we can use this position
+ // so long as there's enough space for the minimum dimensions.
+
+
+ if (this._canFitWithFlexibleDimensions(overlayFit, overlayPoint, viewportRect)) {
+ // Save positions where the overlay will fit with flexible dimensions. We will use these
+ // if none of the positions fit *without* flexible dimensions.
+ flexibleFits.push({
+ position: pos,
+ origin: originPoint,
+ overlayRect,
+ boundingBoxRect: this._calculateBoundingBoxRect(originPoint, pos)
+ });
+ continue;
+ } // If the current preferred position does not fit on the screen, remember the position
+ // if it has more visible area on-screen than we've seen and move onto the next preferred
+ // position.
+
+
+ if (!fallback || fallback.overlayFit.visibleArea < overlayFit.visibleArea) {
+ fallback = {
+ overlayFit,
+ overlayPoint,
+ originPoint,
+ position: pos,
+ overlayRect
+ };
+ }
+ } // If there are any positions where the overlay would fit with flexible dimensions, choose the
+ // one that has the greatest area available modified by the position's weight
+
+
+ if (flexibleFits.length) {
+ let bestFit = null;
+ let bestScore = -1;
+
+ for (const fit of flexibleFits) {
+ const score = fit.boundingBoxRect.width * fit.boundingBoxRect.height * (fit.position.weight || 1);
+
+ if (score > bestScore) {
+ bestScore = score;
+ bestFit = fit;
+ }
+ }
+
+ this._isPushed = false;
+
+ this._applyPosition(bestFit.position, bestFit.origin);
+
+ return;
+ } // When none of the preferred positions fit within the viewport, take the position
+ // that went off-screen the least and attempt to push it on-screen.
+
+
+ if (this._canPush) {
+ // TODO(jelbourn): after pushing, the opening "direction" of the overlay might not make sense.
+ this._isPushed = true;
+
+ this._applyPosition(fallback.position, fallback.originPoint);
+
+ return;
+ } // All options for getting the overlay within the viewport have been exhausted, so go with the
+ // position that went off-screen the least.
+
+
+ this._applyPosition(fallback.position, fallback.originPoint);
+ }
+
+ detach() {
+ this._clearPanelClasses();
+
+ this._lastPosition = null;
+ this._previousPushAmount = null;
+
+ this._resizeSubscription.unsubscribe();
+ }
+ /** Cleanup after the element gets destroyed. */
+
+
+ dispose() {
+ if (this._isDisposed) {
+ return;
+ } // We can't use `_resetBoundingBoxStyles` here, because it resets
+ // some properties to zero, rather than removing them.
+
+
+ if (this._boundingBox) {
+ extendStyles(this._boundingBox.style, {
+ top: '',
+ left: '',
+ right: '',
+ bottom: '',
+ height: '',
+ width: '',
+ alignItems: '',
+ justifyContent: ''
+ });
+ }
+
+ if (this._pane) {
+ this._resetOverlayElementStyles();
+ }
+
+ if (this._overlayRef) {
+ this._overlayRef.hostElement.classList.remove(boundingBoxClass);
+ }
+
+ this.detach();
+
+ this._positionChanges.complete();
+
+ this._overlayRef = this._boundingBox = null;
+ this._isDisposed = true;
+ }
+ /**
+ * This re-aligns the overlay element with the trigger in its last calculated position,
+ * even if a position higher in the "preferred positions" list would now fit. This
+ * allows one to re-align the panel without changing the orientation of the panel.
+ */
+
+
+ reapplyLastPosition() {
+ if (!this._isDisposed && (!this._platform || this._platform.isBrowser)) {
+ this._originRect = this._getOriginRect();
+ this._overlayRect = this._pane.getBoundingClientRect();
+ this._viewportRect = this._getNarrowedViewportRect();
+ const lastPosition = this._lastPosition || this._preferredPositions[0];
+
+ const originPoint = this._getOriginPoint(this._originRect, lastPosition);
+
+ this._applyPosition(lastPosition, originPoint);
+ }
+ }
+ /**
+ * Sets the list of Scrollable containers that host the origin element so that
+ * on reposition we can evaluate if it or the overlay has been clipped or outside view. Every
+ * Scrollable must be an ancestor element of the strategy's origin element.
+ */
+
+
+ withScrollableContainers(scrollables) {
+ this._scrollables = scrollables;
+ return this;
+ }
+ /**
+ * Adds new preferred positions.
+ * @param positions List of positions options for this overlay.
+ */
+
+
+ withPositions(positions) {
+ this._preferredPositions = positions; // If the last calculated position object isn't part of the positions anymore, clear
+ // it in order to avoid it being picked up if the consumer tries to re-apply.
+
+ if (positions.indexOf(this._lastPosition) === -1) {
+ this._lastPosition = null;
+ }
+
+ this._validatePositions();
+
+ return this;
+ }
+ /**
+ * Sets a minimum distance the overlay may be positioned to the edge of the viewport.
+ * @param margin Required margin between the overlay and the viewport edge in pixels.
+ */
+
+
+ withViewportMargin(margin) {
+ this._viewportMargin = margin;
+ return this;
+ }
+ /** Sets whether the overlay's width and height can be constrained to fit within the viewport. */
+
+
+ withFlexibleDimensions(flexibleDimensions = true) {
+ this._hasFlexibleDimensions = flexibleDimensions;
+ return this;
+ }
+ /** Sets whether the overlay can grow after the initial open via flexible width/height. */
+
+
+ withGrowAfterOpen(growAfterOpen = true) {
+ this._growAfterOpen = growAfterOpen;
+ return this;
+ }
+ /** Sets whether the overlay can be pushed on-screen if none of the provided positions fit. */
+
+
+ withPush(canPush = true) {
+ this._canPush = canPush;
+ return this;
+ }
+ /**
+ * Sets whether the overlay's position should be locked in after it is positioned
+ * initially. When an overlay is locked in, it won't attempt to reposition itself
+ * when the position is re-applied (e.g. when the user scrolls away).
+ * @param isLocked Whether the overlay should locked in.
+ */
+
+
+ withLockedPosition(isLocked = true) {
+ this._positionLocked = isLocked;
+ return this;
+ }
+ /**
+ * Sets the origin, relative to which to position the overlay.
+ * Using an element origin is useful for building components that need to be positioned
+ * relatively to a trigger (e.g. dropdown menus or tooltips), whereas using a point can be
+ * used for cases like contextual menus which open relative to the user's pointer.
+ * @param origin Reference to the new origin.
+ */
+
+
+ setOrigin(origin) {
+ this._origin = origin;
+ return this;
+ }
+ /**
+ * Sets the default offset for the overlay's connection point on the x-axis.
+ * @param offset New offset in the X axis.
+ */
+
+
+ withDefaultOffsetX(offset) {
+ this._offsetX = offset;
+ return this;
+ }
+ /**
+ * Sets the default offset for the overlay's connection point on the y-axis.
+ * @param offset New offset in the Y axis.
+ */
+
+
+ withDefaultOffsetY(offset) {
+ this._offsetY = offset;
+ return this;
+ }
+ /**
+ * Configures that the position strategy should set a `transform-origin` on some elements
+ * inside the overlay, depending on the current position that is being applied. This is
+ * useful for the cases where the origin of an animation can change depending on the
+ * alignment of the overlay.
+ * @param selector CSS selector that will be used to find the target
+ * elements onto which to set the transform origin.
+ */
+
+
+ withTransformOriginOn(selector) {
+ this._transformOriginSelector = selector;
+ return this;
+ }
+ /**
+ * Gets the (x, y) coordinate of a connection point on the origin based on a relative position.
+ */
+
+
+ _getOriginPoint(originRect, pos) {
+ let x;
+
+ if (pos.originX == 'center') {
+ // Note: when centering we should always use the `left`
+ // offset, otherwise the position will be wrong in RTL.
+ x = originRect.left + originRect.width / 2;
+ } else {
+ const startX = this._isRtl() ? originRect.right : originRect.left;
+ const endX = this._isRtl() ? originRect.left : originRect.right;
+ x = pos.originX == 'start' ? startX : endX;
+ }
+
+ let y;
+
+ if (pos.originY == 'center') {
+ y = originRect.top + originRect.height / 2;
+ } else {
+ y = pos.originY == 'top' ? originRect.top : originRect.bottom;
+ }
+
+ return {
+ x,
+ y
+ };
+ }
+ /**
+ * Gets the (x, y) coordinate of the top-left corner of the overlay given a given position and
+ * origin point to which the overlay should be connected.
+ */
+
+
+ _getOverlayPoint(originPoint, overlayRect, pos) {
+ // Calculate the (overlayStartX, overlayStartY), the start of the
+ // potential overlay position relative to the origin point.
+ let overlayStartX;
+
+ if (pos.overlayX == 'center') {
+ overlayStartX = -overlayRect.width / 2;
+ } else if (pos.overlayX === 'start') {
+ overlayStartX = this._isRtl() ? -overlayRect.width : 0;
+ } else {
+ overlayStartX = this._isRtl() ? 0 : -overlayRect.width;
+ }
+
+ let overlayStartY;
+
+ if (pos.overlayY == 'center') {
+ overlayStartY = -overlayRect.height / 2;
+ } else {
+ overlayStartY = pos.overlayY == 'top' ? 0 : -overlayRect.height;
+ } // The (x, y) coordinates of the overlay.
+
+
+ return {
+ x: originPoint.x + overlayStartX,
+ y: originPoint.y + overlayStartY
+ };
+ }
+ /** Gets how well an overlay at the given point will fit within the viewport. */
+
+
+ _getOverlayFit(point, rawOverlayRect, viewport, position) {
+ // Round the overlay rect when comparing against the
+ // viewport, because the viewport is always rounded.
+ const overlay = getRoundedBoundingClientRect(rawOverlayRect);
+ let {
+ x,
+ y
+ } = point;
+
+ let offsetX = this._getOffset(position, 'x');
+
+ let offsetY = this._getOffset(position, 'y'); // Account for the offsets since they could push the overlay out of the viewport.
+
+
+ if (offsetX) {
+ x += offsetX;
+ }
+
+ if (offsetY) {
+ y += offsetY;
+ } // How much the overlay would overflow at this position, on each side.
+
+
+ let leftOverflow = 0 - x;
+ let rightOverflow = x + overlay.width - viewport.width;
+ let topOverflow = 0 - y;
+ let bottomOverflow = y + overlay.height - viewport.height; // Visible parts of the element on each axis.
+
+ let visibleWidth = this._subtractOverflows(overlay.width, leftOverflow, rightOverflow);
+
+ let visibleHeight = this._subtractOverflows(overlay.height, topOverflow, bottomOverflow);
+
+ let visibleArea = visibleWidth * visibleHeight;
+ return {
+ visibleArea,
+ isCompletelyWithinViewport: overlay.width * overlay.height === visibleArea,
+ fitsInViewportVertically: visibleHeight === overlay.height,
+ fitsInViewportHorizontally: visibleWidth == overlay.width
+ };
+ }
+ /**
+ * Whether the overlay can fit within the viewport when it may resize either its width or height.
+ * @param fit How well the overlay fits in the viewport at some position.
+ * @param point The (x, y) coordinates of the overlat at some position.
+ * @param viewport The geometry of the viewport.
+ */
+
+
+ _canFitWithFlexibleDimensions(fit, point, viewport) {
+ if (this._hasFlexibleDimensions) {
+ const availableHeight = viewport.bottom - point.y;
+ const availableWidth = viewport.right - point.x;
+ const minHeight = getPixelValue(this._overlayRef.getConfig().minHeight);
+ const minWidth = getPixelValue(this._overlayRef.getConfig().minWidth);
+ const verticalFit = fit.fitsInViewportVertically || minHeight != null && minHeight <= availableHeight;
+ const horizontalFit = fit.fitsInViewportHorizontally || minWidth != null && minWidth <= availableWidth;
+ return verticalFit && horizontalFit;
+ }
+
+ return false;
+ }
+ /**
+ * Gets the point at which the overlay can be "pushed" on-screen. If the overlay is larger than
+ * the viewport, the top-left corner will be pushed on-screen (with overflow occuring on the
+ * right and bottom).
+ *
+ * @param start Starting point from which the overlay is pushed.
+ * @param overlay Dimensions of the overlay.
+ * @param scrollPosition Current viewport scroll position.
+ * @returns The point at which to position the overlay after pushing. This is effectively a new
+ * originPoint.
+ */
+
+
+ _pushOverlayOnScreen(start, rawOverlayRect, scrollPosition) {
+ // If the position is locked and we've pushed the overlay already, reuse the previous push
+ // amount, rather than pushing it again. If we were to continue pushing, the element would
+ // remain in the viewport, which goes against the expectations when position locking is enabled.
+ if (this._previousPushAmount && this._positionLocked) {
+ return {
+ x: start.x + this._previousPushAmount.x,
+ y: start.y + this._previousPushAmount.y
+ };
+ } // Round the overlay rect when comparing against the
+ // viewport, because the viewport is always rounded.
+
+
+ const overlay = getRoundedBoundingClientRect(rawOverlayRect);
+ const viewport = this._viewportRect; // Determine how much the overlay goes outside the viewport on each
+ // side, which we'll use to decide which direction to push it.
+
+ const overflowRight = Math.max(start.x + overlay.width - viewport.width, 0);
+ const overflowBottom = Math.max(start.y + overlay.height - viewport.height, 0);
+ const overflowTop = Math.max(viewport.top - scrollPosition.top - start.y, 0);
+ const overflowLeft = Math.max(viewport.left - scrollPosition.left - start.x, 0); // Amount by which to push the overlay in each axis such that it remains on-screen.
+
+ let pushX = 0;
+ let pushY = 0; // If the overlay fits completely within the bounds of the viewport, push it from whichever
+ // direction is goes off-screen. Otherwise, push the top-left corner such that its in the
+ // viewport and allow for the trailing end of the overlay to go out of bounds.
+
+ if (overlay.width <= viewport.width) {
+ pushX = overflowLeft || -overflowRight;
+ } else {
+ pushX = start.x < this._viewportMargin ? viewport.left - scrollPosition.left - start.x : 0;
+ }
+
+ if (overlay.height <= viewport.height) {
+ pushY = overflowTop || -overflowBottom;
+ } else {
+ pushY = start.y < this._viewportMargin ? viewport.top - scrollPosition.top - start.y : 0;
+ }
+
+ this._previousPushAmount = {
+ x: pushX,
+ y: pushY
+ };
+ return {
+ x: start.x + pushX,
+ y: start.y + pushY
+ };
+ }
+ /**
+ * Applies a computed position to the overlay and emits a position change.
+ * @param position The position preference
+ * @param originPoint The point on the origin element where the overlay is connected.
+ */
+
+
+ _applyPosition(position, originPoint) {
+ this._setTransformOrigin(position);
+
+ this._setOverlayElementStyles(originPoint, position);
+
+ this._setBoundingBoxStyles(originPoint, position);
+
+ if (position.panelClass) {
+ this._addPanelClasses(position.panelClass);
+ } // Save the last connected position in case the position needs to be re-calculated.
+
+
+ this._lastPosition = position; // Notify that the position has been changed along with its change properties.
+ // We only emit if we've got any subscriptions, because the scroll visibility
+ // calculcations can be somewhat expensive.
+
+ if (this._positionChanges.observers.length) {
+ const scrollableViewProperties = this._getScrollVisibility();
+
+ const changeEvent = new ConnectedOverlayPositionChange(position, scrollableViewProperties);
+
+ this._positionChanges.next(changeEvent);
+ }
+
+ this._isInitialRender = false;
+ }
+ /** Sets the transform origin based on the configured selector and the passed-in position. */
+
+
+ _setTransformOrigin(position) {
+ if (!this._transformOriginSelector) {
+ return;
+ }
+
+ const elements = this._boundingBox.querySelectorAll(this._transformOriginSelector);
+
+ let xOrigin;
+ let yOrigin = position.overlayY;
+
+ if (position.overlayX === 'center') {
+ xOrigin = 'center';
+ } else if (this._isRtl()) {
+ xOrigin = position.overlayX === 'start' ? 'right' : 'left';
+ } else {
+ xOrigin = position.overlayX === 'start' ? 'left' : 'right';
+ }
+
+ for (let i = 0; i < elements.length; i++) {
+ elements[i].style.transformOrigin = `${xOrigin} ${yOrigin}`;
+ }
+ }
+ /**
+ * Gets the position and size of the overlay's sizing container.
+ *
+ * This method does no measuring and applies no styles so that we can cheaply compute the
+ * bounds for all positions and choose the best fit based on these results.
+ */
+
+
+ _calculateBoundingBoxRect(origin, position) {
+ const viewport = this._viewportRect;
+
+ const isRtl = this._isRtl();
+
+ let height, top, bottom;
+
+ if (position.overlayY === 'top') {
+ // Overlay is opening "downward" and thus is bound by the bottom viewport edge.
+ top = origin.y;
+ height = viewport.height - top + this._viewportMargin;
+ } else if (position.overlayY === 'bottom') {
+ // Overlay is opening "upward" and thus is bound by the top viewport edge. We need to add
+ // the viewport margin back in, because the viewport rect is narrowed down to remove the
+ // margin, whereas the `origin` position is calculated based on its `ClientRect`.
+ bottom = viewport.height - origin.y + this._viewportMargin * 2;
+ height = viewport.height - bottom + this._viewportMargin;
+ } else {
+ // If neither top nor bottom, it means that the overlay is vertically centered on the
+ // origin point. Note that we want the position relative to the viewport, rather than
+ // the page, which is why we don't use something like `viewport.bottom - origin.y` and
+ // `origin.y - viewport.top`.
+ const smallestDistanceToViewportEdge = Math.min(viewport.bottom - origin.y + viewport.top, origin.y);
+ const previousHeight = this._lastBoundingBoxSize.height;
+ height = smallestDistanceToViewportEdge * 2;
+ top = origin.y - smallestDistanceToViewportEdge;
+
+ if (height > previousHeight && !this._isInitialRender && !this._growAfterOpen) {
+ top = origin.y - previousHeight / 2;
+ }
+ } // The overlay is opening 'right-ward' (the content flows to the right).
+
+
+ const isBoundedByRightViewportEdge = position.overlayX === 'start' && !isRtl || position.overlayX === 'end' && isRtl; // The overlay is opening 'left-ward' (the content flows to the left).
+
+ const isBoundedByLeftViewportEdge = position.overlayX === 'end' && !isRtl || position.overlayX === 'start' && isRtl;
+ let width, left, right;
+
+ if (isBoundedByLeftViewportEdge) {
+ right = viewport.width - origin.x + this._viewportMargin;
+ width = origin.x - this._viewportMargin;
+ } else if (isBoundedByRightViewportEdge) {
+ left = origin.x;
+ width = viewport.right - origin.x;
+ } else {
+ // If neither start nor end, it means that the overlay is horizontally centered on the
+ // origin point. Note that we want the position relative to the viewport, rather than
+ // the page, which is why we don't use something like `viewport.right - origin.x` and
+ // `origin.x - viewport.left`.
+ const smallestDistanceToViewportEdge = Math.min(viewport.right - origin.x + viewport.left, origin.x);
+ const previousWidth = this._lastBoundingBoxSize.width;
+ width = smallestDistanceToViewportEdge * 2;
+ left = origin.x - smallestDistanceToViewportEdge;
+
+ if (width > previousWidth && !this._isInitialRender && !this._growAfterOpen) {
+ left = origin.x - previousWidth / 2;
+ }
+ }
+
+ return {
+ top: top,
+ left: left,
+ bottom: bottom,
+ right: right,
+ width,
+ height
+ };
+ }
+ /**
+ * Sets the position and size of the overlay's sizing wrapper. The wrapper is positioned on the
+ * origin's connection point and stetches to the bounds of the viewport.
+ *
+ * @param origin The point on the origin element where the overlay is connected.
+ * @param position The position preference
+ */
+
+
+ _setBoundingBoxStyles(origin, position) {
+ const boundingBoxRect = this._calculateBoundingBoxRect(origin, position); // It's weird if the overlay *grows* while scrolling, so we take the last size into account
+ // when applying a new size.
+
+
+ if (!this._isInitialRender && !this._growAfterOpen) {
+ boundingBoxRect.height = Math.min(boundingBoxRect.height, this._lastBoundingBoxSize.height);
+ boundingBoxRect.width = Math.min(boundingBoxRect.width, this._lastBoundingBoxSize.width);
+ }
+
+ const styles = {};
+
+ if (this._hasExactPosition()) {
+ styles.top = styles.left = '0';
+ styles.bottom = styles.right = styles.maxHeight = styles.maxWidth = '';
+ styles.width = styles.height = '100%';
+ } else {
+ const maxHeight = this._overlayRef.getConfig().maxHeight;
+
+ const maxWidth = this._overlayRef.getConfig().maxWidth;
+
+ styles.height = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(boundingBoxRect.height);
+ styles.top = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(boundingBoxRect.top);
+ styles.bottom = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(boundingBoxRect.bottom);
+ styles.width = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(boundingBoxRect.width);
+ styles.left = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(boundingBoxRect.left);
+ styles.right = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(boundingBoxRect.right); // Push the pane content towards the proper direction.
+
+ if (position.overlayX === 'center') {
+ styles.alignItems = 'center';
+ } else {
+ styles.alignItems = position.overlayX === 'end' ? 'flex-end' : 'flex-start';
+ }
+
+ if (position.overlayY === 'center') {
+ styles.justifyContent = 'center';
+ } else {
+ styles.justifyContent = position.overlayY === 'bottom' ? 'flex-end' : 'flex-start';
+ }
+
+ if (maxHeight) {
+ styles.maxHeight = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(maxHeight);
+ }
+
+ if (maxWidth) {
+ styles.maxWidth = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(maxWidth);
+ }
+ }
+
+ this._lastBoundingBoxSize = boundingBoxRect;
+ extendStyles(this._boundingBox.style, styles);
+ }
+ /** Resets the styles for the bounding box so that a new positioning can be computed. */
+
+
+ _resetBoundingBoxStyles() {
+ extendStyles(this._boundingBox.style, {
+ top: '0',
+ left: '0',
+ right: '0',
+ bottom: '0',
+ height: '',
+ width: '',
+ alignItems: '',
+ justifyContent: ''
+ });
+ }
+ /** Resets the styles for the overlay pane so that a new positioning can be computed. */
+
+
+ _resetOverlayElementStyles() {
+ extendStyles(this._pane.style, {
+ top: '',
+ left: '',
+ bottom: '',
+ right: '',
+ position: '',
+ transform: ''
+ });
+ }
+ /** Sets positioning styles to the overlay element. */
+
+
+ _setOverlayElementStyles(originPoint, position) {
+ const styles = {};
+
+ const hasExactPosition = this._hasExactPosition();
+
+ const hasFlexibleDimensions = this._hasFlexibleDimensions;
+
+ const config = this._overlayRef.getConfig();
+
+ if (hasExactPosition) {
+ const scrollPosition = this._viewportRuler.getViewportScrollPosition();
+
+ extendStyles(styles, this._getExactOverlayY(position, originPoint, scrollPosition));
+ extendStyles(styles, this._getExactOverlayX(position, originPoint, scrollPosition));
+ } else {
+ styles.position = 'static';
+ } // Use a transform to apply the offsets. We do this because the `center` positions rely on
+ // being in the normal flex flow and setting a `top` / `left` at all will completely throw
+ // off the position. We also can't use margins, because they won't have an effect in some
+ // cases where the element doesn't have anything to "push off of". Finally, this works
+ // better both with flexible and non-flexible positioning.
+
+
+ let transformString = '';
+
+ let offsetX = this._getOffset(position, 'x');
+
+ let offsetY = this._getOffset(position, 'y');
+
+ if (offsetX) {
+ transformString += `translateX(${offsetX}px) `;
+ }
+
+ if (offsetY) {
+ transformString += `translateY(${offsetY}px)`;
+ }
+
+ styles.transform = transformString.trim(); // If a maxWidth or maxHeight is specified on the overlay, we remove them. We do this because
+ // we need these values to both be set to "100%" for the automatic flexible sizing to work.
+ // The maxHeight and maxWidth are set on the boundingBox in order to enforce the constraint.
+ // Note that this doesn't apply when we have an exact position, in which case we do want to
+ // apply them because they'll be cleared from the bounding box.
+
+ if (config.maxHeight) {
+ if (hasExactPosition) {
+ styles.maxHeight = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(config.maxHeight);
+ } else if (hasFlexibleDimensions) {
+ styles.maxHeight = '';
+ }
+ }
+
+ if (config.maxWidth) {
+ if (hasExactPosition) {
+ styles.maxWidth = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(config.maxWidth);
+ } else if (hasFlexibleDimensions) {
+ styles.maxWidth = '';
+ }
+ }
+
+ extendStyles(this._pane.style, styles);
+ }
+ /** Gets the exact top/bottom for the overlay when not using flexible sizing or when pushing. */
+
+
+ _getExactOverlayY(position, originPoint, scrollPosition) {
+ // Reset any existing styles. This is necessary in case the
+ // preferred position has changed since the last `apply`.
+ let styles = {
+ top: '',
+ bottom: ''
+ };
+
+ let overlayPoint = this._getOverlayPoint(originPoint, this._overlayRect, position);
+
+ if (this._isPushed) {
+ overlayPoint = this._pushOverlayOnScreen(overlayPoint, this._overlayRect, scrollPosition);
+ }
+
+ let virtualKeyboardOffset = this._overlayContainer.getContainerElement().getBoundingClientRect().top; // Normally this would be zero, however when the overlay is attached to an input (e.g. in an
+ // autocomplete), mobile browsers will shift everything in order to put the input in the middle
+ // of the screen and to make space for the virtual keyboard. We need to account for this offset,
+ // otherwise our positioning will be thrown off.
+
+
+ overlayPoint.y -= virtualKeyboardOffset; // We want to set either `top` or `bottom` based on whether the overlay wants to appear
+ // above or below the origin and the direction in which the element will expand.
+
+ if (position.overlayY === 'bottom') {
+ // When using `bottom`, we adjust the y position such that it is the distance
+ // from the bottom of the viewport rather than the top.
+ const documentHeight = this._document.documentElement.clientHeight;
+ styles.bottom = `${documentHeight - (overlayPoint.y + this._overlayRect.height)}px`;
+ } else {
+ styles.top = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(overlayPoint.y);
+ }
+
+ return styles;
+ }
+ /** Gets the exact left/right for the overlay when not using flexible sizing or when pushing. */
+
+
+ _getExactOverlayX(position, originPoint, scrollPosition) {
+ // Reset any existing styles. This is necessary in case the preferred position has
+ // changed since the last `apply`.
+ let styles = {
+ left: '',
+ right: ''
+ };
+
+ let overlayPoint = this._getOverlayPoint(originPoint, this._overlayRect, position);
+
+ if (this._isPushed) {
+ overlayPoint = this._pushOverlayOnScreen(overlayPoint, this._overlayRect, scrollPosition);
+ } // We want to set either `left` or `right` based on whether the overlay wants to appear "before"
+ // or "after" the origin, which determines the direction in which the element will expand.
+ // For the horizontal axis, the meaning of "before" and "after" change based on whether the
+ // page is in RTL or LTR.
+
+
+ let horizontalStyleProperty;
+
+ if (this._isRtl()) {
+ horizontalStyleProperty = position.overlayX === 'end' ? 'left' : 'right';
+ } else {
+ horizontalStyleProperty = position.overlayX === 'end' ? 'right' : 'left';
+ } // When we're setting `right`, we adjust the x position such that it is the distance
+ // from the right edge of the viewport rather than the left edge.
+
+
+ if (horizontalStyleProperty === 'right') {
+ const documentWidth = this._document.documentElement.clientWidth;
+ styles.right = `${documentWidth - (overlayPoint.x + this._overlayRect.width)}px`;
+ } else {
+ styles.left = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceCssPixelValue)(overlayPoint.x);
+ }
+
+ return styles;
+ }
+ /**
+ * Gets the view properties of the trigger and overlay, including whether they are clipped
+ * or completely outside the view of any of the strategy's scrollables.
+ */
+
+
+ _getScrollVisibility() {
+ // Note: needs fresh rects since the position could've changed.
+ const originBounds = this._getOriginRect();
+
+ const overlayBounds = this._pane.getBoundingClientRect(); // TODO(jelbourn): instead of needing all of the client rects for these scrolling containers
+ // every time, we should be able to use the scrollTop of the containers if the size of those
+ // containers hasn't changed.
+
+
+ const scrollContainerBounds = this._scrollables.map(scrollable => {
+ return scrollable.getElementRef().nativeElement.getBoundingClientRect();
+ });
+
+ return {
+ isOriginClipped: isElementClippedByScrolling(originBounds, scrollContainerBounds),
+ isOriginOutsideView: isElementScrolledOutsideView(originBounds, scrollContainerBounds),
+ isOverlayClipped: isElementClippedByScrolling(overlayBounds, scrollContainerBounds),
+ isOverlayOutsideView: isElementScrolledOutsideView(overlayBounds, scrollContainerBounds)
+ };
+ }
+ /** Subtracts the amount that an element is overflowing on an axis from its length. */
+
+
+ _subtractOverflows(length, ...overflows) {
+ return overflows.reduce((currentValue, currentOverflow) => {
+ return currentValue - Math.max(currentOverflow, 0);
+ }, length);
+ }
+ /** Narrows the given viewport rect by the current _viewportMargin. */
+
+
+ _getNarrowedViewportRect() {
+ // We recalculate the viewport rect here ourselves, rather than using the ViewportRuler,
+ // because we want to use the `clientWidth` and `clientHeight` as the base. The difference
+ // being that the client properties don't include the scrollbar, as opposed to `innerWidth`
+ // and `innerHeight` that do. This is necessary, because the overlay container uses
+ // 100% `width` and `height` which don't include the scrollbar either.
+ const width = this._document.documentElement.clientWidth;
+ const height = this._document.documentElement.clientHeight;
+
+ const scrollPosition = this._viewportRuler.getViewportScrollPosition();
+
+ return {
+ top: scrollPosition.top + this._viewportMargin,
+ left: scrollPosition.left + this._viewportMargin,
+ right: scrollPosition.left + width - this._viewportMargin,
+ bottom: scrollPosition.top + height - this._viewportMargin,
+ width: width - 2 * this._viewportMargin,
+ height: height - 2 * this._viewportMargin
+ };
+ }
+ /** Whether the we're dealing with an RTL context */
+
+
+ _isRtl() {
+ return this._overlayRef.getDirection() === 'rtl';
+ }
+ /** Determines whether the overlay uses exact or flexible positioning. */
+
+
+ _hasExactPosition() {
+ return !this._hasFlexibleDimensions || this._isPushed;
+ }
+ /** Retrieves the offset of a position along the x or y axis. */
+
+
+ _getOffset(position, axis) {
+ if (axis === 'x') {
+ // We don't do something like `position['offset' + axis]` in
+ // order to avoid breking minifiers that rename properties.
+ return position.offsetX == null ? this._offsetX : position.offsetX;
+ }
+
+ return position.offsetY == null ? this._offsetY : position.offsetY;
+ }
+ /** Validates that the current position match the expected values. */
+
+
+ _validatePositions() {
+ if (typeof ngDevMode === 'undefined' || ngDevMode) {
+ if (!this._preferredPositions.length) {
+ throw Error('FlexibleConnectedPositionStrategy: At least one position is required.');
+ } // TODO(crisbeto): remove these once Angular's template type
+ // checking is advanced enough to catch these cases.
+
+
+ this._preferredPositions.forEach(pair => {
+ validateHorizontalPosition('originX', pair.originX);
+ validateVerticalPosition('originY', pair.originY);
+ validateHorizontalPosition('overlayX', pair.overlayX);
+ validateVerticalPosition('overlayY', pair.overlayY);
+ });
+ }
+ }
+ /** Adds a single CSS class or an array of classes on the overlay panel. */
+
+
+ _addPanelClasses(cssClasses) {
+ if (this._pane) {
+ (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceArray)(cssClasses).forEach(cssClass => {
+ if (cssClass !== '' && this._appliedPanelClasses.indexOf(cssClass) === -1) {
+ this._appliedPanelClasses.push(cssClass);
+
+ this._pane.classList.add(cssClass);
+ }
+ });
+ }
+ }
+ /** Clears the classes that the position strategy has applied from the overlay panel. */
+
+
+ _clearPanelClasses() {
+ if (this._pane) {
+ this._appliedPanelClasses.forEach(cssClass => {
+ this._pane.classList.remove(cssClass);
+ });
+
+ this._appliedPanelClasses = [];
+ }
+ }
+ /** Returns the ClientRect of the current origin. */
+
+
+ _getOriginRect() {
+ const origin = this._origin;
+
+ if (origin instanceof _angular_core__WEBPACK_IMPORTED_MODULE_3__.ElementRef) {
+ return origin.nativeElement.getBoundingClientRect();
+ } // Check for Element so SVG elements are also supported.
+
+
+ if (origin instanceof Element) {
+ return origin.getBoundingClientRect();
+ }
+
+ const width = origin.width || 0;
+ const height = origin.height || 0; // If the origin is a point, return a client rect as if it was a 0x0 element at the point.
+
+ return {
+ top: origin.y,
+ bottom: origin.y + height,
+ left: origin.x,
+ right: origin.x + width,
+ height,
+ width
+ };
+ }
+
+}
+/** Shallow-extends a stylesheet object with another stylesheet object. */
+
+
+function extendStyles(destination, source) {
+ for (let key in source) {
+ if (source.hasOwnProperty(key)) {
+ destination[key] = source[key];
+ }
+ }
+
+ return destination;
+}
+/**
+ * Extracts the pixel value as a number from a value, if it's a number
+ * or a CSS pixel string (e.g. `1337px`). Otherwise returns null.
+ */
+
+
+function getPixelValue(input) {
+ if (typeof input !== 'number' && input != null) {
+ const [value, units] = input.split(cssUnitPattern);
+ return !units || units === 'px' ? parseFloat(value) : null;
+ }
+
+ return input || null;
+}
+/**
+ * Gets a version of an element's bounding `ClientRect` where all the values are rounded down to
+ * the nearest pixel. This allows us to account for the cases where there may be sub-pixel
+ * deviations in the `ClientRect` returned by the browser (e.g. when zoomed in with a percentage
+ * size, see #21350).
+ */
+
+
+function getRoundedBoundingClientRect(clientRect) {
+ return {
+ top: Math.floor(clientRect.top),
+ right: Math.floor(clientRect.right),
+ bottom: Math.floor(clientRect.bottom),
+ left: Math.floor(clientRect.left),
+ width: Math.floor(clientRect.width),
+ height: Math.floor(clientRect.height)
+ };
+}
+/**
+ * @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.io/license
+ */
+
+/** Class to be added to the overlay pane wrapper. */
+
+
+const wrapperClass = 'cdk-global-overlay-wrapper';
+/**
+ * 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.
+ */
+
+class GlobalPositionStrategy {
+ constructor() {
+ this._cssPosition = 'static';
+ this._topOffset = '';
+ this._bottomOffset = '';
+ this._leftOffset = '';
+ this._rightOffset = '';
+ this._alignItems = '';
+ this._justifyContent = '';
+ this._width = '';
+ this._height = '';
+ }
+
+ attach(overlayRef) {
+ const config = overlayRef.getConfig();
+ this._overlayRef = overlayRef;
+
+ if (this._width && !config.width) {
+ overlayRef.updateSize({
+ width: this._width
+ });
+ }
+
+ if (this._height && !config.height) {
+ overlayRef.updateSize({
+ height: this._height
+ });
+ }
+
+ overlayRef.hostElement.classList.add(wrapperClass);
+ this._isDisposed = false;
+ }
+ /**
+ * Sets the top position of the overlay. Clears any previously set vertical position.
+ * @param value New top offset.
+ */
+
+
+ top(value = '') {
+ this._bottomOffset = '';
+ this._topOffset = value;
+ this._alignItems = 'flex-start';
+ return this;
+ }
+ /**
+ * Sets the left position of the overlay. Clears any previously set horizontal position.
+ * @param value New left offset.
+ */
+
+
+ left(value = '') {
+ this._rightOffset = '';
+ this._leftOffset = value;
+ this._justifyContent = 'flex-start';
+ return this;
+ }
+ /**
+ * Sets the bottom position of the overlay. Clears any previously set vertical position.
+ * @param value New bottom offset.
+ */
+
+
+ bottom(value = '') {
+ this._topOffset = '';
+ this._bottomOffset = value;
+ this._alignItems = 'flex-end';
+ return this;
+ }
+ /**
+ * Sets the right position of the overlay. Clears any previously set horizontal position.
+ * @param value New right offset.
+ */
+
+
+ right(value = '') {
+ this._leftOffset = '';
+ this._rightOffset = value;
+ this._justifyContent = 'flex-end';
+ return 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 = '') {
+ if (this._overlayRef) {
+ this._overlayRef.updateSize({
+ width: value
+ });
+ } else {
+ this._width = value;
+ }
+
+ return 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 = '') {
+ if (this._overlayRef) {
+ this._overlayRef.updateSize({
+ height: value
+ });
+ } else {
+ this._height = value;
+ }
+
+ return 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 = '') {
+ this.left(offset);
+ this._justifyContent = 'center';
+ return 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 = '') {
+ this.top(offset);
+ this._alignItems = 'center';
+ return this;
+ }
+ /**
+ * Apply the position to the element.
+ * @docs-private
+ */
+
+
+ apply() {
+ // Since the overlay ref applies the strategy asynchronously, it could
+ // have been disposed before it ends up being applied. If that is the
+ // case, we shouldn't do anything.
+ if (!this._overlayRef || !this._overlayRef.hasAttached()) {
+ return;
+ }
+
+ const styles = this._overlayRef.overlayElement.style;
+ const parentStyles = this._overlayRef.hostElement.style;
+
+ const config = this._overlayRef.getConfig();
+
+ const {
+ width,
+ height,
+ maxWidth,
+ maxHeight
+ } = config;
+ const shouldBeFlushHorizontally = (width === '100%' || width === '100vw') && (!maxWidth || maxWidth === '100%' || maxWidth === '100vw');
+ const shouldBeFlushVertically = (height === '100%' || height === '100vh') && (!maxHeight || maxHeight === '100%' || maxHeight === '100vh');
+ styles.position = this._cssPosition;
+ styles.marginLeft = shouldBeFlushHorizontally ? '0' : this._leftOffset;
+ styles.marginTop = shouldBeFlushVertically ? '0' : this._topOffset;
+ styles.marginBottom = this._bottomOffset;
+ styles.marginRight = this._rightOffset;
+
+ if (shouldBeFlushHorizontally) {
+ parentStyles.justifyContent = 'flex-start';
+ } else if (this._justifyContent === 'center') {
+ parentStyles.justifyContent = 'center';
+ } else if (this._overlayRef.getConfig().direction === 'rtl') {
+ // In RTL the browser will invert `flex-start` and `flex-end` automatically, but we
+ // don't want that because our positioning is explicitly `left` and `right`, hence
+ // why we do another inversion to ensure that the overlay stays in the same position.
+ // TODO: reconsider this if we add `start` and `end` methods.
+ if (this._justifyContent === 'flex-start') {
+ parentStyles.justifyContent = 'flex-end';
+ } else if (this._justifyContent === 'flex-end') {
+ parentStyles.justifyContent = 'flex-start';
+ }
+ } else {
+ parentStyles.justifyContent = this._justifyContent;
+ }
+
+ parentStyles.alignItems = shouldBeFlushVertically ? 'flex-start' : this._alignItems;
+ }
+ /**
+ * Cleans up the DOM changes from the position strategy.
+ * @docs-private
+ */
+
+
+ dispose() {
+ if (this._isDisposed || !this._overlayRef) {
+ return;
+ }
+
+ const styles = this._overlayRef.overlayElement.style;
+ const parent = this._overlayRef.hostElement;
+ const parentStyles = parent.style;
+ parent.classList.remove(wrapperClass);
+ parentStyles.justifyContent = parentStyles.alignItems = styles.marginTop = styles.marginBottom = styles.marginLeft = styles.marginRight = styles.position = '';
+ this._overlayRef = null;
+ this._isDisposed = true;
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+/** Builder for overlay position strategy. */
+
+
+class OverlayPositionBuilder {
+ constructor(_viewportRuler, _document, _platform, _overlayContainer) {
+ this._viewportRuler = _viewportRuler;
+ this._document = _document;
+ this._platform = _platform;
+ this._overlayContainer = _overlayContainer;
+ }
+ /**
+ * Creates a global position strategy.
+ */
+
+
+ global() {
+ return new GlobalPositionStrategy();
+ }
+ /**
+ * Creates a flexible position strategy.
+ * @param origin Origin relative to which to position the overlay.
+ */
+
+
+ flexibleConnectedTo(origin) {
+ return new FlexibleConnectedPositionStrategy(origin, this._viewportRuler, this._document, this._platform, this._overlayContainer);
+ }
+
+}
+
+OverlayPositionBuilder.ɵfac = function OverlayPositionBuilder_Factory(t) {
+ return new (t || OverlayPositionBuilder)(_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_cdk_scrolling__WEBPACK_IMPORTED_MODULE_0__.ViewportRuler), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_common__WEBPACK_IMPORTED_MODULE_4__.DOCUMENT), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_1__.Platform), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](OverlayContainer));
+};
+
+OverlayPositionBuilder.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdefineInjectable"]({
+ token: OverlayPositionBuilder,
+ factory: OverlayPositionBuilder.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵsetClassMetadata"](OverlayPositionBuilder, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: _angular_cdk_scrolling__WEBPACK_IMPORTED_MODULE_0__.ViewportRuler
+ }, {
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_4__.DOCUMENT]
+ }]
+ }, {
+ type: _angular_cdk_platform__WEBPACK_IMPORTED_MODULE_1__.Platform
+ }, {
+ type: OverlayContainer
+ }];
+ }, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/** Next overlay unique ID. */
+
+
+let nextUniqueId = 0; // Note that Overlay is *not* scoped to the app root because of the ComponentFactoryResolver
+// which needs to be different depending on where OverlayModule is imported.
+
+/**
+ * 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.
+ */
+
+class Overlay {
+ constructor(
+ /** Scrolling strategies that can be used when creating an overlay. */
+ scrollStrategies, _overlayContainer, _componentFactoryResolver, _positionBuilder, _keyboardDispatcher, _injector, _ngZone, _document, _directionality, _location, _outsideClickDispatcher) {
+ this.scrollStrategies = scrollStrategies;
+ this._overlayContainer = _overlayContainer;
+ this._componentFactoryResolver = _componentFactoryResolver;
+ this._positionBuilder = _positionBuilder;
+ this._keyboardDispatcher = _keyboardDispatcher;
+ this._injector = _injector;
+ this._ngZone = _ngZone;
+ this._document = _document;
+ this._directionality = _directionality;
+ this._location = _location;
+ this._outsideClickDispatcher = _outsideClickDispatcher;
+ }
+ /**
+ * Creates an overlay.
+ * @param config Configuration applied to the overlay.
+ * @returns Reference to the created overlay.
+ */
+
+
+ create(config) {
+ const host = this._createHostElement();
+
+ const pane = this._createPaneElement(host);
+
+ const portalOutlet = this._createPortalOutlet(pane);
+
+ const overlayConfig = new OverlayConfig(config);
+ overlayConfig.direction = overlayConfig.direction || this._directionality.value;
+ return new OverlayRef(portalOutlet, host, pane, overlayConfig, this._ngZone, this._keyboardDispatcher, this._document, this._location, this._outsideClickDispatcher);
+ }
+ /**
+ * Gets a position builder that can be used, via fluent API,
+ * to construct and configure a position strategy.
+ * @returns An overlay position builder.
+ */
+
+
+ position() {
+ return this._positionBuilder;
+ }
+ /**
+ * Creates the DOM element for an overlay and appends it to the overlay container.
+ * @returns Newly-created pane element
+ */
+
+
+ _createPaneElement(host) {
+ const pane = this._document.createElement('div');
+
+ pane.id = `cdk-overlay-${nextUniqueId++}`;
+ pane.classList.add('cdk-overlay-pane');
+ host.appendChild(pane);
+ return pane;
+ }
+ /**
+ * Creates the host element that wraps around an overlay
+ * and can be used for advanced positioning.
+ * @returns Newly-create host element.
+ */
+
+
+ _createHostElement() {
+ const host = this._document.createElement('div');
+
+ this._overlayContainer.getContainerElement().appendChild(host);
+
+ return host;
+ }
+ /**
+ * 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.
+ */
+
+
+ _createPortalOutlet(pane) {
+ // We have to resolve the ApplicationRef later in order to allow people
+ // to use overlay-based providers during app initialization.
+ if (!this._appRef) {
+ this._appRef = this._injector.get(_angular_core__WEBPACK_IMPORTED_MODULE_3__.ApplicationRef);
+ }
+
+ return new _angular_cdk_portal__WEBPACK_IMPORTED_MODULE_11__.DomPortalOutlet(pane, this._componentFactoryResolver, this._appRef, this._injector, this._document);
+ }
+
+}
+
+Overlay.ɵfac = function Overlay_Factory(t) {
+ return new (t || Overlay)(_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](ScrollStrategyOptions), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](OverlayContainer), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_core__WEBPACK_IMPORTED_MODULE_3__.ComponentFactoryResolver), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](OverlayPositionBuilder), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](OverlayKeyboardDispatcher), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_core__WEBPACK_IMPORTED_MODULE_3__.Injector), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_core__WEBPACK_IMPORTED_MODULE_3__.NgZone), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_common__WEBPACK_IMPORTED_MODULE_4__.DOCUMENT), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_cdk_bidi__WEBPACK_IMPORTED_MODULE_12__.Directionality), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_common__WEBPACK_IMPORTED_MODULE_4__.Location), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](OverlayOutsideClickDispatcher));
+};
+
+Overlay.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdefineInjectable"]({
+ token: Overlay,
+ factory: Overlay.ɵfac
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵsetClassMetadata"](Overlay, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Injectable
+ }], function () {
+ return [{
+ type: ScrollStrategyOptions
+ }, {
+ type: OverlayContainer
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.ComponentFactoryResolver
+ }, {
+ type: OverlayPositionBuilder
+ }, {
+ type: OverlayKeyboardDispatcher
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Injector
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.NgZone
+ }, {
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_4__.DOCUMENT]
+ }]
+ }, {
+ type: _angular_cdk_bidi__WEBPACK_IMPORTED_MODULE_12__.Directionality
+ }, {
+ type: _angular_common__WEBPACK_IMPORTED_MODULE_4__.Location
+ }, {
+ type: OverlayOutsideClickDispatcher
+ }];
+ }, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/** Default set of positions for the overlay. Follows the behavior of a dropdown. */
+
+
+const defaultPositionList = [{
+ originX: 'start',
+ originY: 'bottom',
+ overlayX: 'start',
+ overlayY: 'top'
+}, {
+ originX: 'start',
+ originY: 'top',
+ overlayX: 'start',
+ overlayY: 'bottom'
+}, {
+ originX: 'end',
+ originY: 'top',
+ overlayX: 'end',
+ overlayY: 'bottom'
+}, {
+ originX: 'end',
+ originY: 'bottom',
+ overlayX: 'end',
+ overlayY: 'top'
+}];
+/** Injection token that determines the scroll handling while the connected overlay is open. */
+
+const CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY = new _angular_core__WEBPACK_IMPORTED_MODULE_3__.InjectionToken('cdk-connected-overlay-scroll-strategy');
+/**
+ * Directive applied to an element to make it usable as an origin for an Overlay using a
+ * ConnectedPositionStrategy.
+ */
+
+class CdkOverlayOrigin {
+ constructor(
+ /** Reference to the element on which the directive is applied. */
+ elementRef) {
+ this.elementRef = elementRef;
+ }
+
+}
+
+CdkOverlayOrigin.ɵfac = function CdkOverlayOrigin_Factory(t) {
+ return new (t || CdkOverlayOrigin)(_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_3__.ElementRef));
+};
+
+CdkOverlayOrigin.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdefineDirective"]({
+ type: CdkOverlayOrigin,
+ selectors: [["", "cdk-overlay-origin", ""], ["", "overlay-origin", ""], ["", "cdkOverlayOrigin", ""]],
+ exportAs: ["cdkOverlayOrigin"]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵsetClassMetadata"](CdkOverlayOrigin, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Directive,
+ args: [{
+ selector: '[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]',
+ exportAs: 'cdkOverlayOrigin'
+ }]
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.ElementRef
+ }];
+ }, null);
+})();
+/**
+ * Directive to facilitate declarative creation of an
+ * Overlay using a FlexibleConnectedPositionStrategy.
+ */
+
+
+class CdkConnectedOverlay {
+ // TODO(jelbourn): inputs for size, scroll behavior, animation, etc.
+ constructor(_overlay, templateRef, viewContainerRef, scrollStrategyFactory, _dir) {
+ this._overlay = _overlay;
+ this._dir = _dir;
+ this._hasBackdrop = false;
+ this._lockPosition = false;
+ this._growAfterOpen = false;
+ this._flexibleDimensions = false;
+ this._push = false;
+ this._backdropSubscription = rxjs__WEBPACK_IMPORTED_MODULE_7__.Subscription.EMPTY;
+ this._attachSubscription = rxjs__WEBPACK_IMPORTED_MODULE_7__.Subscription.EMPTY;
+ this._detachSubscription = rxjs__WEBPACK_IMPORTED_MODULE_7__.Subscription.EMPTY;
+ this._positionSubscription = rxjs__WEBPACK_IMPORTED_MODULE_7__.Subscription.EMPTY;
+ /** Margin between the overlay and the viewport edges. */
+
+ this.viewportMargin = 0;
+ /** Whether the overlay is open. */
+
+ this.open = false;
+ /** Whether the overlay can be closed by user interaction. */
+
+ this.disableClose = false;
+ /** Event emitted when the backdrop is clicked. */
+
+ this.backdropClick = new _angular_core__WEBPACK_IMPORTED_MODULE_3__.EventEmitter();
+ /** Event emitted when the position has changed. */
+
+ this.positionChange = new _angular_core__WEBPACK_IMPORTED_MODULE_3__.EventEmitter();
+ /** Event emitted when the overlay has been attached. */
+
+ this.attach = new _angular_core__WEBPACK_IMPORTED_MODULE_3__.EventEmitter();
+ /** Event emitted when the overlay has been detached. */
+
+ this.detach = new _angular_core__WEBPACK_IMPORTED_MODULE_3__.EventEmitter();
+ /** Emits when there are keyboard events that are targeted at the overlay. */
+
+ this.overlayKeydown = new _angular_core__WEBPACK_IMPORTED_MODULE_3__.EventEmitter();
+ /** Emits when there are mouse outside click events that are targeted at the overlay. */
+
+ this.overlayOutsideClick = new _angular_core__WEBPACK_IMPORTED_MODULE_3__.EventEmitter();
+ this._templatePortal = new _angular_cdk_portal__WEBPACK_IMPORTED_MODULE_11__.TemplatePortal(templateRef, viewContainerRef);
+ this._scrollStrategyFactory = scrollStrategyFactory;
+ this.scrollStrategy = this._scrollStrategyFactory();
+ }
+ /** The offset in pixels for the overlay connection point on the x-axis */
+
+
+ get offsetX() {
+ return this._offsetX;
+ }
+
+ set offsetX(offsetX) {
+ this._offsetX = offsetX;
+
+ if (this._position) {
+ this._updatePositionStrategy(this._position);
+ }
+ }
+ /** The offset in pixels for the overlay connection point on the y-axis */
+
+
+ get offsetY() {
+ return this._offsetY;
+ }
+
+ set offsetY(offsetY) {
+ this._offsetY = offsetY;
+
+ if (this._position) {
+ this._updatePositionStrategy(this._position);
+ }
+ }
+ /** Whether or not the overlay should attach a backdrop. */
+
+
+ get hasBackdrop() {
+ return this._hasBackdrop;
+ }
+
+ set hasBackdrop(value) {
+ this._hasBackdrop = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceBooleanProperty)(value);
+ }
+ /** Whether or not the overlay should be locked when scrolling. */
+
+
+ get lockPosition() {
+ return this._lockPosition;
+ }
+
+ set lockPosition(value) {
+ this._lockPosition = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceBooleanProperty)(value);
+ }
+ /** Whether the overlay's width and height can be constrained to fit within the viewport. */
+
+
+ get flexibleDimensions() {
+ return this._flexibleDimensions;
+ }
+
+ set flexibleDimensions(value) {
+ this._flexibleDimensions = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceBooleanProperty)(value);
+ }
+ /** Whether the overlay can grow after the initial open when flexible positioning is turned on. */
+
+
+ get growAfterOpen() {
+ return this._growAfterOpen;
+ }
+
+ set growAfterOpen(value) {
+ this._growAfterOpen = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceBooleanProperty)(value);
+ }
+ /** Whether the overlay can be pushed on-screen if none of the provided positions fit. */
+
+
+ get push() {
+ return this._push;
+ }
+
+ set push(value) {
+ this._push = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceBooleanProperty)(value);
+ }
+ /** The associated overlay reference. */
+
+
+ get overlayRef() {
+ return this._overlayRef;
+ }
+ /** The element's layout direction. */
+
+
+ get dir() {
+ return this._dir ? this._dir.value : 'ltr';
+ }
+
+ ngOnDestroy() {
+ this._attachSubscription.unsubscribe();
+
+ this._detachSubscription.unsubscribe();
+
+ this._backdropSubscription.unsubscribe();
+
+ this._positionSubscription.unsubscribe();
+
+ if (this._overlayRef) {
+ this._overlayRef.dispose();
+ }
+ }
+
+ ngOnChanges(changes) {
+ if (this._position) {
+ this._updatePositionStrategy(this._position);
+
+ this._overlayRef.updateSize({
+ width: this.width,
+ minWidth: this.minWidth,
+ height: this.height,
+ minHeight: this.minHeight
+ });
+
+ if (changes['origin'] && this.open) {
+ this._position.apply();
+ }
+ }
+
+ if (changes['open']) {
+ this.open ? this._attachOverlay() : this._detachOverlay();
+ }
+ }
+ /** Creates an overlay */
+
+
+ _createOverlay() {
+ if (!this.positions || !this.positions.length) {
+ this.positions = defaultPositionList;
+ }
+
+ const overlayRef = this._overlayRef = this._overlay.create(this._buildConfig());
+
+ this._attachSubscription = overlayRef.attachments().subscribe(() => this.attach.emit());
+ this._detachSubscription = overlayRef.detachments().subscribe(() => this.detach.emit());
+ overlayRef.keydownEvents().subscribe(event => {
+ this.overlayKeydown.next(event);
+
+ if (event.keyCode === _angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_13__.ESCAPE && !this.disableClose && !(0,_angular_cdk_keycodes__WEBPACK_IMPORTED_MODULE_13__.hasModifierKey)(event)) {
+ event.preventDefault();
+
+ this._detachOverlay();
+ }
+ });
+
+ this._overlayRef.outsidePointerEvents().subscribe(event => {
+ this.overlayOutsideClick.next(event);
+ });
+ }
+ /** Builds the overlay config based on the directive's inputs */
+
+
+ _buildConfig() {
+ const positionStrategy = this._position = this.positionStrategy || this._createPositionStrategy();
+
+ const overlayConfig = new OverlayConfig({
+ direction: this._dir,
+ positionStrategy,
+ scrollStrategy: this.scrollStrategy,
+ hasBackdrop: this.hasBackdrop
+ });
+
+ if (this.width || this.width === 0) {
+ overlayConfig.width = this.width;
+ }
+
+ if (this.height || this.height === 0) {
+ overlayConfig.height = this.height;
+ }
+
+ if (this.minWidth || this.minWidth === 0) {
+ overlayConfig.minWidth = this.minWidth;
+ }
+
+ if (this.minHeight || this.minHeight === 0) {
+ overlayConfig.minHeight = this.minHeight;
+ }
+
+ if (this.backdropClass) {
+ overlayConfig.backdropClass = this.backdropClass;
+ }
+
+ if (this.panelClass) {
+ overlayConfig.panelClass = this.panelClass;
+ }
+
+ return overlayConfig;
+ }
+ /** Updates the state of a position strategy, based on the values of the directive inputs. */
+
+
+ _updatePositionStrategy(positionStrategy) {
+ const positions = this.positions.map(currentPosition => ({
+ originX: currentPosition.originX,
+ originY: currentPosition.originY,
+ overlayX: currentPosition.overlayX,
+ overlayY: currentPosition.overlayY,
+ offsetX: currentPosition.offsetX || this.offsetX,
+ offsetY: currentPosition.offsetY || this.offsetY,
+ panelClass: currentPosition.panelClass || undefined
+ }));
+ return positionStrategy.setOrigin(this._getFlexibleConnectedPositionStrategyOrigin()).withPositions(positions).withFlexibleDimensions(this.flexibleDimensions).withPush(this.push).withGrowAfterOpen(this.growAfterOpen).withViewportMargin(this.viewportMargin).withLockedPosition(this.lockPosition).withTransformOriginOn(this.transformOriginSelector);
+ }
+ /** Returns the position strategy of the overlay to be set on the overlay config */
+
+
+ _createPositionStrategy() {
+ const strategy = this._overlay.position().flexibleConnectedTo(this._getFlexibleConnectedPositionStrategyOrigin());
+
+ this._updatePositionStrategy(strategy);
+
+ return strategy;
+ }
+
+ _getFlexibleConnectedPositionStrategyOrigin() {
+ if (this.origin instanceof CdkOverlayOrigin) {
+ return this.origin.elementRef;
+ } else {
+ return this.origin;
+ }
+ }
+ /** Attaches the overlay and subscribes to backdrop clicks if backdrop exists */
+
+
+ _attachOverlay() {
+ if (!this._overlayRef) {
+ this._createOverlay();
+ } else {
+ // Update the overlay size, in case the directive's inputs have changed
+ this._overlayRef.getConfig().hasBackdrop = this.hasBackdrop;
+ }
+
+ if (!this._overlayRef.hasAttached()) {
+ this._overlayRef.attach(this._templatePortal);
+ }
+
+ if (this.hasBackdrop) {
+ this._backdropSubscription = this._overlayRef.backdropClick().subscribe(event => {
+ this.backdropClick.emit(event);
+ });
+ } else {
+ this._backdropSubscription.unsubscribe();
+ }
+
+ this._positionSubscription.unsubscribe(); // Only subscribe to `positionChanges` if requested, because putting
+ // together all the information for it can be expensive.
+
+
+ if (this.positionChange.observers.length > 0) {
+ this._positionSubscription = this._position.positionChanges.pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_14__.takeWhile)(() => this.positionChange.observers.length > 0)).subscribe(position => {
+ this.positionChange.emit(position);
+
+ if (this.positionChange.observers.length === 0) {
+ this._positionSubscription.unsubscribe();
+ }
+ });
+ }
+ }
+ /** Detaches the overlay and unsubscribes to backdrop clicks if backdrop exists */
+
+
+ _detachOverlay() {
+ if (this._overlayRef) {
+ this._overlayRef.detach();
+ }
+
+ this._backdropSubscription.unsubscribe();
+
+ this._positionSubscription.unsubscribe();
+ }
+
+}
+
+CdkConnectedOverlay.ɵfac = function CdkConnectedOverlay_Factory(t) {
+ return new (t || CdkConnectedOverlay)(_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdirectiveInject"](Overlay), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_3__.TemplateRef), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_3__.ViewContainerRef), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdirectiveInject"](CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdirectiveInject"](_angular_cdk_bidi__WEBPACK_IMPORTED_MODULE_12__.Directionality, 8));
+};
+
+CdkConnectedOverlay.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdefineDirective"]({
+ type: CdkConnectedOverlay,
+ selectors: [["", "cdk-connected-overlay", ""], ["", "connected-overlay", ""], ["", "cdkConnectedOverlay", ""]],
+ inputs: {
+ origin: ["cdkConnectedOverlayOrigin", "origin"],
+ positions: ["cdkConnectedOverlayPositions", "positions"],
+ positionStrategy: ["cdkConnectedOverlayPositionStrategy", "positionStrategy"],
+ offsetX: ["cdkConnectedOverlayOffsetX", "offsetX"],
+ offsetY: ["cdkConnectedOverlayOffsetY", "offsetY"],
+ width: ["cdkConnectedOverlayWidth", "width"],
+ height: ["cdkConnectedOverlayHeight", "height"],
+ minWidth: ["cdkConnectedOverlayMinWidth", "minWidth"],
+ minHeight: ["cdkConnectedOverlayMinHeight", "minHeight"],
+ backdropClass: ["cdkConnectedOverlayBackdropClass", "backdropClass"],
+ panelClass: ["cdkConnectedOverlayPanelClass", "panelClass"],
+ viewportMargin: ["cdkConnectedOverlayViewportMargin", "viewportMargin"],
+ scrollStrategy: ["cdkConnectedOverlayScrollStrategy", "scrollStrategy"],
+ open: ["cdkConnectedOverlayOpen", "open"],
+ disableClose: ["cdkConnectedOverlayDisableClose", "disableClose"],
+ transformOriginSelector: ["cdkConnectedOverlayTransformOriginOn", "transformOriginSelector"],
+ hasBackdrop: ["cdkConnectedOverlayHasBackdrop", "hasBackdrop"],
+ lockPosition: ["cdkConnectedOverlayLockPosition", "lockPosition"],
+ flexibleDimensions: ["cdkConnectedOverlayFlexibleDimensions", "flexibleDimensions"],
+ growAfterOpen: ["cdkConnectedOverlayGrowAfterOpen", "growAfterOpen"],
+ push: ["cdkConnectedOverlayPush", "push"]
+ },
+ outputs: {
+ backdropClick: "backdropClick",
+ positionChange: "positionChange",
+ attach: "attach",
+ detach: "detach",
+ overlayKeydown: "overlayKeydown",
+ overlayOutsideClick: "overlayOutsideClick"
+ },
+ exportAs: ["cdkConnectedOverlay"],
+ features: [_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵNgOnChangesFeature"]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵsetClassMetadata"](CdkConnectedOverlay, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Directive,
+ args: [{
+ selector: '[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]',
+ exportAs: 'cdkConnectedOverlay'
+ }]
+ }], function () {
+ return [{
+ type: Overlay
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.TemplateRef
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.ViewContainerRef
+ }, {
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Inject,
+ args: [CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY]
+ }]
+ }, {
+ type: _angular_cdk_bidi__WEBPACK_IMPORTED_MODULE_12__.Directionality,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Optional
+ }]
+ }];
+ }, {
+ origin: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayOrigin']
+ }],
+ positions: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayPositions']
+ }],
+ positionStrategy: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayPositionStrategy']
+ }],
+ offsetX: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayOffsetX']
+ }],
+ offsetY: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayOffsetY']
+ }],
+ width: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayWidth']
+ }],
+ height: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayHeight']
+ }],
+ minWidth: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayMinWidth']
+ }],
+ minHeight: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayMinHeight']
+ }],
+ backdropClass: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayBackdropClass']
+ }],
+ panelClass: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayPanelClass']
+ }],
+ viewportMargin: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayViewportMargin']
+ }],
+ scrollStrategy: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayScrollStrategy']
+ }],
+ open: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayOpen']
+ }],
+ disableClose: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayDisableClose']
+ }],
+ transformOriginSelector: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayTransformOriginOn']
+ }],
+ hasBackdrop: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayHasBackdrop']
+ }],
+ lockPosition: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayLockPosition']
+ }],
+ flexibleDimensions: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayFlexibleDimensions']
+ }],
+ growAfterOpen: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayGrowAfterOpen']
+ }],
+ push: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Input,
+ args: ['cdkConnectedOverlayPush']
+ }],
+ backdropClick: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Output
+ }],
+ positionChange: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Output
+ }],
+ attach: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Output
+ }],
+ detach: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Output
+ }],
+ overlayKeydown: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Output
+ }],
+ overlayOutsideClick: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Output
+ }]
+ });
+})();
+/** @docs-private */
+
+
+function CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {
+ return () => overlay.scrollStrategies.reposition();
+}
+/** @docs-private */
+
+
+const CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER = {
+ provide: CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY,
+ deps: [Overlay],
+ useFactory: CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY
+};
+/**
+ * @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.io/license
+ */
+
+class OverlayModule {}
+
+OverlayModule.ɵfac = function OverlayModule_Factory(t) {
+ return new (t || OverlayModule)();
+};
+
+OverlayModule.ɵmod = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdefineNgModule"]({
+ type: OverlayModule
+});
+OverlayModule.ɵinj = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdefineInjector"]({
+ providers: [Overlay, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER],
+ imports: [[_angular_cdk_bidi__WEBPACK_IMPORTED_MODULE_12__.BidiModule, _angular_cdk_portal__WEBPACK_IMPORTED_MODULE_11__.PortalModule, _angular_cdk_scrolling__WEBPACK_IMPORTED_MODULE_0__.ScrollingModule], _angular_cdk_scrolling__WEBPACK_IMPORTED_MODULE_0__.ScrollingModule]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵsetClassMetadata"](OverlayModule, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.NgModule,
+ args: [{
+ imports: [_angular_cdk_bidi__WEBPACK_IMPORTED_MODULE_12__.BidiModule, _angular_cdk_portal__WEBPACK_IMPORTED_MODULE_11__.PortalModule, _angular_cdk_scrolling__WEBPACK_IMPORTED_MODULE_0__.ScrollingModule],
+ exports: [CdkConnectedOverlay, CdkOverlayOrigin, _angular_cdk_scrolling__WEBPACK_IMPORTED_MODULE_0__.ScrollingModule],
+ declarations: [CdkConnectedOverlay, CdkOverlayOrigin],
+ providers: [Overlay, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER]
+ }]
+ }], null, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * Alternative to OverlayContainer that supports correct displaying of overlay elements in
+ * Fullscreen mode
+ * https://developer.mozilla.org/en-US/docs/Web/API/Element/requestFullScreen
+ *
+ * Should be provided in the root component.
+ */
+
+
+class FullscreenOverlayContainer extends OverlayContainer {
+ constructor(_document, platform) {
+ super(_document, platform);
+ }
+
+ ngOnDestroy() {
+ super.ngOnDestroy();
+
+ if (this._fullScreenEventName && this._fullScreenListener) {
+ this._document.removeEventListener(this._fullScreenEventName, this._fullScreenListener);
+ }
+ }
+
+ _createContainer() {
+ super._createContainer();
+
+ this._adjustParentForFullscreenChange();
+
+ this._addFullscreenChangeListener(() => this._adjustParentForFullscreenChange());
+ }
+
+ _adjustParentForFullscreenChange() {
+ if (!this._containerElement) {
+ return;
+ }
+
+ const fullscreenElement = this.getFullscreenElement();
+ const parent = fullscreenElement || this._document.body;
+ parent.appendChild(this._containerElement);
+ }
+
+ _addFullscreenChangeListener(fn) {
+ const eventName = this._getEventName();
+
+ if (eventName) {
+ if (this._fullScreenListener) {
+ this._document.removeEventListener(eventName, this._fullScreenListener);
+ }
+
+ this._document.addEventListener(eventName, fn);
+
+ this._fullScreenListener = fn;
+ }
+ }
+
+ _getEventName() {
+ if (!this._fullScreenEventName) {
+ const _document = this._document;
+
+ if (_document.fullscreenEnabled) {
+ this._fullScreenEventName = 'fullscreenchange';
+ } else if (_document.webkitFullscreenEnabled) {
+ this._fullScreenEventName = 'webkitfullscreenchange';
+ } else if (_document.mozFullScreenEnabled) {
+ this._fullScreenEventName = 'mozfullscreenchange';
+ } else if (_document.msFullscreenEnabled) {
+ this._fullScreenEventName = 'MSFullscreenChange';
+ }
+ }
+
+ return this._fullScreenEventName;
+ }
+ /**
+ * When the page is put into fullscreen mode, a specific element is specified.
+ * Only that element and its children are visible when in fullscreen mode.
+ */
+
+
+ getFullscreenElement() {
+ const _document = this._document;
+ return _document.fullscreenElement || _document.webkitFullscreenElement || _document.mozFullScreenElement || _document.msFullscreenElement || null;
+ }
+
+}
+
+FullscreenOverlayContainer.ɵfac = function FullscreenOverlayContainer_Factory(t) {
+ return new (t || FullscreenOverlayContainer)(_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_common__WEBPACK_IMPORTED_MODULE_4__.DOCUMENT), _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵinject"](_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_1__.Platform));
+};
+
+FullscreenOverlayContainer.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵɵdefineInjectable"]({
+ token: FullscreenOverlayContainer,
+ factory: FullscreenOverlayContainer.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_3__["ɵsetClassMetadata"](FullscreenOverlayContainer, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_3__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_4__.DOCUMENT]
+ }]
+ }, {
+ type: _angular_cdk_platform__WEBPACK_IMPORTED_MODULE_1__.Platform
+ }];
+ }, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+
+
+
+/***/ }),
+
+/***/ 9107:
+/*!*********************************************************!*\
+ !*** ./node_modules/@angular/cdk/fesm2020/platform.mjs ***!
+ \*********************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "Platform": () => (/* binding */ Platform),
+/* harmony export */ "PlatformModule": () => (/* binding */ PlatformModule),
+/* harmony export */ "_getEventTarget": () => (/* binding */ _getEventTarget),
+/* harmony export */ "_getFocusedElementPierceShadowDom": () => (/* binding */ _getFocusedElementPierceShadowDom),
+/* harmony export */ "_getShadowRoot": () => (/* binding */ _getShadowRoot),
+/* harmony export */ "_isTestEnvironment": () => (/* binding */ _isTestEnvironment),
+/* harmony export */ "_supportsShadowDom": () => (/* binding */ _supportsShadowDom),
+/* harmony export */ "getRtlScrollAxisType": () => (/* binding */ getRtlScrollAxisType),
+/* harmony export */ "getSupportedInputTypes": () => (/* binding */ getSupportedInputTypes),
+/* harmony export */ "normalizePassiveListenerOptions": () => (/* binding */ normalizePassiveListenerOptions),
+/* harmony export */ "supportsPassiveEventListeners": () => (/* binding */ supportsPassiveEventListeners),
+/* harmony export */ "supportsScrollBehavior": () => (/* binding */ supportsScrollBehavior)
+/* harmony export */ });
+/* harmony import */ var _angular_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @angular/core */ 2560);
+/* harmony import */ var _angular_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @angular/common */ 4666);
+
+
+
+/**
+ * @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.io/license
+ */
+// Whether the current platform supports the V8 Break Iterator. The V8 check
+// is necessary to detect all Blink based browsers.
+
+let hasV8BreakIterator; // We need a try/catch around the reference to `Intl`, because accessing it in some cases can
+// cause IE to throw. These cases are tied to particular versions of Windows and can happen if
+// the consumer is providing a polyfilled `Map`. See:
+// https://github.com/Microsoft/ChakraCore/issues/3189
+// https://github.com/angular/components/issues/15687
+
+try {
+ hasV8BreakIterator = typeof Intl !== 'undefined' && Intl.v8BreakIterator;
+} catch {
+ hasV8BreakIterator = false;
+}
+/**
+ * Service to detect the current platform by comparing the userAgent strings and
+ * checking browser-specific global properties.
+ */
+
+
+class Platform {
+ constructor(_platformId) {
+ this._platformId = _platformId; // We want to use the Angular platform check because if the Document is shimmed
+ // without the navigator, the following checks will fail. This is preferred because
+ // sometimes the Document may be shimmed without the user's knowledge or intention
+
+ /** Whether the Angular application is being rendered in the browser. */
+
+ this.isBrowser = this._platformId ? (0,_angular_common__WEBPACK_IMPORTED_MODULE_0__.isPlatformBrowser)(this._platformId) : typeof document === 'object' && !!document;
+ /** Whether the current browser is Microsoft Edge. */
+
+ this.EDGE = this.isBrowser && /(edge)/i.test(navigator.userAgent);
+ /** Whether the current rendering engine is Microsoft Trident. */
+
+ this.TRIDENT = this.isBrowser && /(msie|trident)/i.test(navigator.userAgent); // EdgeHTML and Trident mock Blink specific things and need to be excluded from this check.
+
+ /** Whether the current rendering engine is Blink. */
+
+ this.BLINK = this.isBrowser && !!(window.chrome || hasV8BreakIterator) && typeof CSS !== 'undefined' && !this.EDGE && !this.TRIDENT; // Webkit is part of the userAgent in EdgeHTML, Blink and Trident. Therefore we need to
+ // ensure that Webkit runs standalone and is not used as another engine's base.
+
+ /** Whether the current rendering engine is WebKit. */
+
+ this.WEBKIT = this.isBrowser && /AppleWebKit/i.test(navigator.userAgent) && !this.BLINK && !this.EDGE && !this.TRIDENT;
+ /** Whether the current platform is Apple iOS. */
+
+ this.IOS = this.isBrowser && /iPad|iPhone|iPod/.test(navigator.userAgent) && !('MSStream' in window); // It's difficult to detect the plain Gecko engine, because most of the browsers identify
+ // them self as Gecko-like browsers and modify the userAgent's according to that.
+ // Since we only cover one explicit Firefox case, we can simply check for Firefox
+ // instead of having an unstable check for Gecko.
+
+ /** Whether the current browser is Firefox. */
+
+ this.FIREFOX = this.isBrowser && /(firefox|minefield)/i.test(navigator.userAgent);
+ /** Whether the current platform is Android. */
+ // Trident on mobile adds the android platform to the userAgent to trick detections.
+
+ this.ANDROID = this.isBrowser && /android/i.test(navigator.userAgent) && !this.TRIDENT; // Safari browsers will include the Safari keyword in their userAgent. Some browsers may fake
+ // this and just place the Safari keyword in the userAgent. To be more safe about Safari every
+ // Safari browser should also use Webkit as its layout engine.
+
+ /** Whether the current browser is Safari. */
+
+ this.SAFARI = this.isBrowser && /safari/i.test(navigator.userAgent) && this.WEBKIT;
+ }
+
+}
+
+Platform.ɵfac = function Platform_Factory(t) {
+ return new (t || Platform)(_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵinject"](_angular_core__WEBPACK_IMPORTED_MODULE_1__.PLATFORM_ID));
+};
+
+Platform.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdefineInjectable"]({
+ token: Platform,
+ factory: Platform.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵsetClassMetadata"](Platform, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: Object,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Inject,
+ args: [_angular_core__WEBPACK_IMPORTED_MODULE_1__.PLATFORM_ID]
+ }]
+ }];
+ }, null);
+})();
+/**
+ * @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.io/license
+ */
+
+
+class PlatformModule {}
+
+PlatformModule.ɵfac = function PlatformModule_Factory(t) {
+ return new (t || PlatformModule)();
+};
+
+PlatformModule.ɵmod = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdefineNgModule"]({
+ type: PlatformModule
+});
+PlatformModule.ɵinj = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdefineInjector"]({});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵsetClassMetadata"](PlatformModule, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.NgModule,
+ args: [{}]
+ }], null, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/** Cached result Set of input types support by the current browser. */
+
+
+let supportedInputTypes;
+/** Types of `` that *might* be supported. */
+
+const candidateInputTypes = [// `color` must come first. Chrome 56 shows a warning if we change the type to `color` after
+// first changing it to something else:
+// The specified value "" does not conform to the required format.
+// The format is "#rrggbb" where rr, gg, bb are two-digit hexadecimal numbers.
+'color', 'button', 'checkbox', 'date', 'datetime-local', 'email', 'file', 'hidden', 'image', 'month', 'number', 'password', 'radio', 'range', 'reset', 'search', 'submit', 'tel', 'text', 'time', 'url', 'week'];
+/** @returns The input types supported by this browser. */
+
+function getSupportedInputTypes() {
+ // Result is cached.
+ if (supportedInputTypes) {
+ return supportedInputTypes;
+ } // We can't check if an input type is not supported until we're on the browser, so say that
+ // everything is supported when not on the browser. We don't use `Platform` here since it's
+ // just a helper function and can't inject it.
+
+
+ if (typeof document !== 'object' || !document) {
+ supportedInputTypes = new Set(candidateInputTypes);
+ return supportedInputTypes;
+ }
+
+ let featureTestInput = document.createElement('input');
+ supportedInputTypes = new Set(candidateInputTypes.filter(value => {
+ featureTestInput.setAttribute('type', value);
+ return featureTestInput.type === value;
+ }));
+ return supportedInputTypes;
+}
+/**
+ * @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.io/license
+ */
+
+/** Cached result of whether the user's browser supports passive event listeners. */
+
+
+let supportsPassiveEvents;
+/**
+ * Checks whether the user's browser supports passive event listeners.
+ * See: https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md
+ */
+
+function supportsPassiveEventListeners() {
+ if (supportsPassiveEvents == null && typeof window !== 'undefined') {
+ try {
+ window.addEventListener('test', null, Object.defineProperty({}, 'passive', {
+ get: () => supportsPassiveEvents = true
+ }));
+ } finally {
+ supportsPassiveEvents = supportsPassiveEvents || false;
+ }
+ }
+
+ return supportsPassiveEvents;
+}
+/**
+ * Normalizes an `AddEventListener` object to something that can be passed
+ * to `addEventListener` on any browser, no matter whether it supports the
+ * `options` parameter.
+ * @param options Object to be normalized.
+ */
+
+
+function normalizePassiveListenerOptions(options) {
+ return supportsPassiveEventListeners() ? options : !!options.capture;
+}
+/**
+ * @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.io/license
+ */
+
+/** Cached result of the way the browser handles the horizontal scroll axis in RTL mode. */
+
+
+let rtlScrollAxisType;
+/** Cached result of the check that indicates whether the browser supports scroll behaviors. */
+
+let scrollBehaviorSupported;
+/** Check whether the browser supports scroll behaviors. */
+
+function supportsScrollBehavior() {
+ if (scrollBehaviorSupported == null) {
+ // If we're not in the browser, it can't be supported. Also check for `Element`, because
+ // some projects stub out the global `document` during SSR which can throw us off.
+ if (typeof document !== 'object' || !document || typeof Element !== 'function' || !Element) {
+ scrollBehaviorSupported = false;
+ return scrollBehaviorSupported;
+ } // If the element can have a `scrollBehavior` style, we can be sure that it's supported.
+
+
+ if ('scrollBehavior' in document.documentElement.style) {
+ scrollBehaviorSupported = true;
+ } else {
+ // At this point we have 3 possibilities: `scrollTo` isn't supported at all, it's
+ // supported but it doesn't handle scroll behavior, or it has been polyfilled.
+ const scrollToFunction = Element.prototype.scrollTo;
+
+ if (scrollToFunction) {
+ // We can detect if the function has been polyfilled by calling `toString` on it. Native
+ // functions are obfuscated using `[native code]`, whereas if it was overwritten we'd get
+ // the actual function source. Via https://davidwalsh.name/detect-native-function. Consider
+ // polyfilled functions as supporting scroll behavior.
+ scrollBehaviorSupported = !/\{\s*\[native code\]\s*\}/.test(scrollToFunction.toString());
+ } else {
+ scrollBehaviorSupported = false;
+ }
+ }
+ }
+
+ return scrollBehaviorSupported;
+}
+/**
+ * Checks the type of RTL scroll axis used by this browser. As of time of writing, Chrome is NORMAL,
+ * Firefox & Safari are NEGATED, and IE & Edge are INVERTED.
+ */
+
+
+function getRtlScrollAxisType() {
+ // We can't check unless we're on the browser. Just assume 'normal' if we're not.
+ if (typeof document !== 'object' || !document) {
+ return 0
+ /* NORMAL */
+ ;
+ }
+
+ if (rtlScrollAxisType == null) {
+ // Create a 1px wide scrolling container and a 2px wide content element.
+ const scrollContainer = document.createElement('div');
+ const containerStyle = scrollContainer.style;
+ scrollContainer.dir = 'rtl';
+ containerStyle.width = '1px';
+ containerStyle.overflow = 'auto';
+ containerStyle.visibility = 'hidden';
+ containerStyle.pointerEvents = 'none';
+ containerStyle.position = 'absolute';
+ const content = document.createElement('div');
+ const contentStyle = content.style;
+ contentStyle.width = '2px';
+ contentStyle.height = '1px';
+ scrollContainer.appendChild(content);
+ document.body.appendChild(scrollContainer);
+ rtlScrollAxisType = 0
+ /* NORMAL */
+ ; // The viewport starts scrolled all the way to the right in RTL mode. If we are in a NORMAL
+ // browser this would mean that the scrollLeft should be 1. If it's zero instead we know we're
+ // dealing with one of the other two types of browsers.
+
+ if (scrollContainer.scrollLeft === 0) {
+ // In a NEGATED browser the scrollLeft is always somewhere in [-maxScrollAmount, 0]. For an
+ // INVERTED browser it is always somewhere in [0, maxScrollAmount]. We can determine which by
+ // setting to the scrollLeft to 1. This is past the max for a NEGATED browser, so it will
+ // return 0 when we read it again.
+ scrollContainer.scrollLeft = 1;
+ rtlScrollAxisType = scrollContainer.scrollLeft === 0 ? 1
+ /* NEGATED */
+ : 2
+ /* INVERTED */
+ ;
+ }
+
+ scrollContainer.remove();
+ }
+
+ return rtlScrollAxisType;
+}
+/**
+ * @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.io/license
+ */
+
+
+let shadowDomIsSupported;
+/** Checks whether the user's browser support Shadow DOM. */
+
+function _supportsShadowDom() {
+ if (shadowDomIsSupported == null) {
+ const head = typeof document !== 'undefined' ? document.head : null;
+ shadowDomIsSupported = !!(head && (head.createShadowRoot || head.attachShadow));
+ }
+
+ return shadowDomIsSupported;
+}
+/** Gets the shadow root of an element, if supported and the element is inside the Shadow DOM. */
+
+
+function _getShadowRoot(element) {
+ if (_supportsShadowDom()) {
+ const rootNode = element.getRootNode ? element.getRootNode() : null; // Note that this should be caught by `_supportsShadowDom`, but some
+ // teams have been able to hit this code path on unsupported browsers.
+
+ if (typeof ShadowRoot !== 'undefined' && ShadowRoot && rootNode instanceof ShadowRoot) {
+ return rootNode;
+ }
+ }
+
+ return null;
+}
+/**
+ * Gets the currently-focused element on the page while
+ * also piercing through Shadow DOM boundaries.
+ */
+
+
+function _getFocusedElementPierceShadowDom() {
+ let activeElement = typeof document !== 'undefined' && document ? document.activeElement : null;
+
+ while (activeElement && activeElement.shadowRoot) {
+ const newActiveElement = activeElement.shadowRoot.activeElement;
+
+ if (newActiveElement === activeElement) {
+ break;
+ } else {
+ activeElement = newActiveElement;
+ }
+ }
+
+ return activeElement;
+}
+/** Gets the target of an event while accounting for Shadow DOM. */
+
+
+function _getEventTarget(event) {
+ // If an event is bound outside the Shadow DOM, the `event.target` will
+ // point to the shadow root so we have to use `composedPath` instead.
+ return event.composedPath ? event.composedPath()[0] : event.target;
+}
+/**
+ * @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.io/license
+ */
+
+
+let testGlobals; // We check the Node-specific `global` first, because tools tend to add a fake
+// `window` in Node environments which won't actually receive global variables.
+
+if (typeof global !== 'undefined') {
+ testGlobals = global;
+} else if (typeof window !== 'undefined') {
+ testGlobals = window;
+} else {
+ testGlobals = {};
+}
+/** Gets whether the code is currently running in a test environment. */
+
+
+function _isTestEnvironment() {
+ return typeof testGlobals.__karma__ !== 'undefined' && !!testGlobals.__karma__ || typeof testGlobals.jasmine !== 'undefined' && !!testGlobals.jasmine || typeof testGlobals.jest !== 'undefined' && !!testGlobals.jest || typeof testGlobals.Mocha !== 'undefined' && !!testGlobals.Mocha;
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+
+
+
+/***/ }),
+
+/***/ 7520:
+/*!*******************************************************!*\
+ !*** ./node_modules/@angular/cdk/fesm2020/portal.mjs ***!
+ \*******************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "BasePortalHost": () => (/* binding */ BasePortalHost),
+/* harmony export */ "BasePortalOutlet": () => (/* binding */ BasePortalOutlet),
+/* harmony export */ "CdkPortal": () => (/* binding */ CdkPortal),
+/* harmony export */ "CdkPortalOutlet": () => (/* binding */ CdkPortalOutlet),
+/* harmony export */ "ComponentPortal": () => (/* binding */ ComponentPortal),
+/* harmony export */ "DomPortal": () => (/* binding */ DomPortal),
+/* harmony export */ "DomPortalHost": () => (/* binding */ DomPortalHost),
+/* harmony export */ "DomPortalOutlet": () => (/* binding */ DomPortalOutlet),
+/* harmony export */ "Portal": () => (/* binding */ Portal),
+/* harmony export */ "PortalHostDirective": () => (/* binding */ PortalHostDirective),
+/* harmony export */ "PortalInjector": () => (/* binding */ PortalInjector),
+/* harmony export */ "PortalModule": () => (/* binding */ PortalModule),
+/* harmony export */ "TemplatePortal": () => (/* binding */ TemplatePortal),
+/* harmony export */ "TemplatePortalDirective": () => (/* binding */ TemplatePortalDirective)
+/* harmony export */ });
+/* harmony import */ var _angular_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @angular/core */ 2560);
+/* harmony import */ var _angular_common__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @angular/common */ 4666);
+
+
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * Throws an exception when attempting to attach a null portal to a host.
+ * @docs-private
+ */
+
+function throwNullPortalError() {
+ throw Error('Must provide a portal to attach');
+}
+/**
+ * Throws an exception when attempting to attach a portal to a host that is already attached.
+ * @docs-private
+ */
+
+
+function throwPortalAlreadyAttachedError() {
+ throw Error('Host already has a portal attached');
+}
+/**
+ * Throws an exception when attempting to attach a portal to an already-disposed host.
+ * @docs-private
+ */
+
+
+function throwPortalOutletAlreadyDisposedError() {
+ throw Error('This PortalOutlet has already been disposed');
+}
+/**
+ * Throws an exception when attempting to attach an unknown portal type.
+ * @docs-private
+ */
+
+
+function throwUnknownPortalTypeError() {
+ throw Error('Attempting to attach an unknown Portal type. BasePortalOutlet accepts either ' + 'a ComponentPortal or a TemplatePortal.');
+}
+/**
+ * Throws an exception when attempting to attach a portal to a null host.
+ * @docs-private
+ */
+
+
+function throwNullPortalOutletError() {
+ throw Error('Attempting to attach a portal to a null PortalOutlet');
+}
+/**
+ * Throws an exception when attempting to detach a portal that is not attached.
+ * @docs-private
+ */
+
+
+function throwNoPortalAttachedError() {
+ throw Error('Attempting to detach a portal that is not attached to a host');
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * A `Portal` is something that you want to render somewhere else.
+ * It can be attach to / detached from a `PortalOutlet`.
+ */
+
+
+class Portal {
+ /** Attach this portal to a host. */
+ attach(host) {
+ if (typeof ngDevMode === 'undefined' || ngDevMode) {
+ if (host == null) {
+ throwNullPortalOutletError();
+ }
+
+ if (host.hasAttached()) {
+ throwPortalAlreadyAttachedError();
+ }
+ }
+
+ this._attachedHost = host;
+ return host.attach(this);
+ }
+ /** Detach this portal from its host */
+
+
+ detach() {
+ let host = this._attachedHost;
+
+ if (host != null) {
+ this._attachedHost = null;
+ host.detach();
+ } else if (typeof ngDevMode === 'undefined' || ngDevMode) {
+ throwNoPortalAttachedError();
+ }
+ }
+ /** Whether this portal is attached to a host. */
+
+
+ get isAttached() {
+ return this._attachedHost != null;
+ }
+ /**
+ * Sets the PortalOutlet reference without performing `attach()`. This is used directly by
+ * the PortalOutlet when it is performing an `attach()` or `detach()`.
+ */
+
+
+ setAttachedHost(host) {
+ this._attachedHost = host;
+ }
+
+}
+/**
+ * A `ComponentPortal` is a portal that instantiates some Component upon attachment.
+ */
+
+
+class ComponentPortal extends Portal {
+ constructor(component, viewContainerRef, injector, componentFactoryResolver) {
+ super();
+ this.component = component;
+ this.viewContainerRef = viewContainerRef;
+ this.injector = injector;
+ this.componentFactoryResolver = componentFactoryResolver;
+ }
+
+}
+/**
+ * A `TemplatePortal` is a portal that represents some embedded template (TemplateRef).
+ */
+
+
+class TemplatePortal extends Portal {
+ constructor(template, viewContainerRef, context) {
+ super();
+ this.templateRef = template;
+ this.viewContainerRef = viewContainerRef;
+ this.context = context;
+ }
+
+ get origin() {
+ return this.templateRef.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, context = this.context) {
+ this.context = context;
+ return super.attach(host);
+ }
+
+ detach() {
+ this.context = undefined;
+ return super.detach();
+ }
+
+}
+/**
+ * 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.
+ */
+
+
+class DomPortal extends Portal {
+ constructor(element) {
+ super();
+ this.element = element instanceof _angular_core__WEBPACK_IMPORTED_MODULE_0__.ElementRef ? element.nativeElement : element;
+ }
+
+}
+/**
+ * Partial implementation of PortalOutlet that handles attaching
+ * ComponentPortal and TemplatePortal.
+ */
+
+
+class BasePortalOutlet {
+ constructor() {
+ /** Whether this host has already been permanently disposed. */
+ this._isDisposed = false; // @breaking-change 10.0.0 `attachDomPortal` to become a required abstract method.
+
+ this.attachDomPortal = null;
+ }
+ /** Whether this host has an attached portal. */
+
+
+ hasAttached() {
+ return !!this._attachedPortal;
+ }
+ /** Attaches a portal. */
+
+
+ attach(portal) {
+ if (typeof ngDevMode === 'undefined' || ngDevMode) {
+ if (!portal) {
+ throwNullPortalError();
+ }
+
+ if (this.hasAttached()) {
+ throwPortalAlreadyAttachedError();
+ }
+
+ if (this._isDisposed) {
+ throwPortalOutletAlreadyDisposedError();
+ }
+ }
+
+ if (portal instanceof ComponentPortal) {
+ this._attachedPortal = portal;
+ return this.attachComponentPortal(portal);
+ } else if (portal instanceof TemplatePortal) {
+ this._attachedPortal = portal;
+ return this.attachTemplatePortal(portal); // @breaking-change 10.0.0 remove null check for `this.attachDomPortal`.
+ } else if (this.attachDomPortal && portal instanceof DomPortal) {
+ this._attachedPortal = portal;
+ return this.attachDomPortal(portal);
+ }
+
+ if (typeof ngDevMode === 'undefined' || ngDevMode) {
+ throwUnknownPortalTypeError();
+ }
+ }
+ /** Detaches a previously attached portal. */
+
+
+ detach() {
+ if (this._attachedPortal) {
+ this._attachedPortal.setAttachedHost(null);
+
+ this._attachedPortal = null;
+ }
+
+ this._invokeDisposeFn();
+ }
+ /** Permanently dispose of this portal host. */
+
+
+ dispose() {
+ if (this.hasAttached()) {
+ this.detach();
+ }
+
+ this._invokeDisposeFn();
+
+ this._isDisposed = true;
+ }
+ /** @docs-private */
+
+
+ setDisposeFn(fn) {
+ this._disposeFn = fn;
+ }
+
+ _invokeDisposeFn() {
+ if (this._disposeFn) {
+ this._disposeFn();
+
+ this._disposeFn = null;
+ }
+ }
+
+}
+/**
+ * @deprecated Use `BasePortalOutlet` instead.
+ * @breaking-change 9.0.0
+ */
+
+
+class BasePortalHost extends BasePortalOutlet {}
+/**
+ * @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.io/license
+ */
+
+/**
+ * A PortalOutlet for attaching portals to an arbitrary DOM element outside of the Angular
+ * application context.
+ */
+
+
+class DomPortalOutlet extends BasePortalOutlet {
+ constructor(
+ /** Element into which the content is projected. */
+ outletElement, _componentFactoryResolver, _appRef, _defaultInjector,
+ /**
+ * @deprecated `_document` Parameter to be made required.
+ * @breaking-change 10.0.0
+ */
+ _document) {
+ super();
+ this.outletElement = outletElement;
+ this._componentFactoryResolver = _componentFactoryResolver;
+ this._appRef = _appRef;
+ this._defaultInjector = _defaultInjector;
+ /**
+ * Attaches a DOM portal by transferring its content into the outlet.
+ * @param portal Portal to be attached.
+ * @deprecated To be turned into a method.
+ * @breaking-change 10.0.0
+ */
+
+ this.attachDomPortal = portal => {
+ // @breaking-change 10.0.0 Remove check and error once the
+ // `_document` constructor parameter is required.
+ if (!this._document && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+ throw Error('Cannot attach DOM portal without _document constructor parameter');
+ }
+
+ const element = portal.element;
+
+ if (!element.parentNode && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+ throw Error('DOM portal content must be attached to a parent node.');
+ } // Anchor used to save the element's previous position so
+ // that we can restore it when the portal is detached.
+
+
+ const anchorNode = this._document.createComment('dom-portal');
+
+ element.parentNode.insertBefore(anchorNode, element);
+ this.outletElement.appendChild(element);
+ this._attachedPortal = portal;
+ super.setDisposeFn(() => {
+ // We can't use `replaceWith` here because IE doesn't support it.
+ if (anchorNode.parentNode) {
+ anchorNode.parentNode.replaceChild(element, anchorNode);
+ }
+ });
+ };
+
+ this._document = _document;
+ }
+ /**
+ * Attach the given ComponentPortal to DOM element using the ComponentFactoryResolver.
+ * @param portal Portal to be attached
+ * @returns Reference to the created component.
+ */
+
+
+ attachComponentPortal(portal) {
+ const resolver = portal.componentFactoryResolver || this._componentFactoryResolver;
+ const componentFactory = resolver.resolveComponentFactory(portal.component);
+ let componentRef; // If the portal specifies a ViewContainerRef, we will use that as the attachment point
+ // for the component (in terms of Angular's component tree, not rendering).
+ // When the ViewContainerRef is missing, we use the factory to create the component directly
+ // and then manually attach the view to the application.
+
+ if (portal.viewContainerRef) {
+ componentRef = portal.viewContainerRef.createComponent(componentFactory, portal.viewContainerRef.length, portal.injector || portal.viewContainerRef.injector);
+ this.setDisposeFn(() => componentRef.destroy());
+ } else {
+ componentRef = componentFactory.create(portal.injector || this._defaultInjector);
+
+ this._appRef.attachView(componentRef.hostView);
+
+ this.setDisposeFn(() => {
+ this._appRef.detachView(componentRef.hostView);
+
+ componentRef.destroy();
+ });
+ } // At this point the component has been instantiated, so we move it to the location in the DOM
+ // where we want it to be rendered.
+
+
+ this.outletElement.appendChild(this._getComponentRootNode(componentRef));
+ this._attachedPortal = portal;
+ return componentRef;
+ }
+ /**
+ * Attaches a template portal to the DOM as an embedded view.
+ * @param portal Portal to be attached.
+ * @returns Reference to the created embedded view.
+ */
+
+
+ attachTemplatePortal(portal) {
+ let viewContainer = portal.viewContainerRef;
+ let viewRef = viewContainer.createEmbeddedView(portal.templateRef, portal.context); // The method `createEmbeddedView` will add the view as a child of the viewContainer.
+ // But for the DomPortalOutlet the view can be added everywhere in the DOM
+ // (e.g Overlay Container) To move the view to the specified host element. We just
+ // re-append the existing root nodes.
+
+ viewRef.rootNodes.forEach(rootNode => this.outletElement.appendChild(rootNode)); // Note that we want to detect changes after the nodes have been moved so that
+ // any directives inside the portal that are looking at the DOM inside a lifecycle
+ // hook won't be invoked too early.
+
+ viewRef.detectChanges();
+ this.setDisposeFn(() => {
+ let index = viewContainer.indexOf(viewRef);
+
+ if (index !== -1) {
+ viewContainer.remove(index);
+ }
+ });
+ this._attachedPortal = portal; // TODO(jelbourn): Return locals from view.
+
+ return viewRef;
+ }
+ /**
+ * Clears out a portal from the DOM.
+ */
+
+
+ dispose() {
+ super.dispose();
+ this.outletElement.remove();
+ }
+ /** Gets the root HTMLElement for an instantiated component. */
+
+
+ _getComponentRootNode(componentRef) {
+ return componentRef.hostView.rootNodes[0];
+ }
+
+}
+/**
+ * @deprecated Use `DomPortalOutlet` instead.
+ * @breaking-change 9.0.0
+ */
+
+
+class DomPortalHost extends DomPortalOutlet {}
+/**
+ * @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.io/license
+ */
+
+/**
+ * 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.
+ */
+
+
+class CdkPortal extends TemplatePortal {
+ constructor(templateRef, viewContainerRef) {
+ super(templateRef, viewContainerRef);
+ }
+
+}
+
+CdkPortal.ɵfac = function CdkPortal_Factory(t) {
+ return new (t || CdkPortal)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.TemplateRef), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.ViewContainerRef));
+};
+
+CdkPortal.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineDirective"]({
+ type: CdkPortal,
+ selectors: [["", "cdkPortal", ""]],
+ exportAs: ["cdkPortal"],
+ features: [_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵInheritDefinitionFeature"]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](CdkPortal, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Directive,
+ args: [{
+ selector: '[cdkPortal]',
+ exportAs: 'cdkPortal'
+ }]
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.TemplateRef
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.ViewContainerRef
+ }];
+ }, null);
+})();
+/**
+ * @deprecated Use `CdkPortal` instead.
+ * @breaking-change 9.0.0
+ */
+
+
+class TemplatePortalDirective extends CdkPortal {}
+
+TemplatePortalDirective.ɵfac = /* @__PURE__ */function () {
+ let ɵTemplatePortalDirective_BaseFactory;
+ return function TemplatePortalDirective_Factory(t) {
+ return (ɵTemplatePortalDirective_BaseFactory || (ɵTemplatePortalDirective_BaseFactory = _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵgetInheritedFactory"](TemplatePortalDirective)))(t || TemplatePortalDirective);
+ };
+}();
+
+TemplatePortalDirective.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineDirective"]({
+ type: TemplatePortalDirective,
+ selectors: [["", "cdk-portal", ""], ["", "portal", ""]],
+ exportAs: ["cdkPortal"],
+ features: [_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵProvidersFeature"]([{
+ provide: CdkPortal,
+ useExisting: TemplatePortalDirective
+ }]), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵInheritDefinitionFeature"]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](TemplatePortalDirective, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Directive,
+ args: [{
+ selector: '[cdk-portal], [portal]',
+ exportAs: 'cdkPortal',
+ providers: [{
+ provide: CdkPortal,
+ useExisting: TemplatePortalDirective
+ }]
+ }]
+ }], null, null);
+})();
+/**
+ * Directive version of a PortalOutlet. Because the directive *is* a PortalOutlet, portals can be
+ * directly attached to it, enabling declarative use.
+ *
+ * Usage:
+ * ``
+ // and attach a portal programmatically in the parent component. When Angular does the first CD
+ // round, it will fire the setter with empty string, causing the user's content to be cleared.
+ if (this.hasAttached() && !portal && !this._isInitialized) {
+ return;
+ }
+
+ if (this.hasAttached()) {
+ super.detach();
+ }
+
+ if (portal) {
+ super.attach(portal);
+ }
+
+ this._attachedPortal = portal;
+ }
+ /** Component or view reference that is attached to the portal. */
+
+
+ get attachedRef() {
+ return this._attachedRef;
+ }
+
+ ngOnInit() {
+ this._isInitialized = true;
+ }
+
+ ngOnDestroy() {
+ super.dispose();
+ this._attachedPortal = null;
+ this._attachedRef = null;
+ }
+ /**
+ * Attach the given ComponentPortal to this PortalOutlet using the ComponentFactoryResolver.
+ *
+ * @param portal Portal to be attached to the portal outlet.
+ * @returns Reference to the created component.
+ */
+
+
+ attachComponentPortal(portal) {
+ portal.setAttachedHost(this); // If the portal specifies an origin, use that as the logical location of the component
+ // in the application tree. Otherwise use the location of this PortalOutlet.
+
+ const viewContainerRef = portal.viewContainerRef != null ? portal.viewContainerRef : this._viewContainerRef;
+ const resolver = portal.componentFactoryResolver || this._componentFactoryResolver;
+ const componentFactory = resolver.resolveComponentFactory(portal.component);
+ const ref = viewContainerRef.createComponent(componentFactory, viewContainerRef.length, portal.injector || viewContainerRef.injector); // If we're using a view container that's different from the injected one (e.g. when the portal
+ // specifies its own) we need to move the component into the outlet, otherwise it'll be rendered
+ // inside of the alternate view container.
+
+ if (viewContainerRef !== this._viewContainerRef) {
+ this._getRootNode().appendChild(ref.hostView.rootNodes[0]);
+ }
+
+ super.setDisposeFn(() => ref.destroy());
+ this._attachedPortal = portal;
+ this._attachedRef = ref;
+ this.attached.emit(ref);
+ return ref;
+ }
+ /**
+ * 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(portal) {
+ portal.setAttachedHost(this);
+
+ const viewRef = this._viewContainerRef.createEmbeddedView(portal.templateRef, portal.context);
+
+ super.setDisposeFn(() => this._viewContainerRef.clear());
+ this._attachedPortal = portal;
+ this._attachedRef = viewRef;
+ this.attached.emit(viewRef);
+ return viewRef;
+ }
+ /** Gets the root node of the portal outlet. */
+
+
+ _getRootNode() {
+ const nativeElement = this._viewContainerRef.element.nativeElement; // The directive could be set on a template which will result in a comment
+ // node being the root. Use the comment's parent node if that is the case.
+
+ return nativeElement.nodeType === nativeElement.ELEMENT_NODE ? nativeElement : nativeElement.parentNode;
+ }
+
+}
+
+CdkPortalOutlet.ɵfac = function CdkPortalOutlet_Factory(t) {
+ return new (t || CdkPortalOutlet)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.ComponentFactoryResolver), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.ViewContainerRef), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT));
+};
+
+CdkPortalOutlet.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineDirective"]({
+ type: CdkPortalOutlet,
+ selectors: [["", "cdkPortalOutlet", ""]],
+ inputs: {
+ portal: ["cdkPortalOutlet", "portal"]
+ },
+ outputs: {
+ attached: "attached"
+ },
+ exportAs: ["cdkPortalOutlet"],
+ features: [_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵInheritDefinitionFeature"]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](CdkPortalOutlet, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Directive,
+ args: [{
+ selector: '[cdkPortalOutlet]',
+ exportAs: 'cdkPortalOutlet',
+ inputs: ['portal: cdkPortalOutlet']
+ }]
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.ComponentFactoryResolver
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.ViewContainerRef
+ }, {
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_1__.DOCUMENT]
+ }]
+ }];
+ }, {
+ attached: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Output
+ }]
+ });
+})();
+/**
+ * @deprecated Use `CdkPortalOutlet` instead.
+ * @breaking-change 9.0.0
+ */
+
+
+class PortalHostDirective extends CdkPortalOutlet {}
+
+PortalHostDirective.ɵfac = /* @__PURE__ */function () {
+ let ɵPortalHostDirective_BaseFactory;
+ return function PortalHostDirective_Factory(t) {
+ return (ɵPortalHostDirective_BaseFactory || (ɵPortalHostDirective_BaseFactory = _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵgetInheritedFactory"](PortalHostDirective)))(t || PortalHostDirective);
+ };
+}();
+
+PortalHostDirective.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineDirective"]({
+ type: PortalHostDirective,
+ selectors: [["", "cdkPortalHost", ""], ["", "portalHost", ""]],
+ inputs: {
+ portal: ["cdkPortalHost", "portal"]
+ },
+ exportAs: ["cdkPortalHost"],
+ features: [_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵProvidersFeature"]([{
+ provide: CdkPortalOutlet,
+ useExisting: PortalHostDirective
+ }]), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵInheritDefinitionFeature"]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](PortalHostDirective, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Directive,
+ args: [{
+ selector: '[cdkPortalHost], [portalHost]',
+ exportAs: 'cdkPortalHost',
+ inputs: ['portal: cdkPortalHost'],
+ providers: [{
+ provide: CdkPortalOutlet,
+ useExisting: PortalHostDirective
+ }]
+ }]
+ }], null, null);
+})();
+
+class PortalModule {}
+
+PortalModule.ɵfac = function PortalModule_Factory(t) {
+ return new (t || PortalModule)();
+};
+
+PortalModule.ɵmod = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineNgModule"]({
+ type: PortalModule
+});
+PortalModule.ɵinj = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjector"]({});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](PortalModule, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgModule,
+ args: [{
+ exports: [CdkPortal, CdkPortalOutlet, TemplatePortalDirective, PortalHostDirective],
+ declarations: [CdkPortal, CdkPortalOutlet, TemplatePortalDirective, PortalHostDirective]
+ }]
+ }], null, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/**
+ * Custom injector to be used when providing custom
+ * injection tokens to components inside a portal.
+ * @docs-private
+ * @deprecated Use `Injector.create` instead.
+ * @breaking-change 11.0.0
+ */
+
+
+class PortalInjector {
+ constructor(_parentInjector, _customTokens) {
+ this._parentInjector = _parentInjector;
+ this._customTokens = _customTokens;
+ }
+
+ get(token, notFoundValue) {
+ const value = this._customTokens.get(token);
+
+ if (typeof value !== 'undefined') {
+ return value;
+ }
+
+ return this._parentInjector.get(token, notFoundValue);
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+
+
+
+/***/ }),
+
+/***/ 6328:
+/*!**********************************************************!*\
+ !*** ./node_modules/@angular/cdk/fesm2020/scrolling.mjs ***!
+ \**********************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "CdkFixedSizeVirtualScroll": () => (/* binding */ CdkFixedSizeVirtualScroll),
+/* harmony export */ "CdkScrollable": () => (/* binding */ CdkScrollable),
+/* harmony export */ "CdkScrollableModule": () => (/* binding */ CdkScrollableModule),
+/* harmony export */ "CdkVirtualForOf": () => (/* binding */ CdkVirtualForOf),
+/* harmony export */ "CdkVirtualScrollViewport": () => (/* binding */ CdkVirtualScrollViewport),
+/* harmony export */ "DEFAULT_RESIZE_TIME": () => (/* binding */ DEFAULT_RESIZE_TIME),
+/* harmony export */ "DEFAULT_SCROLL_TIME": () => (/* binding */ DEFAULT_SCROLL_TIME),
+/* harmony export */ "FixedSizeVirtualScrollStrategy": () => (/* binding */ FixedSizeVirtualScrollStrategy),
+/* harmony export */ "ScrollDispatcher": () => (/* binding */ ScrollDispatcher),
+/* harmony export */ "ScrollingModule": () => (/* binding */ ScrollingModule),
+/* harmony export */ "VIRTUAL_SCROLL_STRATEGY": () => (/* binding */ VIRTUAL_SCROLL_STRATEGY),
+/* harmony export */ "ViewportRuler": () => (/* binding */ ViewportRuler),
+/* harmony export */ "_fixedSizeVirtualScrollStrategyFactory": () => (/* binding */ _fixedSizeVirtualScrollStrategyFactory)
+/* harmony export */ });
+/* harmony import */ var _angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @angular/cdk/coercion */ 8971);
+/* harmony import */ var _angular_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @angular/core */ 2560);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! rxjs */ 228);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! rxjs */ 745);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! rxjs */ 833);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! rxjs */ 3280);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! rxjs */ 8184);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! rxjs */ 9672);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! rxjs */ 6078);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(/*! rxjs */ 4437);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! rxjs/operators */ 8977);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! rxjs/operators */ 998);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! rxjs/operators */ 116);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! rxjs/operators */ 8951);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! rxjs/operators */ 4874);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! rxjs/operators */ 679);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(/*! rxjs/operators */ 2673);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(/*! rxjs/operators */ 9196);
+/* harmony import */ var _angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! @angular/cdk/platform */ 9107);
+/* harmony import */ var _angular_common__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! @angular/common */ 4666);
+/* harmony import */ var _angular_cdk_bidi__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! @angular/cdk/bidi */ 2867);
+/* harmony import */ var _angular_cdk_collections__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(/*! @angular/cdk/collections */ 1755);
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * @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.io/license
+ */
+
+/** The injection token used to specify the virtual scrolling strategy. */
+
+const _c0 = ["contentWrapper"];
+const _c1 = ["*"];
+const VIRTUAL_SCROLL_STRATEGY = new _angular_core__WEBPACK_IMPORTED_MODULE_0__.InjectionToken('VIRTUAL_SCROLL_STRATEGY');
+/**
+ * @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.io/license
+ */
+
+/** Virtual scrolling strategy for lists with items of known fixed size. */
+
+class FixedSizeVirtualScrollStrategy {
+ /**
+ * @param itemSize The size of the items in the virtually scrolling list.
+ * @param minBufferPx The minimum amount of buffer (in pixels) before needing to render more
+ * @param maxBufferPx The amount of buffer (in pixels) to render when rendering more.
+ */
+ constructor(itemSize, minBufferPx, maxBufferPx) {
+ this._scrolledIndexChange = new rxjs__WEBPACK_IMPORTED_MODULE_1__.Subject();
+ /** @docs-private Implemented as part of VirtualScrollStrategy. */
+
+ this.scrolledIndexChange = this._scrolledIndexChange.pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_2__.distinctUntilChanged)());
+ /** The attached viewport. */
+
+ this._viewport = null;
+ this._itemSize = itemSize;
+ this._minBufferPx = minBufferPx;
+ this._maxBufferPx = maxBufferPx;
+ }
+ /**
+ * Attaches this scroll strategy to a viewport.
+ * @param viewport The viewport to attach this strategy to.
+ */
+
+
+ attach(viewport) {
+ this._viewport = viewport;
+
+ this._updateTotalContentSize();
+
+ this._updateRenderedRange();
+ }
+ /** Detaches this scroll strategy from the currently attached viewport. */
+
+
+ detach() {
+ this._scrolledIndexChange.complete();
+
+ this._viewport = null;
+ }
+ /**
+ * Update the item size and buffer size.
+ * @param itemSize The size of the items in the virtually scrolling list.
+ * @param minBufferPx The minimum amount of buffer (in pixels) before needing to render more
+ * @param maxBufferPx The amount of buffer (in pixels) to render when rendering more.
+ */
+
+
+ updateItemAndBufferSize(itemSize, minBufferPx, maxBufferPx) {
+ if (maxBufferPx < minBufferPx && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+ throw Error('CDK virtual scroll: maxBufferPx must be greater than or equal to minBufferPx');
+ }
+
+ this._itemSize = itemSize;
+ this._minBufferPx = minBufferPx;
+ this._maxBufferPx = maxBufferPx;
+
+ this._updateTotalContentSize();
+
+ this._updateRenderedRange();
+ }
+ /** @docs-private Implemented as part of VirtualScrollStrategy. */
+
+
+ onContentScrolled() {
+ this._updateRenderedRange();
+ }
+ /** @docs-private Implemented as part of VirtualScrollStrategy. */
+
+
+ onDataLengthChanged() {
+ this._updateTotalContentSize();
+
+ this._updateRenderedRange();
+ }
+ /** @docs-private Implemented as part of VirtualScrollStrategy. */
+
+
+ onContentRendered() {
+ /* no-op */
+ }
+ /** @docs-private Implemented as part of VirtualScrollStrategy. */
+
+
+ onRenderedOffsetChanged() {
+ /* no-op */
+ }
+ /**
+ * Scroll to the offset for the given index.
+ * @param index The index of the element to scroll to.
+ * @param behavior The ScrollBehavior to use when scrolling.
+ */
+
+
+ scrollToIndex(index, behavior) {
+ if (this._viewport) {
+ this._viewport.scrollToOffset(index * this._itemSize, behavior);
+ }
+ }
+ /** Update the viewport's total content size. */
+
+
+ _updateTotalContentSize() {
+ if (!this._viewport) {
+ return;
+ }
+
+ this._viewport.setTotalContentSize(this._viewport.getDataLength() * this._itemSize);
+ }
+ /** Update the viewport's rendered range. */
+
+
+ _updateRenderedRange() {
+ if (!this._viewport) {
+ return;
+ }
+
+ const renderedRange = this._viewport.getRenderedRange();
+
+ const newRange = {
+ start: renderedRange.start,
+ end: renderedRange.end
+ };
+
+ const viewportSize = this._viewport.getViewportSize();
+
+ const dataLength = this._viewport.getDataLength();
+
+ let scrollOffset = this._viewport.measureScrollOffset(); // Prevent NaN as result when dividing by zero.
+
+
+ let firstVisibleIndex = this._itemSize > 0 ? scrollOffset / this._itemSize : 0; // If user scrolls to the bottom of the list and data changes to a smaller list
+
+ if (newRange.end > dataLength) {
+ // We have to recalculate the first visible index based on new data length and viewport size.
+ const maxVisibleItems = Math.ceil(viewportSize / this._itemSize);
+ const newVisibleIndex = Math.max(0, Math.min(firstVisibleIndex, dataLength - maxVisibleItems)); // If first visible index changed we must update scroll offset to handle start/end buffers
+ // Current range must also be adjusted to cover the new position (bottom of new list).
+
+ if (firstVisibleIndex != newVisibleIndex) {
+ firstVisibleIndex = newVisibleIndex;
+ scrollOffset = newVisibleIndex * this._itemSize;
+ newRange.start = Math.floor(firstVisibleIndex);
+ }
+
+ newRange.end = Math.max(0, Math.min(dataLength, newRange.start + maxVisibleItems));
+ }
+
+ const startBuffer = scrollOffset - newRange.start * this._itemSize;
+
+ if (startBuffer < this._minBufferPx && newRange.start != 0) {
+ const expandStart = Math.ceil((this._maxBufferPx - startBuffer) / this._itemSize);
+ newRange.start = Math.max(0, newRange.start - expandStart);
+ newRange.end = Math.min(dataLength, Math.ceil(firstVisibleIndex + (viewportSize + this._minBufferPx) / this._itemSize));
+ } else {
+ const endBuffer = newRange.end * this._itemSize - (scrollOffset + viewportSize);
+
+ if (endBuffer < this._minBufferPx && newRange.end != dataLength) {
+ const expandEnd = Math.ceil((this._maxBufferPx - endBuffer) / this._itemSize);
+
+ if (expandEnd > 0) {
+ newRange.end = Math.min(dataLength, newRange.end + expandEnd);
+ newRange.start = Math.max(0, Math.floor(firstVisibleIndex - this._minBufferPx / this._itemSize));
+ }
+ }
+ }
+
+ this._viewport.setRenderedRange(newRange);
+
+ this._viewport.setRenderedContentOffset(this._itemSize * newRange.start);
+
+ this._scrolledIndexChange.next(Math.floor(firstVisibleIndex));
+ }
+
+}
+/**
+ * Provider factory for `FixedSizeVirtualScrollStrategy` that simply extracts the already created
+ * `FixedSizeVirtualScrollStrategy` from the given directive.
+ * @param fixedSizeDir The instance of `CdkFixedSizeVirtualScroll` to extract the
+ * `FixedSizeVirtualScrollStrategy` from.
+ */
+
+
+function _fixedSizeVirtualScrollStrategyFactory(fixedSizeDir) {
+ return fixedSizeDir._scrollStrategy;
+}
+/** A virtual scroll strategy that supports fixed-size items. */
+
+
+class CdkFixedSizeVirtualScroll {
+ constructor() {
+ this._itemSize = 20;
+ this._minBufferPx = 100;
+ this._maxBufferPx = 200;
+ /** The scroll strategy used by this directive. */
+
+ this._scrollStrategy = new FixedSizeVirtualScrollStrategy(this.itemSize, this.minBufferPx, this.maxBufferPx);
+ }
+ /** The size of the items in the list (in pixels). */
+
+
+ get itemSize() {
+ return this._itemSize;
+ }
+
+ set itemSize(value) {
+ this._itemSize = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_3__.coerceNumberProperty)(value);
+ }
+ /**
+ * The minimum amount of buffer rendered beyond the viewport (in pixels).
+ * If the amount of buffer dips below this number, more items will be rendered. Defaults to 100px.
+ */
+
+
+ get minBufferPx() {
+ return this._minBufferPx;
+ }
+
+ set minBufferPx(value) {
+ this._minBufferPx = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_3__.coerceNumberProperty)(value);
+ }
+ /**
+ * The number of pixels worth of buffer to render for when rendering new items. Defaults to 200px.
+ */
+
+
+ get maxBufferPx() {
+ return this._maxBufferPx;
+ }
+
+ set maxBufferPx(value) {
+ this._maxBufferPx = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_3__.coerceNumberProperty)(value);
+ }
+
+ ngOnChanges() {
+ this._scrollStrategy.updateItemAndBufferSize(this.itemSize, this.minBufferPx, this.maxBufferPx);
+ }
+
+}
+
+CdkFixedSizeVirtualScroll.ɵfac = function CdkFixedSizeVirtualScroll_Factory(t) {
+ return new (t || CdkFixedSizeVirtualScroll)();
+};
+
+CdkFixedSizeVirtualScroll.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineDirective"]({
+ type: CdkFixedSizeVirtualScroll,
+ selectors: [["cdk-virtual-scroll-viewport", "itemSize", ""]],
+ inputs: {
+ itemSize: "itemSize",
+ minBufferPx: "minBufferPx",
+ maxBufferPx: "maxBufferPx"
+ },
+ features: [_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵProvidersFeature"]([{
+ provide: VIRTUAL_SCROLL_STRATEGY,
+ useFactory: _fixedSizeVirtualScrollStrategyFactory,
+ deps: [(0,_angular_core__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(() => CdkFixedSizeVirtualScroll)]
+ }]), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵNgOnChangesFeature"]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](CdkFixedSizeVirtualScroll, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Directive,
+ args: [{
+ selector: 'cdk-virtual-scroll-viewport[itemSize]',
+ providers: [{
+ provide: VIRTUAL_SCROLL_STRATEGY,
+ useFactory: _fixedSizeVirtualScrollStrategyFactory,
+ deps: [(0,_angular_core__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(() => CdkFixedSizeVirtualScroll)]
+ }]
+ }]
+ }], null, {
+ itemSize: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Input
+ }],
+ minBufferPx: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Input
+ }],
+ maxBufferPx: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Input
+ }]
+ });
+})();
+/**
+ * @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.io/license
+ */
+
+/** Time in ms to throttle the scrolling events by default. */
+
+
+const DEFAULT_SCROLL_TIME = 20;
+/**
+ * Service contained all registered Scrollable references and emits an event when any one of the
+ * Scrollable references emit a scrolled event.
+ */
+
+class ScrollDispatcher {
+ constructor(_ngZone, _platform, document) {
+ this._ngZone = _ngZone;
+ this._platform = _platform;
+ /** Subject for notifying that a registered scrollable reference element has been scrolled. */
+
+ this._scrolled = new rxjs__WEBPACK_IMPORTED_MODULE_1__.Subject();
+ /** Keeps track of the global `scroll` and `resize` subscriptions. */
+
+ this._globalSubscription = null;
+ /** Keeps track of the amount of subscriptions to `scrolled`. Used for cleaning up afterwards. */
+
+ this._scrolledCount = 0;
+ /**
+ * Map of all the scrollable references that are registered with the service and their
+ * scroll event subscriptions.
+ */
+
+ this.scrollContainers = new Map();
+ this._document = document;
+ }
+ /**
+ * Registers a scrollable instance with the service and listens for its scrolled events. When the
+ * scrollable is scrolled, the service emits the event to its scrolled observable.
+ * @param scrollable Scrollable instance to be registered.
+ */
+
+
+ register(scrollable) {
+ if (!this.scrollContainers.has(scrollable)) {
+ this.scrollContainers.set(scrollable, scrollable.elementScrolled().subscribe(() => this._scrolled.next(scrollable)));
+ }
+ }
+ /**
+ * Deregisters a Scrollable reference and unsubscribes from its scroll event observable.
+ * @param scrollable Scrollable instance to be deregistered.
+ */
+
+
+ deregister(scrollable) {
+ const scrollableReference = this.scrollContainers.get(scrollable);
+
+ if (scrollableReference) {
+ scrollableReference.unsubscribe();
+ this.scrollContainers.delete(scrollable);
+ }
+ }
+ /**
+ * Returns an observable that emits an event whenever any of the registered Scrollable
+ * references (or window, document, or body) fire a scrolled event. Can provide a time in ms
+ * to override the default "throttle" time.
+ *
+ * **Note:** in order to avoid hitting change detection for every scroll event,
+ * all of the events emitted from this stream will be run outside the Angular zone.
+ * If you need to update any data bindings as a result of a scroll event, you have
+ * to run the callback using `NgZone.run`.
+ */
+
+
+ scrolled(auditTimeInMs = DEFAULT_SCROLL_TIME) {
+ if (!this._platform.isBrowser) {
+ return (0,rxjs__WEBPACK_IMPORTED_MODULE_4__.of)();
+ }
+
+ return new rxjs__WEBPACK_IMPORTED_MODULE_5__.Observable(observer => {
+ if (!this._globalSubscription) {
+ this._addGlobalListener();
+ } // In the case of a 0ms delay, use an observable without auditTime
+ // since it does add a perceptible delay in processing overhead.
+
+
+ const subscription = auditTimeInMs > 0 ? this._scrolled.pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_6__.auditTime)(auditTimeInMs)).subscribe(observer) : this._scrolled.subscribe(observer);
+ this._scrolledCount++;
+ return () => {
+ subscription.unsubscribe();
+ this._scrolledCount--;
+
+ if (!this._scrolledCount) {
+ this._removeGlobalListener();
+ }
+ };
+ });
+ }
+
+ ngOnDestroy() {
+ this._removeGlobalListener();
+
+ this.scrollContainers.forEach((_, container) => this.deregister(container));
+
+ this._scrolled.complete();
+ }
+ /**
+ * Returns an observable that emits whenever any of the
+ * scrollable ancestors of an element are scrolled.
+ * @param elementOrElementRef Element whose ancestors to listen for.
+ * @param auditTimeInMs Time to throttle the scroll events.
+ */
+
+
+ ancestorScrolled(elementOrElementRef, auditTimeInMs) {
+ const ancestors = this.getAncestorScrollContainers(elementOrElementRef);
+ return this.scrolled(auditTimeInMs).pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_7__.filter)(target => {
+ return !target || ancestors.indexOf(target) > -1;
+ }));
+ }
+ /** Returns all registered Scrollables that contain the provided element. */
+
+
+ getAncestorScrollContainers(elementOrElementRef) {
+ const scrollingContainers = [];
+ this.scrollContainers.forEach((_subscription, scrollable) => {
+ if (this._scrollableContainsElement(scrollable, elementOrElementRef)) {
+ scrollingContainers.push(scrollable);
+ }
+ });
+ return scrollingContainers;
+ }
+ /** Use defaultView of injected document if available or fallback to global window reference */
+
+
+ _getWindow() {
+ return this._document.defaultView || window;
+ }
+ /** Returns true if the element is contained within the provided Scrollable. */
+
+
+ _scrollableContainsElement(scrollable, elementOrElementRef) {
+ let element = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_3__.coerceElement)(elementOrElementRef);
+ let scrollableElement = scrollable.getElementRef().nativeElement; // Traverse through the element parents until we reach null, checking if any of the elements
+ // are the scrollable's element.
+
+ do {
+ if (element == scrollableElement) {
+ return true;
+ }
+ } while (element = element.parentElement);
+
+ return false;
+ }
+ /** Sets up the global scroll listeners. */
+
+
+ _addGlobalListener() {
+ this._globalSubscription = this._ngZone.runOutsideAngular(() => {
+ const window = this._getWindow();
+
+ return (0,rxjs__WEBPACK_IMPORTED_MODULE_8__.fromEvent)(window.document, 'scroll').subscribe(() => this._scrolled.next());
+ });
+ }
+ /** Cleans up the global scroll listener. */
+
+
+ _removeGlobalListener() {
+ if (this._globalSubscription) {
+ this._globalSubscription.unsubscribe();
+
+ this._globalSubscription = null;
+ }
+ }
+
+}
+
+ScrollDispatcher.ɵfac = function ScrollDispatcher_Factory(t) {
+ return new (t || ScrollDispatcher)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.Platform), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_common__WEBPACK_IMPORTED_MODULE_10__.DOCUMENT, 8));
+};
+
+ScrollDispatcher.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjectable"]({
+ token: ScrollDispatcher,
+ factory: ScrollDispatcher.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](ScrollDispatcher, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone
+ }, {
+ type: _angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.Platform
+ }, {
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Optional
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_10__.DOCUMENT]
+ }]
+ }];
+ }, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/**
+ * Sends an event when the directive's element is scrolled. Registers itself with the
+ * ScrollDispatcher service to include itself as part of its collection of scrolling events that it
+ * can be listened to through the service.
+ */
+
+
+class CdkScrollable {
+ constructor(elementRef, scrollDispatcher, ngZone, dir) {
+ this.elementRef = elementRef;
+ this.scrollDispatcher = scrollDispatcher;
+ this.ngZone = ngZone;
+ this.dir = dir;
+ this._destroyed = new rxjs__WEBPACK_IMPORTED_MODULE_1__.Subject();
+ this._elementScrolled = new rxjs__WEBPACK_IMPORTED_MODULE_5__.Observable(observer => this.ngZone.runOutsideAngular(() => (0,rxjs__WEBPACK_IMPORTED_MODULE_8__.fromEvent)(this.elementRef.nativeElement, 'scroll').pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_11__.takeUntil)(this._destroyed)).subscribe(observer)));
+ }
+
+ ngOnInit() {
+ this.scrollDispatcher.register(this);
+ }
+
+ ngOnDestroy() {
+ this.scrollDispatcher.deregister(this);
+
+ this._destroyed.next();
+
+ this._destroyed.complete();
+ }
+ /** Returns observable that emits when a scroll event is fired on the host element. */
+
+
+ elementScrolled() {
+ return this._elementScrolled;
+ }
+ /** Gets the ElementRef for the viewport. */
+
+
+ getElementRef() {
+ return this.elementRef;
+ }
+ /**
+ * Scrolls to the specified offsets. This is a normalized version of the browser's native scrollTo
+ * method, since browsers are not consistent about what scrollLeft means in RTL. For this method
+ * left and right always refer to the left and right side of the scrolling container irrespective
+ * of the layout direction. start and end refer to left and right in an LTR context and vice-versa
+ * in an RTL context.
+ * @param options specified the offsets to scroll to.
+ */
+
+
+ scrollTo(options) {
+ const el = this.elementRef.nativeElement;
+ const isRtl = this.dir && this.dir.value == 'rtl'; // Rewrite start & end offsets as right or left offsets.
+
+ if (options.left == null) {
+ options.left = isRtl ? options.end : options.start;
+ }
+
+ if (options.right == null) {
+ options.right = isRtl ? options.start : options.end;
+ } // Rewrite the bottom offset as a top offset.
+
+
+ if (options.bottom != null) {
+ options.top = el.scrollHeight - el.clientHeight - options.bottom;
+ } // Rewrite the right offset as a left offset.
+
+
+ if (isRtl && (0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.getRtlScrollAxisType)() != 0
+ /* NORMAL */
+ ) {
+ if (options.left != null) {
+ options.right = el.scrollWidth - el.clientWidth - options.left;
+ }
+
+ if ((0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.getRtlScrollAxisType)() == 2
+ /* INVERTED */
+ ) {
+ options.left = options.right;
+ } else if ((0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.getRtlScrollAxisType)() == 1
+ /* NEGATED */
+ ) {
+ options.left = options.right ? -options.right : options.right;
+ }
+ } else {
+ if (options.right != null) {
+ options.left = el.scrollWidth - el.clientWidth - options.right;
+ }
+ }
+
+ this._applyScrollToOptions(options);
+ }
+
+ _applyScrollToOptions(options) {
+ const el = this.elementRef.nativeElement;
+
+ if ((0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.supportsScrollBehavior)()) {
+ el.scrollTo(options);
+ } else {
+ if (options.top != null) {
+ el.scrollTop = options.top;
+ }
+
+ if (options.left != null) {
+ el.scrollLeft = options.left;
+ }
+ }
+ }
+ /**
+ * Measures the scroll offset relative to the specified edge of the viewport. This method can be
+ * used instead of directly checking scrollLeft or scrollTop, since browsers are not consistent
+ * about what scrollLeft means in RTL. The values returned by this method are normalized such that
+ * left and right always refer to the left and right side of the scrolling container irrespective
+ * of the layout direction. start and end refer to left and right in an LTR context and vice-versa
+ * in an RTL context.
+ * @param from The edge to measure from.
+ */
+
+
+ measureScrollOffset(from) {
+ const LEFT = 'left';
+ const RIGHT = 'right';
+ const el = this.elementRef.nativeElement;
+
+ if (from == 'top') {
+ return el.scrollTop;
+ }
+
+ if (from == 'bottom') {
+ return el.scrollHeight - el.clientHeight - el.scrollTop;
+ } // Rewrite start & end as left or right offsets.
+
+
+ const isRtl = this.dir && this.dir.value == 'rtl';
+
+ if (from == 'start') {
+ from = isRtl ? RIGHT : LEFT;
+ } else if (from == 'end') {
+ from = isRtl ? LEFT : RIGHT;
+ }
+
+ if (isRtl && (0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.getRtlScrollAxisType)() == 2
+ /* INVERTED */
+ ) {
+ // For INVERTED, scrollLeft is (scrollWidth - clientWidth) when scrolled all the way left and
+ // 0 when scrolled all the way right.
+ if (from == LEFT) {
+ return el.scrollWidth - el.clientWidth - el.scrollLeft;
+ } else {
+ return el.scrollLeft;
+ }
+ } else if (isRtl && (0,_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.getRtlScrollAxisType)() == 1
+ /* NEGATED */
+ ) {
+ // For NEGATED, scrollLeft is -(scrollWidth - clientWidth) when scrolled all the way left and
+ // 0 when scrolled all the way right.
+ if (from == LEFT) {
+ return el.scrollLeft + el.scrollWidth - el.clientWidth;
+ } else {
+ return -el.scrollLeft;
+ }
+ } else {
+ // For NORMAL, as well as non-RTL contexts, scrollLeft is 0 when scrolled all the way left and
+ // (scrollWidth - clientWidth) when scrolled all the way right.
+ if (from == LEFT) {
+ return el.scrollLeft;
+ } else {
+ return el.scrollWidth - el.clientWidth - el.scrollLeft;
+ }
+ }
+ }
+
+}
+
+CdkScrollable.ɵfac = function CdkScrollable_Factory(t) {
+ return new (t || CdkScrollable)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.ElementRef), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](ScrollDispatcher), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_cdk_bidi__WEBPACK_IMPORTED_MODULE_12__.Directionality, 8));
+};
+
+CdkScrollable.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineDirective"]({
+ type: CdkScrollable,
+ selectors: [["", "cdk-scrollable", ""], ["", "cdkScrollable", ""]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](CdkScrollable, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Directive,
+ args: [{
+ selector: '[cdk-scrollable], [cdkScrollable]'
+ }]
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.ElementRef
+ }, {
+ type: ScrollDispatcher
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone
+ }, {
+ type: _angular_cdk_bidi__WEBPACK_IMPORTED_MODULE_12__.Directionality,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Optional
+ }]
+ }];
+ }, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/** Time in ms to throttle the resize events by default. */
+
+
+const DEFAULT_RESIZE_TIME = 20;
+/**
+ * Simple utility for getting the bounds of the browser viewport.
+ * @docs-private
+ */
+
+class ViewportRuler {
+ constructor(_platform, ngZone, document) {
+ this._platform = _platform;
+ /** Stream of viewport change events. */
+
+ this._change = new rxjs__WEBPACK_IMPORTED_MODULE_1__.Subject();
+ /** Event listener that will be used to handle the viewport change events. */
+
+ this._changeListener = event => {
+ this._change.next(event);
+ };
+
+ this._document = document;
+ ngZone.runOutsideAngular(() => {
+ if (_platform.isBrowser) {
+ const window = this._getWindow(); // Note that bind the events ourselves, rather than going through something like RxJS's
+ // `fromEvent` so that we can ensure that they're bound outside of the NgZone.
+
+
+ window.addEventListener('resize', this._changeListener);
+ window.addEventListener('orientationchange', this._changeListener);
+ } // Clear the cached position so that the viewport is re-measured next time it is required.
+ // We don't need to keep track of the subscription, because it is completed on destroy.
+
+
+ this.change().subscribe(() => this._viewportSize = null);
+ });
+ }
+
+ ngOnDestroy() {
+ if (this._platform.isBrowser) {
+ const window = this._getWindow();
+
+ window.removeEventListener('resize', this._changeListener);
+ window.removeEventListener('orientationchange', this._changeListener);
+ }
+
+ this._change.complete();
+ }
+ /** Returns the viewport's width and height. */
+
+
+ getViewportSize() {
+ if (!this._viewportSize) {
+ this._updateViewportSize();
+ }
+
+ const output = {
+ width: this._viewportSize.width,
+ height: this._viewportSize.height
+ }; // If we're not on a browser, don't cache the size since it'll be mocked out anyway.
+
+ if (!this._platform.isBrowser) {
+ this._viewportSize = null;
+ }
+
+ return output;
+ }
+ /** Gets a ClientRect for the viewport's bounds. */
+
+
+ getViewportRect() {
+ // Use the document element's bounding rect rather than the window scroll properties
+ // (e.g. pageYOffset, scrollY) due to in issue in Chrome and IE where window scroll
+ // properties and client coordinates (boundingClientRect, clientX/Y, etc.) are in different
+ // conceptual viewports. Under most circumstances these viewports are equivalent, but they
+ // can disagree when the page is pinch-zoomed (on devices that support touch).
+ // See https://bugs.chromium.org/p/chromium/issues/detail?id=489206#c4
+ // We use the documentElement instead of the body because, by default (without a css reset)
+ // browsers typically give the document body an 8px margin, which is not included in
+ // getBoundingClientRect().
+ const scrollPosition = this.getViewportScrollPosition();
+ const {
+ width,
+ height
+ } = this.getViewportSize();
+ return {
+ top: scrollPosition.top,
+ left: scrollPosition.left,
+ bottom: scrollPosition.top + height,
+ right: scrollPosition.left + width,
+ height,
+ width
+ };
+ }
+ /** Gets the (top, left) scroll position of the viewport. */
+
+
+ getViewportScrollPosition() {
+ // While we can get a reference to the fake document
+ // during SSR, it doesn't have getBoundingClientRect.
+ if (!this._platform.isBrowser) {
+ return {
+ top: 0,
+ left: 0
+ };
+ } // The top-left-corner of the viewport is determined by the scroll position of the document
+ // body, normally just (scrollLeft, scrollTop). However, Chrome and Firefox disagree about
+ // whether `document.body` or `document.documentElement` is the scrolled element, so reading
+ // `scrollTop` and `scrollLeft` is inconsistent. However, using the bounding rect of
+ // `document.documentElement` works consistently, where the `top` and `left` values will
+ // equal negative the scroll position.
+
+
+ const document = this._document;
+
+ const window = this._getWindow();
+
+ const documentElement = document.documentElement;
+ const documentRect = documentElement.getBoundingClientRect();
+ const top = -documentRect.top || document.body.scrollTop || window.scrollY || documentElement.scrollTop || 0;
+ const left = -documentRect.left || document.body.scrollLeft || window.scrollX || documentElement.scrollLeft || 0;
+ return {
+ top,
+ left
+ };
+ }
+ /**
+ * Returns a stream that emits whenever the size of the viewport changes.
+ * This stream emits outside of the Angular zone.
+ * @param throttleTime Time in milliseconds to throttle the stream.
+ */
+
+
+ change(throttleTime = DEFAULT_RESIZE_TIME) {
+ return throttleTime > 0 ? this._change.pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_6__.auditTime)(throttleTime)) : this._change;
+ }
+ /** Use defaultView of injected document if available or fallback to global window reference */
+
+
+ _getWindow() {
+ return this._document.defaultView || window;
+ }
+ /** Updates the cached viewport size. */
+
+
+ _updateViewportSize() {
+ const window = this._getWindow();
+
+ this._viewportSize = this._platform.isBrowser ? {
+ width: window.innerWidth,
+ height: window.innerHeight
+ } : {
+ width: 0,
+ height: 0
+ };
+ }
+
+}
+
+ViewportRuler.ɵfac = function ViewportRuler_Factory(t) {
+ return new (t || ViewportRuler)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.Platform), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵinject"](_angular_common__WEBPACK_IMPORTED_MODULE_10__.DOCUMENT, 8));
+};
+
+ViewportRuler.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjectable"]({
+ token: ViewportRuler,
+ factory: ViewportRuler.ɵfac,
+ providedIn: 'root'
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](ViewportRuler, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Injectable,
+ args: [{
+ providedIn: 'root'
+ }]
+ }], function () {
+ return [{
+ type: _angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.Platform
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone
+ }, {
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Optional
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [_angular_common__WEBPACK_IMPORTED_MODULE_10__.DOCUMENT]
+ }]
+ }];
+ }, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/** Checks if the given ranges are equal. */
+
+
+function rangesEqual(r1, r2) {
+ return r1.start == r2.start && r1.end == r2.end;
+}
+/**
+ * Scheduler to be used for scroll events. Needs to fall back to
+ * something that doesn't rely on requestAnimationFrame on environments
+ * that don't support it (e.g. server-side rendering).
+ */
+
+
+const SCROLL_SCHEDULER = typeof requestAnimationFrame !== 'undefined' ? rxjs__WEBPACK_IMPORTED_MODULE_13__.animationFrameScheduler : rxjs__WEBPACK_IMPORTED_MODULE_14__.asapScheduler;
+/** A viewport that virtualizes its scrolling with the help of `CdkVirtualForOf`. */
+
+class CdkVirtualScrollViewport extends CdkScrollable {
+ constructor(elementRef, _changeDetectorRef, ngZone, _scrollStrategy, dir, scrollDispatcher, viewportRuler) {
+ super(elementRef, scrollDispatcher, ngZone, dir);
+ this.elementRef = elementRef;
+ this._changeDetectorRef = _changeDetectorRef;
+ this._scrollStrategy = _scrollStrategy;
+ /** Emits when the viewport is detached from a CdkVirtualForOf. */
+
+ this._detachedSubject = new rxjs__WEBPACK_IMPORTED_MODULE_1__.Subject();
+ /** Emits when the rendered range changes. */
+
+ this._renderedRangeSubject = new rxjs__WEBPACK_IMPORTED_MODULE_1__.Subject();
+ this._orientation = 'vertical';
+ this._appendOnly = false; // Note: we don't use the typical EventEmitter here because we need to subscribe to the scroll
+ // strategy lazily (i.e. only if the user is actually listening to the events). We do this because
+ // depending on how the strategy calculates the scrolled index, it may come at a cost to
+ // performance.
+
+ /** Emits when the index of the first element visible in the viewport changes. */
+
+ this.scrolledIndexChange = new rxjs__WEBPACK_IMPORTED_MODULE_5__.Observable(observer => this._scrollStrategy.scrolledIndexChange.subscribe(index => Promise.resolve().then(() => this.ngZone.run(() => observer.next(index)))));
+ /** A stream that emits whenever the rendered range changes. */
+
+ this.renderedRangeStream = this._renderedRangeSubject;
+ /**
+ * The total size of all content (in pixels), including content that is not currently rendered.
+ */
+
+ this._totalContentSize = 0;
+ /** A string representing the `style.width` property value to be used for the spacer element. */
+
+ this._totalContentWidth = '';
+ /** A string representing the `style.height` property value to be used for the spacer element. */
+
+ this._totalContentHeight = '';
+ /** The currently rendered range of indices. */
+
+ this._renderedRange = {
+ start: 0,
+ end: 0
+ };
+ /** The length of the data bound to this viewport (in number of items). */
+
+ this._dataLength = 0;
+ /** The size of the viewport (in pixels). */
+
+ this._viewportSize = 0;
+ /** The last rendered content offset that was set. */
+
+ this._renderedContentOffset = 0;
+ /**
+ * Whether the last rendered content offset was to the end of the content (and therefore needs to
+ * be rewritten as an offset to the start of the content).
+ */
+
+ this._renderedContentOffsetNeedsRewrite = false;
+ /** Whether there is a pending change detection cycle. */
+
+ this._isChangeDetectionPending = false;
+ /** A list of functions to run after the next change detection cycle. */
+
+ this._runAfterChangeDetection = [];
+ /** Subscription to changes in the viewport size. */
+
+ this._viewportChanges = rxjs__WEBPACK_IMPORTED_MODULE_15__.Subscription.EMPTY;
+
+ if (!_scrollStrategy && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+ throw Error('Error: cdk-virtual-scroll-viewport requires the "itemSize" property to be set.');
+ }
+
+ this._viewportChanges = viewportRuler.change().subscribe(() => {
+ this.checkViewportSize();
+ });
+ }
+ /** The direction the viewport scrolls. */
+
+
+ get orientation() {
+ return this._orientation;
+ }
+
+ set orientation(orientation) {
+ if (this._orientation !== orientation) {
+ this._orientation = orientation;
+
+ this._calculateSpacerSize();
+ }
+ }
+ /**
+ * Whether rendered items should persist in the DOM after scrolling out of view. By default, items
+ * will be removed.
+ */
+
+
+ get appendOnly() {
+ return this._appendOnly;
+ }
+
+ set appendOnly(value) {
+ this._appendOnly = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_3__.coerceBooleanProperty)(value);
+ }
+
+ ngOnInit() {
+ super.ngOnInit(); // It's still too early to measure the viewport at this point. Deferring with a promise allows
+ // the Viewport to be rendered with the correct size before we measure. We run this outside the
+ // zone to avoid causing more change detection cycles. We handle the change detection loop
+ // ourselves instead.
+
+ this.ngZone.runOutsideAngular(() => Promise.resolve().then(() => {
+ this._measureViewportSize();
+
+ this._scrollStrategy.attach(this);
+
+ this.elementScrolled().pipe( // Start off with a fake scroll event so we properly detect our initial position.
+ (0,rxjs_operators__WEBPACK_IMPORTED_MODULE_16__.startWith)(null), // Collect multiple events into one until the next animation frame. This way if
+ // there are multiple scroll events in the same frame we only need to recheck
+ // our layout once.
+ (0,rxjs_operators__WEBPACK_IMPORTED_MODULE_6__.auditTime)(0, SCROLL_SCHEDULER)).subscribe(() => this._scrollStrategy.onContentScrolled());
+
+ this._markChangeDetectionNeeded();
+ }));
+ }
+
+ ngOnDestroy() {
+ this.detach();
+
+ this._scrollStrategy.detach(); // Complete all subjects
+
+
+ this._renderedRangeSubject.complete();
+
+ this._detachedSubject.complete();
+
+ this._viewportChanges.unsubscribe();
+
+ super.ngOnDestroy();
+ }
+ /** Attaches a `CdkVirtualScrollRepeater` to this viewport. */
+
+
+ attach(forOf) {
+ if (this._forOf && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+ throw Error('CdkVirtualScrollViewport is already attached.');
+ } // Subscribe to the data stream of the CdkVirtualForOf to keep track of when the data length
+ // changes. Run outside the zone to avoid triggering change detection, since we're managing the
+ // change detection loop ourselves.
+
+
+ this.ngZone.runOutsideAngular(() => {
+ this._forOf = forOf;
+
+ this._forOf.dataStream.pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_11__.takeUntil)(this._detachedSubject)).subscribe(data => {
+ const newLength = data.length;
+
+ if (newLength !== this._dataLength) {
+ this._dataLength = newLength;
+
+ this._scrollStrategy.onDataLengthChanged();
+ }
+
+ this._doChangeDetection();
+ });
+ });
+ }
+ /** Detaches the current `CdkVirtualForOf`. */
+
+
+ detach() {
+ this._forOf = null;
+
+ this._detachedSubject.next();
+ }
+ /** Gets the length of the data bound to this viewport (in number of items). */
+
+
+ getDataLength() {
+ return this._dataLength;
+ }
+ /** Gets the size of the viewport (in pixels). */
+
+
+ getViewportSize() {
+ return this._viewportSize;
+ } // TODO(mmalerba): This is technically out of sync with what's really rendered until a render
+ // cycle happens. I'm being careful to only call it after the render cycle is complete and before
+ // setting it to something else, but its error prone and should probably be split into
+ // `pendingRange` and `renderedRange`, the latter reflecting whats actually in the DOM.
+
+ /** Get the current rendered range of items. */
+
+
+ getRenderedRange() {
+ return this._renderedRange;
+ }
+ /**
+ * Sets the total size of all content (in pixels), including content that is not currently
+ * rendered.
+ */
+
+
+ setTotalContentSize(size) {
+ if (this._totalContentSize !== size) {
+ this._totalContentSize = size;
+
+ this._calculateSpacerSize();
+
+ this._markChangeDetectionNeeded();
+ }
+ }
+ /** Sets the currently rendered range of indices. */
+
+
+ setRenderedRange(range) {
+ if (!rangesEqual(this._renderedRange, range)) {
+ if (this.appendOnly) {
+ range = {
+ start: 0,
+ end: Math.max(this._renderedRange.end, range.end)
+ };
+ }
+
+ this._renderedRangeSubject.next(this._renderedRange = range);
+
+ this._markChangeDetectionNeeded(() => this._scrollStrategy.onContentRendered());
+ }
+ }
+ /**
+ * Gets the offset from the start of the viewport to the start of the rendered data (in pixels).
+ */
+
+
+ getOffsetToRenderedContentStart() {
+ return this._renderedContentOffsetNeedsRewrite ? null : this._renderedContentOffset;
+ }
+ /**
+ * Sets the offset from the start of the viewport to either the start or end of the rendered data
+ * (in pixels).
+ */
+
+
+ setRenderedContentOffset(offset, to = 'to-start') {
+ // For a horizontal viewport in a right-to-left language we need to translate along the x-axis
+ // in the negative direction.
+ const isRtl = this.dir && this.dir.value == 'rtl';
+ const isHorizontal = this.orientation == 'horizontal';
+ const axis = isHorizontal ? 'X' : 'Y';
+ const axisDirection = isHorizontal && isRtl ? -1 : 1;
+ let transform = `translate${axis}(${Number(axisDirection * offset)}px)`;
+ this._renderedContentOffset = offset;
+
+ if (to === 'to-end') {
+ transform += ` translate${axis}(-100%)`; // The viewport should rewrite this as a `to-start` offset on the next render cycle. Otherwise
+ // elements will appear to expand in the wrong direction (e.g. `mat-expansion-panel` would
+ // expand upward).
+
+ this._renderedContentOffsetNeedsRewrite = true;
+ }
+
+ if (this._renderedContentTransform != transform) {
+ // We know this value is safe because we parse `offset` with `Number()` before passing it
+ // into the string.
+ this._renderedContentTransform = transform;
+
+ this._markChangeDetectionNeeded(() => {
+ if (this._renderedContentOffsetNeedsRewrite) {
+ this._renderedContentOffset -= this.measureRenderedContentSize();
+ this._renderedContentOffsetNeedsRewrite = false;
+ this.setRenderedContentOffset(this._renderedContentOffset);
+ } else {
+ this._scrollStrategy.onRenderedOffsetChanged();
+ }
+ });
+ }
+ }
+ /**
+ * Scrolls to the given offset from the start of the viewport. Please note that this is not always
+ * the same as setting `scrollTop` or `scrollLeft`. In a horizontal viewport with right-to-left
+ * direction, this would be the equivalent of setting a fictional `scrollRight` property.
+ * @param offset The offset to scroll to.
+ * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.
+ */
+
+
+ scrollToOffset(offset, behavior = 'auto') {
+ const options = {
+ behavior
+ };
+
+ if (this.orientation === 'horizontal') {
+ options.start = offset;
+ } else {
+ options.top = offset;
+ }
+
+ this.scrollTo(options);
+ }
+ /**
+ * Scrolls to the offset for the given index.
+ * @param index The index of the element to scroll to.
+ * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.
+ */
+
+
+ scrollToIndex(index, behavior = 'auto') {
+ this._scrollStrategy.scrollToIndex(index, behavior);
+ }
+ /**
+ * Gets the current scroll offset from the start of the viewport (in pixels).
+ * @param from The edge to measure the offset from. Defaults to 'top' in vertical mode and 'start'
+ * in horizontal mode.
+ */
+
+
+ measureScrollOffset(from) {
+ return from ? super.measureScrollOffset(from) : super.measureScrollOffset(this.orientation === 'horizontal' ? 'start' : 'top');
+ }
+ /** Measure the combined size of all of the rendered items. */
+
+
+ measureRenderedContentSize() {
+ const contentEl = this._contentWrapper.nativeElement;
+ return this.orientation === 'horizontal' ? contentEl.offsetWidth : contentEl.offsetHeight;
+ }
+ /**
+ * Measure the total combined size of the given range. Throws if the range includes items that are
+ * not rendered.
+ */
+
+
+ measureRangeSize(range) {
+ if (!this._forOf) {
+ return 0;
+ }
+
+ return this._forOf.measureRangeSize(range, this.orientation);
+ }
+ /** Update the viewport dimensions and re-render. */
+
+
+ checkViewportSize() {
+ // TODO: Cleanup later when add logic for handling content resize
+ this._measureViewportSize();
+
+ this._scrollStrategy.onDataLengthChanged();
+ }
+ /** Measure the viewport size. */
+
+
+ _measureViewportSize() {
+ const viewportEl = this.elementRef.nativeElement;
+ this._viewportSize = this.orientation === 'horizontal' ? viewportEl.clientWidth : viewportEl.clientHeight;
+ }
+ /** Queue up change detection to run. */
+
+
+ _markChangeDetectionNeeded(runAfter) {
+ if (runAfter) {
+ this._runAfterChangeDetection.push(runAfter);
+ } // Use a Promise to batch together calls to `_doChangeDetection`. This way if we set a bunch of
+ // properties sequentially we only have to run `_doChangeDetection` once at the end.
+
+
+ if (!this._isChangeDetectionPending) {
+ this._isChangeDetectionPending = true;
+ this.ngZone.runOutsideAngular(() => Promise.resolve().then(() => {
+ this._doChangeDetection();
+ }));
+ }
+ }
+ /** Run change detection. */
+
+
+ _doChangeDetection() {
+ this._isChangeDetectionPending = false; // Apply the content transform. The transform can't be set via an Angular binding because
+ // bypassSecurityTrustStyle is banned in Google. However the value is safe, it's composed of
+ // string literals, a variable that can only be 'X' or 'Y', and user input that is run through
+ // the `Number` function first to coerce it to a numeric value.
+
+ this._contentWrapper.nativeElement.style.transform = this._renderedContentTransform; // Apply changes to Angular bindings. Note: We must call `markForCheck` to run change detection
+ // from the root, since the repeated items are content projected in. Calling `detectChanges`
+ // instead does not properly check the projected content.
+
+ this.ngZone.run(() => this._changeDetectorRef.markForCheck());
+ const runAfterChangeDetection = this._runAfterChangeDetection;
+ this._runAfterChangeDetection = [];
+
+ for (const fn of runAfterChangeDetection) {
+ fn();
+ }
+ }
+ /** Calculates the `style.width` and `style.height` for the spacer element. */
+
+
+ _calculateSpacerSize() {
+ this._totalContentHeight = this.orientation === 'horizontal' ? '' : `${this._totalContentSize}px`;
+ this._totalContentWidth = this.orientation === 'horizontal' ? `${this._totalContentSize}px` : '';
+ }
+
+}
+
+CdkVirtualScrollViewport.ɵfac = function CdkVirtualScrollViewport_Factory(t) {
+ return new (t || CdkVirtualScrollViewport)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.ElementRef), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.ChangeDetectorRef), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](VIRTUAL_SCROLL_STRATEGY, 8), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_cdk_bidi__WEBPACK_IMPORTED_MODULE_12__.Directionality, 8), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](ScrollDispatcher), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](ViewportRuler));
+};
+
+CdkVirtualScrollViewport.ɵcmp = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineComponent"]({
+ type: CdkVirtualScrollViewport,
+ selectors: [["cdk-virtual-scroll-viewport"]],
+ viewQuery: function CdkVirtualScrollViewport_Query(rf, ctx) {
+ if (rf & 1) {
+ _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵviewQuery"](_c0, 7);
+ }
+
+ if (rf & 2) {
+ let _t;
+
+ _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵqueryRefresh"](_t = _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵloadQuery"]()) && (ctx._contentWrapper = _t.first);
+ }
+ },
+ hostAttrs: [1, "cdk-virtual-scroll-viewport"],
+ hostVars: 4,
+ hostBindings: function CdkVirtualScrollViewport_HostBindings(rf, ctx) {
+ if (rf & 2) {
+ _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵclassProp"]("cdk-virtual-scroll-orientation-horizontal", ctx.orientation === "horizontal")("cdk-virtual-scroll-orientation-vertical", ctx.orientation !== "horizontal");
+ }
+ },
+ inputs: {
+ orientation: "orientation",
+ appendOnly: "appendOnly"
+ },
+ outputs: {
+ scrolledIndexChange: "scrolledIndexChange"
+ },
+ features: [_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵProvidersFeature"]([{
+ provide: CdkScrollable,
+ useExisting: CdkVirtualScrollViewport
+ }]), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵInheritDefinitionFeature"]],
+ ngContentSelectors: _c1,
+ decls: 4,
+ vars: 4,
+ consts: [[1, "cdk-virtual-scroll-content-wrapper"], ["contentWrapper", ""], [1, "cdk-virtual-scroll-spacer"]],
+ template: function CdkVirtualScrollViewport_Template(rf, ctx) {
+ if (rf & 1) {
+ _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵprojectionDef"]();
+ _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵelementStart"](0, "div", 0, 1);
+ _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵprojection"](2);
+ _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵelementEnd"]();
+ _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵelement"](3, "div", 2);
+ }
+
+ if (rf & 2) {
+ _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵadvance"](3);
+ _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵstyleProp"]("width", ctx._totalContentWidth)("height", ctx._totalContentHeight);
+ }
+ },
+ styles: ["cdk-virtual-scroll-viewport{display:block;position:relative;overflow:auto;contain:strict;transform:translateZ(0);will-change:scroll-position;-webkit-overflow-scrolling:touch}.cdk-virtual-scroll-content-wrapper{position:absolute;top:0;left:0;contain:content}[dir=rtl] .cdk-virtual-scroll-content-wrapper{right:0;left:auto}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper{min-height:100%}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-left:0;padding-right:0;margin-left:0;margin-right:0;border-left-width:0;border-right-width:0;outline:none}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper{min-width:100%}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-top:0;padding-bottom:0;margin-top:0;margin-bottom:0;border-top-width:0;border-bottom-width:0;outline:none}.cdk-virtual-scroll-spacer{position:absolute;top:0;left:0;height:1px;width:1px;transform-origin:0 0}[dir=rtl] .cdk-virtual-scroll-spacer{right:0;left:auto;transform-origin:100% 0}\n"],
+ encapsulation: 2,
+ changeDetection: 0
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](CdkVirtualScrollViewport, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Component,
+ args: [{
+ selector: 'cdk-virtual-scroll-viewport',
+ host: {
+ 'class': 'cdk-virtual-scroll-viewport',
+ '[class.cdk-virtual-scroll-orientation-horizontal]': 'orientation === "horizontal"',
+ '[class.cdk-virtual-scroll-orientation-vertical]': 'orientation !== "horizontal"'
+ },
+ encapsulation: _angular_core__WEBPACK_IMPORTED_MODULE_0__.ViewEncapsulation.None,
+ changeDetection: _angular_core__WEBPACK_IMPORTED_MODULE_0__.ChangeDetectionStrategy.OnPush,
+ providers: [{
+ provide: CdkScrollable,
+ useExisting: CdkVirtualScrollViewport
+ }],
+ template: "\n` element.
+ * @param _stickCellCss The CSS class that will be applied to every row/cell that has
+ * sticky positioning applied.
+ * @param direction The directionality context of the table (ltr/rtl); affects column positioning
+ * by reversing left/right positions.
+ * @param _isBrowser Whether the table is currently being rendered on the server or the client.
+ * @param _needsPositionStickyOnElement Whether we need to specify position: sticky on cells
+ * using inline styles. If false, it is assumed that position: sticky is included in
+ * the component stylesheet for _stickCellCss.
+ * @param _positionListener A listener that is notified of changes to sticky rows/columns
+ * and their dimensions.
+ */
+ constructor(_isNativeHtmlTable, _stickCellCss, direction, _coalescedStyleScheduler, _isBrowser = true, _needsPositionStickyOnElement = true, _positionListener) {
+ this._isNativeHtmlTable = _isNativeHtmlTable;
+ this._stickCellCss = _stickCellCss;
+ this.direction = direction;
+ this._coalescedStyleScheduler = _coalescedStyleScheduler;
+ this._isBrowser = _isBrowser;
+ this._needsPositionStickyOnElement = _needsPositionStickyOnElement;
+ this._positionListener = _positionListener;
+ this._cachedCellWidths = [];
+ this._borderCellCss = {
+ 'top': `${_stickCellCss}-border-elem-top`,
+ 'bottom': `${_stickCellCss}-border-elem-bottom`,
+ 'left': `${_stickCellCss}-border-elem-left`,
+ 'right': `${_stickCellCss}-border-elem-right`
+ };
+ }
+ /**
+ * Clears the sticky positioning styles from the row and its cells by resetting the `position`
+ * style, setting the zIndex to 0, and unsetting each provided sticky direction.
+ * @param rows The list of rows that should be cleared from sticking in the provided directions
+ * @param stickyDirections The directions that should no longer be set as sticky on the rows.
+ */
+
+
+ clearStickyPositioning(rows, stickyDirections) {
+ const elementsToClear = [];
+
+ for (const row of rows) {
+ // If the row isn't an element (e.g. if it's an `ng-container`),
+ // it won't have inline styles or `children` so we skip it.
+ if (row.nodeType !== row.ELEMENT_NODE) {
+ continue;
+ }
+
+ elementsToClear.push(row);
+
+ for (let i = 0; i < row.children.length; i++) {
+ elementsToClear.push(row.children[i]);
+ }
+ } // Coalesce with sticky row/column updates (and potentially other changes like column resize).
+
+
+ this._coalescedStyleScheduler.schedule(() => {
+ for (const element of elementsToClear) {
+ this._removeStickyStyle(element, stickyDirections);
+ }
+ });
+ }
+ /**
+ * Applies sticky left and right positions to the cells of each row according to the sticky
+ * states of the rendered column definitions.
+ * @param rows The rows that should have its set of cells stuck according to the sticky states.
+ * @param stickyStartStates A list of boolean states where each state represents whether the cell
+ * in this index position should be stuck to the start of the row.
+ * @param stickyEndStates A list of boolean states where each state represents whether the cell
+ * in this index position should be stuck to the end of the row.
+ * @param recalculateCellWidths Whether the sticky styler should recalculate the width of each
+ * column cell. If `false` cached widths will be used instead.
+ */
+
+
+ updateStickyColumns(rows, stickyStartStates, stickyEndStates, recalculateCellWidths = true) {
+ if (!rows.length || !this._isBrowser || !(stickyStartStates.some(state => state) || stickyEndStates.some(state => state))) {
+ if (this._positionListener) {
+ this._positionListener.stickyColumnsUpdated({
+ sizes: []
+ });
+
+ this._positionListener.stickyEndColumnsUpdated({
+ sizes: []
+ });
+ }
+
+ return;
+ }
+
+ const firstRow = rows[0];
+ const numCells = firstRow.children.length;
+
+ const cellWidths = this._getCellWidths(firstRow, recalculateCellWidths);
+
+ const startPositions = this._getStickyStartColumnPositions(cellWidths, stickyStartStates);
+
+ const endPositions = this._getStickyEndColumnPositions(cellWidths, stickyEndStates);
+
+ const lastStickyStart = stickyStartStates.lastIndexOf(true);
+ const firstStickyEnd = stickyEndStates.indexOf(true); // Coalesce with sticky row updates (and potentially other changes like column resize).
+
+ this._coalescedStyleScheduler.schedule(() => {
+ const isRtl = this.direction === 'rtl';
+ const start = isRtl ? 'right' : 'left';
+ const end = isRtl ? 'left' : 'right';
+
+ for (const row of rows) {
+ for (let i = 0; i < numCells; i++) {
+ const cell = row.children[i];
+
+ if (stickyStartStates[i]) {
+ this._addStickyStyle(cell, start, startPositions[i], i === lastStickyStart);
+ }
+
+ if (stickyEndStates[i]) {
+ this._addStickyStyle(cell, end, endPositions[i], i === firstStickyEnd);
+ }
+ }
+ }
+
+ if (this._positionListener) {
+ this._positionListener.stickyColumnsUpdated({
+ sizes: lastStickyStart === -1 ? [] : cellWidths.slice(0, lastStickyStart + 1).map((width, index) => stickyStartStates[index] ? width : null)
+ });
+
+ this._positionListener.stickyEndColumnsUpdated({
+ sizes: firstStickyEnd === -1 ? [] : cellWidths.slice(firstStickyEnd).map((width, index) => stickyEndStates[index + firstStickyEnd] ? width : null).reverse()
+ });
+ }
+ });
+ }
+ /**
+ * Applies sticky positioning to the row's cells if using the native table layout, and to the
+ * row itself otherwise.
+ * @param rowsToStick The list of rows that should be stuck according to their corresponding
+ * sticky state and to the provided top or bottom position.
+ * @param stickyStates A list of boolean states where each state represents whether the row
+ * should be stuck in the particular top or bottom position.
+ * @param position The position direction in which the row should be stuck if that row should be
+ * sticky.
+ *
+ */
+
+
+ stickRows(rowsToStick, stickyStates, position) {
+ // Since we can't measure the rows on the server, we can't stick the rows properly.
+ if (!this._isBrowser) {
+ return;
+ } // If positioning the rows to the bottom, reverse their order when evaluating the sticky
+ // position such that the last row stuck will be "bottom: 0px" and so on. Note that the
+ // sticky states need to be reversed as well.
+
+
+ const rows = position === 'bottom' ? rowsToStick.slice().reverse() : rowsToStick;
+ const states = position === 'bottom' ? stickyStates.slice().reverse() : stickyStates; // Measure row heights all at once before adding sticky styles to reduce layout thrashing.
+
+ const stickyOffsets = [];
+ const stickyCellHeights = [];
+ const elementsToStick = [];
+
+ for (let rowIndex = 0, stickyOffset = 0; rowIndex < rows.length; rowIndex++) {
+ if (!states[rowIndex]) {
+ continue;
+ }
+
+ stickyOffsets[rowIndex] = stickyOffset;
+ const row = rows[rowIndex];
+ elementsToStick[rowIndex] = this._isNativeHtmlTable ? Array.from(row.children) : [row];
+ const height = row.getBoundingClientRect().height;
+ stickyOffset += height;
+ stickyCellHeights[rowIndex] = height;
+ }
+
+ const borderedRowIndex = states.lastIndexOf(true); // Coalesce with other sticky row updates (top/bottom), sticky columns updates
+ // (and potentially other changes like column resize).
+
+ this._coalescedStyleScheduler.schedule(() => {
+ for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+ if (!states[rowIndex]) {
+ continue;
+ }
+
+ const offset = stickyOffsets[rowIndex];
+ const isBorderedRowIndex = rowIndex === borderedRowIndex;
+
+ for (const element of elementsToStick[rowIndex]) {
+ this._addStickyStyle(element, position, offset, isBorderedRowIndex);
+ }
+ }
+
+ if (position === 'top') {
+ this._positionListener?.stickyHeaderRowsUpdated({
+ sizes: stickyCellHeights,
+ offsets: stickyOffsets,
+ elements: elementsToStick
+ });
+ } else {
+ this._positionListener?.stickyFooterRowsUpdated({
+ sizes: stickyCellHeights,
+ offsets: stickyOffsets,
+ elements: elementsToStick
+ });
+ }
+ });
+ }
+ /**
+ * When using the native table in Safari, sticky footer cells do not stick. The only way to stick
+ * footer rows is to apply sticky styling to the tfoot container. This should only be done if
+ * all footer rows are sticky. If not all footer rows are sticky, remove sticky positioning from
+ * the tfoot element.
+ */
+
+
+ updateStickyFooterContainer(tableElement, stickyStates) {
+ if (!this._isNativeHtmlTable) {
+ return;
+ }
+
+ const tfoot = tableElement.querySelector('tfoot'); // Coalesce with other sticky updates (and potentially other changes like column resize).
+
+ this._coalescedStyleScheduler.schedule(() => {
+ if (stickyStates.some(state => !state)) {
+ this._removeStickyStyle(tfoot, ['bottom']);
+ } else {
+ this._addStickyStyle(tfoot, 'bottom', 0, false);
+ }
+ });
+ }
+ /**
+ * Removes the sticky style on the element by removing the sticky cell CSS class, re-evaluating
+ * the zIndex, removing each of the provided sticky directions, and removing the
+ * sticky position if there are no more directions.
+ */
+
+
+ _removeStickyStyle(element, stickyDirections) {
+ for (const dir of stickyDirections) {
+ element.style[dir] = '';
+ element.classList.remove(this._borderCellCss[dir]);
+ } // If the element no longer has any more sticky directions, remove sticky positioning and
+ // the sticky CSS class.
+ // Short-circuit checking element.style[dir] for stickyDirections as they
+ // were already removed above.
+
+
+ const hasDirection = STICKY_DIRECTIONS.some(dir => stickyDirections.indexOf(dir) === -1 && element.style[dir]);
+
+ if (hasDirection) {
+ element.style.zIndex = this._getCalculatedZIndex(element);
+ } else {
+ // When not hasDirection, _getCalculatedZIndex will always return ''.
+ element.style.zIndex = '';
+
+ if (this._needsPositionStickyOnElement) {
+ element.style.position = '';
+ }
+
+ element.classList.remove(this._stickCellCss);
+ }
+ }
+ /**
+ * Adds the sticky styling to the element by adding the sticky style class, changing position
+ * to be sticky (and -webkit-sticky), setting the appropriate zIndex, and adding a sticky
+ * direction and value.
+ */
+
+
+ _addStickyStyle(element, dir, dirValue, isBorderElement) {
+ element.classList.add(this._stickCellCss);
+
+ if (isBorderElement) {
+ element.classList.add(this._borderCellCss[dir]);
+ }
+
+ element.style[dir] = `${dirValue}px`;
+ element.style.zIndex = this._getCalculatedZIndex(element);
+
+ if (this._needsPositionStickyOnElement) {
+ element.style.cssText += 'position: -webkit-sticky; position: sticky; ';
+ }
+ }
+ /**
+ * Calculate what the z-index should be for the element, depending on what directions (top,
+ * bottom, left, right) have been set. It should be true that elements with a top direction
+ * should have the highest index since these are elements like a table header. If any of those
+ * elements are also sticky in another direction, then they should appear above other elements
+ * that are only sticky top (e.g. a sticky column on a sticky header). Bottom-sticky elements
+ * (e.g. footer rows) should then be next in the ordering such that they are below the header
+ * but above any non-sticky elements. Finally, left/right sticky elements (e.g. sticky columns)
+ * should minimally increment so that they are above non-sticky elements but below top and bottom
+ * elements.
+ */
+
+
+ _getCalculatedZIndex(element) {
+ const zIndexIncrements = {
+ top: 100,
+ bottom: 10,
+ left: 1,
+ right: 1
+ };
+ let zIndex = 0; // Use `Iterable` instead of `Array` because TypeScript, as of 3.6.3,
+ // loses the array generic type in the `for of`. But we *also* have to use `Array` because
+ // typescript won't iterate over an `Iterable` unless you compile with `--downlevelIteration`
+
+ for (const dir of STICKY_DIRECTIONS) {
+ if (element.style[dir]) {
+ zIndex += zIndexIncrements[dir];
+ }
+ }
+
+ return zIndex ? `${zIndex}` : '';
+ }
+ /** Gets the widths for each cell in the provided row. */
+
+
+ _getCellWidths(row, recalculateCellWidths = true) {
+ if (!recalculateCellWidths && this._cachedCellWidths.length) {
+ return this._cachedCellWidths;
+ }
+
+ const cellWidths = [];
+ const firstRowCells = row.children;
+
+ for (let i = 0; i < firstRowCells.length; i++) {
+ let cell = firstRowCells[i];
+ cellWidths.push(cell.getBoundingClientRect().width);
+ }
+
+ this._cachedCellWidths = cellWidths;
+ return cellWidths;
+ }
+ /**
+ * Determines the left and right positions of each sticky column cell, which will be the
+ * accumulation of all sticky column cell widths to the left and right, respectively.
+ * Non-sticky cells do not need to have a value set since their positions will not be applied.
+ */
+
+
+ _getStickyStartColumnPositions(widths, stickyStates) {
+ const positions = [];
+ let nextPosition = 0;
+
+ for (let i = 0; i < widths.length; i++) {
+ if (stickyStates[i]) {
+ positions[i] = nextPosition;
+ nextPosition += widths[i];
+ }
+ }
+
+ return positions;
+ }
+ /**
+ * Determines the left and right positions of each sticky column cell, which will be the
+ * accumulation of all sticky column cell widths to the left and right, respectively.
+ * Non-sticky cells do not need to have a value set since their positions will not be applied.
+ */
+
+
+ _getStickyEndColumnPositions(widths, stickyStates) {
+ const positions = [];
+ let nextPosition = 0;
+
+ for (let i = widths.length; i > 0; i--) {
+ if (stickyStates[i]) {
+ positions[i] = nextPosition;
+ nextPosition += widths[i];
+ }
+ }
+
+ return positions;
+ }
+
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * Returns an error to be thrown when attempting to find an unexisting column.
+ * @param id Id whose lookup failed.
+ * @docs-private
+ */
+
+
+function getTableUnknownColumnError(id) {
+ return Error(`Could not find column with id "${id}".`);
+}
+/**
+ * Returns an error to be thrown when two column definitions have the same name.
+ * @docs-private
+ */
+
+
+function getTableDuplicateColumnNameError(name) {
+ return Error(`Duplicate column definition name provided: "${name}".`);
+}
+/**
+ * Returns an error to be thrown when there are multiple rows that are missing a when function.
+ * @docs-private
+ */
+
+
+function getTableMultipleDefaultRowDefsError() {
+ return Error(`There can only be one default row without a when predicate function.`);
+}
+/**
+ * Returns an error to be thrown when there are no matching row defs for a particular set of data.
+ * @docs-private
+ */
+
+
+function getTableMissingMatchingRowDefError(data) {
+ return Error(`Could not find a matching row definition for the` + `provided row data: ${JSON.stringify(data)}`);
+}
+/**
+ * Returns an error to be thrown when there is no row definitions present in the content.
+ * @docs-private
+ */
+
+
+function getTableMissingRowDefsError() {
+ return Error('Missing definitions for header, footer, and row; ' + 'cannot determine which columns should be rendered.');
+}
+/**
+ * Returns an error to be thrown when the data source does not match the compatible types.
+ * @docs-private
+ */
+
+
+function getTableUnknownDataSourceError() {
+ return Error(`Provided data source did not match an array, Observable, or DataSource`);
+}
+/**
+ * Returns an error to be thrown when the text column cannot find a parent table to inject.
+ * @docs-private
+ */
+
+
+function getTableTextColumnMissingParentTableError() {
+ return Error(`Text column could not find a parent table for registration.`);
+}
+/**
+ * Returns an error to be thrown when a table text column doesn't have a name.
+ * @docs-private
+ */
+
+
+function getTableTextColumnMissingNameError() {
+ return Error(`Table text column must have a name.`);
+}
+/**
+ * @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.io/license
+ */
+
+/** The injection token used to specify the StickyPositioningListener. */
+
+
+const STICKY_POSITIONING_LISTENER = new _angular_core__WEBPACK_IMPORTED_MODULE_1__.InjectionToken('CDK_SPL');
+/**
+ * @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.io/license
+ */
+
+/**
+ * Enables the recycle view repeater strategy, which reduces rendering latency. Not compatible with
+ * tables that animate rows.
+ */
+
+class CdkRecycleRows {}
+
+CdkRecycleRows.ɵfac = function CdkRecycleRows_Factory(t) {
+ return new (t || CdkRecycleRows)();
+};
+
+CdkRecycleRows.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdefineDirective"]({
+ type: CdkRecycleRows,
+ selectors: [["cdk-table", "recycleRows", ""], ["table", "cdk-table", "", "recycleRows", ""]],
+ features: [_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵProvidersFeature"]([{
+ provide: _angular_cdk_collections__WEBPACK_IMPORTED_MODULE_0__._VIEW_REPEATER_STRATEGY,
+ useClass: _angular_cdk_collections__WEBPACK_IMPORTED_MODULE_0__._RecycleViewRepeaterStrategy
+ }])]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵsetClassMetadata"](CdkRecycleRows, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Directive,
+ args: [{
+ selector: 'cdk-table[recycleRows], table[cdk-table][recycleRows]',
+ providers: [{
+ provide: _angular_cdk_collections__WEBPACK_IMPORTED_MODULE_0__._VIEW_REPEATER_STRATEGY,
+ useClass: _angular_cdk_collections__WEBPACK_IMPORTED_MODULE_0__._RecycleViewRepeaterStrategy
+ }]
+ }]
+ }], null, null);
+})();
+/**
+ * Provides a handle for the table to grab the view container's ng-container to insert data rows.
+ * @docs-private
+ */
+
+
+class DataRowOutlet {
+ constructor(viewContainer, elementRef) {
+ this.viewContainer = viewContainer;
+ this.elementRef = elementRef;
+ }
+
+}
+
+DataRowOutlet.ɵfac = function DataRowOutlet_Factory(t) {
+ return new (t || DataRowOutlet)(_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_1__.ViewContainerRef), _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_1__.ElementRef));
+};
+
+DataRowOutlet.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdefineDirective"]({
+ type: DataRowOutlet,
+ selectors: [["", "rowOutlet", ""]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵsetClassMetadata"](DataRowOutlet, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Directive,
+ args: [{
+ selector: '[rowOutlet]'
+ }]
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.ViewContainerRef
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.ElementRef
+ }];
+ }, null);
+})();
+/**
+ * Provides a handle for the table to grab the view container's ng-container to insert the header.
+ * @docs-private
+ */
+
+
+class HeaderRowOutlet {
+ constructor(viewContainer, elementRef) {
+ this.viewContainer = viewContainer;
+ this.elementRef = elementRef;
+ }
+
+}
+
+HeaderRowOutlet.ɵfac = function HeaderRowOutlet_Factory(t) {
+ return new (t || HeaderRowOutlet)(_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_1__.ViewContainerRef), _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_1__.ElementRef));
+};
+
+HeaderRowOutlet.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdefineDirective"]({
+ type: HeaderRowOutlet,
+ selectors: [["", "headerRowOutlet", ""]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵsetClassMetadata"](HeaderRowOutlet, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Directive,
+ args: [{
+ selector: '[headerRowOutlet]'
+ }]
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.ViewContainerRef
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.ElementRef
+ }];
+ }, null);
+})();
+/**
+ * Provides a handle for the table to grab the view container's ng-container to insert the footer.
+ * @docs-private
+ */
+
+
+class FooterRowOutlet {
+ constructor(viewContainer, elementRef) {
+ this.viewContainer = viewContainer;
+ this.elementRef = elementRef;
+ }
+
+}
+
+FooterRowOutlet.ɵfac = function FooterRowOutlet_Factory(t) {
+ return new (t || FooterRowOutlet)(_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_1__.ViewContainerRef), _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_1__.ElementRef));
+};
+
+FooterRowOutlet.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdefineDirective"]({
+ type: FooterRowOutlet,
+ selectors: [["", "footerRowOutlet", ""]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵsetClassMetadata"](FooterRowOutlet, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Directive,
+ args: [{
+ selector: '[footerRowOutlet]'
+ }]
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.ViewContainerRef
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.ElementRef
+ }];
+ }, null);
+})();
+/**
+ * Provides a handle for the table to grab the view
+ * container's ng-container to insert the no data row.
+ * @docs-private
+ */
+
+
+class NoDataRowOutlet {
+ constructor(viewContainer, elementRef) {
+ this.viewContainer = viewContainer;
+ this.elementRef = elementRef;
+ }
+
+}
+
+NoDataRowOutlet.ɵfac = function NoDataRowOutlet_Factory(t) {
+ return new (t || NoDataRowOutlet)(_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_1__.ViewContainerRef), _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_1__.ElementRef));
+};
+
+NoDataRowOutlet.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdefineDirective"]({
+ type: NoDataRowOutlet,
+ selectors: [["", "noDataRowOutlet", ""]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵsetClassMetadata"](NoDataRowOutlet, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Directive,
+ args: [{
+ selector: '[noDataRowOutlet]'
+ }]
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.ViewContainerRef
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.ElementRef
+ }];
+ }, null);
+})();
+/**
+ * The table template that can be used by the mat-table. Should not be used outside of the
+ * material library.
+ * @docs-private
+ */
+
+
+const CDK_TABLE_TEMPLATE = // Note that according to MDN, the `caption` element has to be projected as the **first**
+// element in the table. See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/caption
+`
+
\n
\n\n\n",
+ styles: ["cdk-virtual-scroll-viewport{display:block;position:relative;overflow:auto;contain:strict;transform:translateZ(0);will-change:scroll-position;-webkit-overflow-scrolling:touch}.cdk-virtual-scroll-content-wrapper{position:absolute;top:0;left:0;contain:content}[dir=rtl] .cdk-virtual-scroll-content-wrapper{right:0;left:auto}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper{min-height:100%}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-left:0;padding-right:0;margin-left:0;margin-right:0;border-left-width:0;border-right-width:0;outline:none}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper{min-width:100%}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-top:0;padding-bottom:0;margin-top:0;margin-bottom:0;border-top-width:0;border-bottom-width:0;outline:none}.cdk-virtual-scroll-spacer{position:absolute;top:0;left:0;height:1px;width:1px;transform-origin:0 0}[dir=rtl] .cdk-virtual-scroll-spacer{right:0;left:auto;transform-origin:100% 0}\n"]
+ }]
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.ElementRef
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.ChangeDetectorRef
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone
+ }, {
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Optional
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [VIRTUAL_SCROLL_STRATEGY]
+ }]
+ }, {
+ type: _angular_cdk_bidi__WEBPACK_IMPORTED_MODULE_12__.Directionality,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Optional
+ }]
+ }, {
+ type: ScrollDispatcher
+ }, {
+ type: ViewportRuler
+ }];
+ }, {
+ orientation: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Input
+ }],
+ appendOnly: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Input
+ }],
+ scrolledIndexChange: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Output
+ }],
+ _contentWrapper: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.ViewChild,
+ args: ['contentWrapper', {
+ static: true
+ }]
+ }]
+ });
+})();
+/**
+ * @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.io/license
+ */
+
+/** Helper to extract the offset of a DOM Node in a certain direction. */
+
+
+function getOffset(orientation, direction, node) {
+ const el = node;
+
+ if (!el.getBoundingClientRect) {
+ return 0;
+ }
+
+ const rect = el.getBoundingClientRect();
+
+ if (orientation === 'horizontal') {
+ return direction === 'start' ? rect.left : rect.right;
+ }
+
+ return direction === 'start' ? rect.top : rect.bottom;
+}
+/**
+ * A directive similar to `ngForOf` to be used for rendering data inside a virtual scrolling
+ * container.
+ */
+
+
+class CdkVirtualForOf {
+ constructor(
+ /** The view container to add items to. */
+ _viewContainerRef,
+ /** The template to use when stamping out new items. */
+ _template,
+ /** The set of available differs. */
+ _differs,
+ /** The strategy used to render items in the virtual scroll viewport. */
+ _viewRepeater,
+ /** The virtual scrolling viewport that these items are being rendered in. */
+ _viewport, ngZone) {
+ this._viewContainerRef = _viewContainerRef;
+ this._template = _template;
+ this._differs = _differs;
+ this._viewRepeater = _viewRepeater;
+ this._viewport = _viewport;
+ /** Emits when the rendered view of the data changes. */
+
+ this.viewChange = new rxjs__WEBPACK_IMPORTED_MODULE_1__.Subject();
+ /** Subject that emits when a new DataSource instance is given. */
+
+ this._dataSourceChanges = new rxjs__WEBPACK_IMPORTED_MODULE_1__.Subject();
+ /** Emits whenever the data in the current DataSource changes. */
+
+ this.dataStream = this._dataSourceChanges.pipe( // Start off with null `DataSource`.
+ (0,rxjs_operators__WEBPACK_IMPORTED_MODULE_16__.startWith)(null), // Bundle up the previous and current data sources so we can work with both.
+ (0,rxjs_operators__WEBPACK_IMPORTED_MODULE_17__.pairwise)(), // Use `_changeDataSource` to disconnect from the previous data source and connect to the
+ // new one, passing back a stream of data changes which we run through `switchMap` to give
+ // us a data stream that emits the latest data from whatever the current `DataSource` is.
+ (0,rxjs_operators__WEBPACK_IMPORTED_MODULE_18__.switchMap)(([prev, cur]) => this._changeDataSource(prev, cur)), // Replay the last emitted data when someone subscribes.
+ (0,rxjs_operators__WEBPACK_IMPORTED_MODULE_19__.shareReplay)(1));
+ /** The differ used to calculate changes to the data. */
+
+ this._differ = null;
+ /** Whether the rendered data should be updated during the next ngDoCheck cycle. */
+
+ this._needsUpdate = false;
+ this._destroyed = new rxjs__WEBPACK_IMPORTED_MODULE_1__.Subject();
+ this.dataStream.subscribe(data => {
+ this._data = data;
+
+ this._onRenderedDataChange();
+ });
+
+ this._viewport.renderedRangeStream.pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_11__.takeUntil)(this._destroyed)).subscribe(range => {
+ this._renderedRange = range;
+ ngZone.run(() => this.viewChange.next(this._renderedRange));
+
+ this._onRenderedDataChange();
+ });
+
+ this._viewport.attach(this);
+ }
+ /** The DataSource to display. */
+
+
+ get cdkVirtualForOf() {
+ return this._cdkVirtualForOf;
+ }
+
+ set cdkVirtualForOf(value) {
+ this._cdkVirtualForOf = value;
+
+ if ((0,_angular_cdk_collections__WEBPACK_IMPORTED_MODULE_20__.isDataSource)(value)) {
+ this._dataSourceChanges.next(value);
+ } else {
+ // If value is an an NgIterable, convert it to an array.
+ this._dataSourceChanges.next(new _angular_cdk_collections__WEBPACK_IMPORTED_MODULE_20__.ArrayDataSource((0,rxjs__WEBPACK_IMPORTED_MODULE_21__.isObservable)(value) ? value : Array.from(value || [])));
+ }
+ }
+ /**
+ * The `TrackByFunction` to use for tracking changes. The `TrackByFunction` takes the index and
+ * the item and produces a value to be used as the item's identity when tracking changes.
+ */
+
+
+ get cdkVirtualForTrackBy() {
+ return this._cdkVirtualForTrackBy;
+ }
+
+ set cdkVirtualForTrackBy(fn) {
+ this._needsUpdate = true;
+ this._cdkVirtualForTrackBy = fn ? (index, item) => fn(index + (this._renderedRange ? this._renderedRange.start : 0), item) : undefined;
+ }
+ /** The template used to stamp out new elements. */
+
+
+ set cdkVirtualForTemplate(value) {
+ if (value) {
+ this._needsUpdate = true;
+ this._template = value;
+ }
+ }
+ /**
+ * The size of the cache used to store templates that are not being used for re-use later.
+ * Setting the cache size to `0` will disable caching. Defaults to 20 templates.
+ */
+
+
+ get cdkVirtualForTemplateCacheSize() {
+ return this._viewRepeater.viewCacheSize;
+ }
+
+ set cdkVirtualForTemplateCacheSize(size) {
+ this._viewRepeater.viewCacheSize = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_3__.coerceNumberProperty)(size);
+ }
+ /**
+ * Measures the combined size (width for horizontal orientation, height for vertical) of all items
+ * in the specified range. Throws an error if the range includes items that are not currently
+ * rendered.
+ */
+
+
+ measureRangeSize(range, orientation) {
+ if (range.start >= range.end) {
+ return 0;
+ }
+
+ if ((range.start < this._renderedRange.start || range.end > this._renderedRange.end) && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+ throw Error(`Error: attempted to measure an item that isn't rendered.`);
+ } // The index into the list of rendered views for the first item in the range.
+
+
+ const renderedStartIndex = range.start - this._renderedRange.start; // The length of the range we're measuring.
+
+ const rangeLen = range.end - range.start; // Loop over all the views, find the first and land node and compute the size by subtracting
+ // the top of the first node from the bottom of the last one.
+
+ let firstNode;
+ let lastNode; // Find the first node by starting from the beginning and going forwards.
+
+ for (let i = 0; i < rangeLen; i++) {
+ const view = this._viewContainerRef.get(i + renderedStartIndex);
+
+ if (view && view.rootNodes.length) {
+ firstNode = lastNode = view.rootNodes[0];
+ break;
+ }
+ } // Find the last node by starting from the end and going backwards.
+
+
+ for (let i = rangeLen - 1; i > -1; i--) {
+ const view = this._viewContainerRef.get(i + renderedStartIndex);
+
+ if (view && view.rootNodes.length) {
+ lastNode = view.rootNodes[view.rootNodes.length - 1];
+ break;
+ }
+ }
+
+ return firstNode && lastNode ? getOffset(orientation, 'end', lastNode) - getOffset(orientation, 'start', firstNode) : 0;
+ }
+
+ ngDoCheck() {
+ if (this._differ && this._needsUpdate) {
+ // TODO(mmalerba): We should differentiate needs update due to scrolling and a new portion of
+ // this list being rendered (can use simpler algorithm) vs needs update due to data actually
+ // changing (need to do this diff).
+ const changes = this._differ.diff(this._renderedItems);
+
+ if (!changes) {
+ this._updateContext();
+ } else {
+ this._applyChanges(changes);
+ }
+
+ this._needsUpdate = false;
+ }
+ }
+
+ ngOnDestroy() {
+ this._viewport.detach();
+
+ this._dataSourceChanges.next(undefined);
+
+ this._dataSourceChanges.complete();
+
+ this.viewChange.complete();
+
+ this._destroyed.next();
+
+ this._destroyed.complete();
+
+ this._viewRepeater.detach();
+ }
+ /** React to scroll state changes in the viewport. */
+
+
+ _onRenderedDataChange() {
+ if (!this._renderedRange) {
+ return;
+ }
+
+ this._renderedItems = this._data.slice(this._renderedRange.start, this._renderedRange.end);
+
+ if (!this._differ) {
+ // Use a wrapper function for the `trackBy` so any new values are
+ // picked up automatically without having to recreate the differ.
+ this._differ = this._differs.find(this._renderedItems).create((index, item) => {
+ return this.cdkVirtualForTrackBy ? this.cdkVirtualForTrackBy(index, item) : item;
+ });
+ }
+
+ this._needsUpdate = true;
+ }
+ /** Swap out one `DataSource` for another. */
+
+
+ _changeDataSource(oldDs, newDs) {
+ if (oldDs) {
+ oldDs.disconnect(this);
+ }
+
+ this._needsUpdate = true;
+ return newDs ? newDs.connect(this) : (0,rxjs__WEBPACK_IMPORTED_MODULE_4__.of)();
+ }
+ /** Update the `CdkVirtualForOfContext` for all views. */
+
+
+ _updateContext() {
+ const count = this._data.length;
+ let i = this._viewContainerRef.length;
+
+ while (i--) {
+ const view = this._viewContainerRef.get(i);
+
+ view.context.index = this._renderedRange.start + i;
+ view.context.count = count;
+
+ this._updateComputedContextProperties(view.context);
+
+ view.detectChanges();
+ }
+ }
+ /** Apply changes to the DOM. */
+
+
+ _applyChanges(changes) {
+ this._viewRepeater.applyChanges(changes, this._viewContainerRef, (record, _adjustedPreviousIndex, currentIndex) => this._getEmbeddedViewArgs(record, currentIndex), record => record.item); // Update $implicit for any items that had an identity change.
+
+
+ changes.forEachIdentityChange(record => {
+ const view = this._viewContainerRef.get(record.currentIndex);
+
+ view.context.$implicit = record.item;
+ }); // Update the context variables on all items.
+
+ const count = this._data.length;
+ let i = this._viewContainerRef.length;
+
+ while (i--) {
+ const view = this._viewContainerRef.get(i);
+
+ view.context.index = this._renderedRange.start + i;
+ view.context.count = count;
+
+ this._updateComputedContextProperties(view.context);
+ }
+ }
+ /** Update the computed properties on the `CdkVirtualForOfContext`. */
+
+
+ _updateComputedContextProperties(context) {
+ context.first = context.index === 0;
+ context.last = context.index === context.count - 1;
+ context.even = context.index % 2 === 0;
+ context.odd = !context.even;
+ }
+
+ _getEmbeddedViewArgs(record, index) {
+ // Note that it's important that we insert the item directly at the proper index,
+ // rather than inserting it and the moving it in place, because if there's a directive
+ // on the same node that injects the `ViewContainerRef`, Angular will insert another
+ // comment node which can throw off the move when it's being repeated for all items.
+ return {
+ templateRef: this._template,
+ context: {
+ $implicit: record.item,
+ // It's guaranteed that the iterable is not "undefined" or "null" because we only
+ // generate views for elements if the "cdkVirtualForOf" iterable has elements.
+ cdkVirtualForOf: this._cdkVirtualForOf,
+ index: -1,
+ count: -1,
+ first: false,
+ last: false,
+ odd: false,
+ even: false
+ },
+ index
+ };
+ }
+
+}
+
+CdkVirtualForOf.ɵfac = function CdkVirtualForOf_Factory(t) {
+ return new (t || CdkVirtualForOf)(_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.ViewContainerRef), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.TemplateRef), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.IterableDiffers), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_cdk_collections__WEBPACK_IMPORTED_MODULE_20__._VIEW_REPEATER_STRATEGY), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](CdkVirtualScrollViewport, 4), _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone));
+};
+
+CdkVirtualForOf.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineDirective"]({
+ type: CdkVirtualForOf,
+ selectors: [["", "cdkVirtualFor", "", "cdkVirtualForOf", ""]],
+ inputs: {
+ cdkVirtualForOf: "cdkVirtualForOf",
+ cdkVirtualForTrackBy: "cdkVirtualForTrackBy",
+ cdkVirtualForTemplate: "cdkVirtualForTemplate",
+ cdkVirtualForTemplateCacheSize: "cdkVirtualForTemplateCacheSize"
+ },
+ features: [_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵProvidersFeature"]([{
+ provide: _angular_cdk_collections__WEBPACK_IMPORTED_MODULE_20__._VIEW_REPEATER_STRATEGY,
+ useClass: _angular_cdk_collections__WEBPACK_IMPORTED_MODULE_20__._RecycleViewRepeaterStrategy
+ }])]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](CdkVirtualForOf, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Directive,
+ args: [{
+ selector: '[cdkVirtualFor][cdkVirtualForOf]',
+ providers: [{
+ provide: _angular_cdk_collections__WEBPACK_IMPORTED_MODULE_20__._VIEW_REPEATER_STRATEGY,
+ useClass: _angular_cdk_collections__WEBPACK_IMPORTED_MODULE_20__._RecycleViewRepeaterStrategy
+ }]
+ }]
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.ViewContainerRef
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.TemplateRef
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.IterableDiffers
+ }, {
+ type: _angular_cdk_collections__WEBPACK_IMPORTED_MODULE_20__._RecycleViewRepeaterStrategy,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Inject,
+ args: [_angular_cdk_collections__WEBPACK_IMPORTED_MODULE_20__._VIEW_REPEATER_STRATEGY]
+ }]
+ }, {
+ type: CdkVirtualScrollViewport,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.SkipSelf
+ }]
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgZone
+ }];
+ }, {
+ cdkVirtualForOf: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Input
+ }],
+ cdkVirtualForTrackBy: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Input
+ }],
+ cdkVirtualForTemplate: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Input
+ }],
+ cdkVirtualForTemplateCacheSize: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.Input
+ }]
+ });
+})();
+/**
+ * @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.io/license
+ */
+
+
+class CdkScrollableModule {}
+
+CdkScrollableModule.ɵfac = function CdkScrollableModule_Factory(t) {
+ return new (t || CdkScrollableModule)();
+};
+
+CdkScrollableModule.ɵmod = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineNgModule"]({
+ type: CdkScrollableModule
+});
+CdkScrollableModule.ɵinj = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjector"]({});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](CdkScrollableModule, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgModule,
+ args: [{
+ exports: [CdkScrollable],
+ declarations: [CdkScrollable]
+ }]
+ }], null, null);
+})();
+/**
+ * @docs-primary-export
+ */
+
+
+class ScrollingModule {}
+
+ScrollingModule.ɵfac = function ScrollingModule_Factory(t) {
+ return new (t || ScrollingModule)();
+};
+
+ScrollingModule.ɵmod = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineNgModule"]({
+ type: ScrollingModule
+});
+ScrollingModule.ɵinj = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵɵdefineInjector"]({
+ imports: [[_angular_cdk_bidi__WEBPACK_IMPORTED_MODULE_12__.BidiModule, _angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.PlatformModule, CdkScrollableModule], _angular_cdk_bidi__WEBPACK_IMPORTED_MODULE_12__.BidiModule, CdkScrollableModule]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_0__["ɵsetClassMetadata"](ScrollingModule, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_0__.NgModule,
+ args: [{
+ imports: [_angular_cdk_bidi__WEBPACK_IMPORTED_MODULE_12__.BidiModule, _angular_cdk_platform__WEBPACK_IMPORTED_MODULE_9__.PlatformModule, CdkScrollableModule],
+ exports: [_angular_cdk_bidi__WEBPACK_IMPORTED_MODULE_12__.BidiModule, CdkScrollableModule, CdkFixedSizeVirtualScroll, CdkVirtualForOf, CdkVirtualScrollViewport],
+ declarations: [CdkFixedSizeVirtualScroll, CdkVirtualForOf, CdkVirtualScrollViewport]
+ }]
+ }], null, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+
+
+
+/***/ }),
+
+/***/ 9673:
+/*!******************************************************!*\
+ !*** ./node_modules/@angular/cdk/fesm2020/table.mjs ***!
+ \******************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "BaseCdkCell": () => (/* binding */ BaseCdkCell),
+/* harmony export */ "BaseRowDef": () => (/* binding */ BaseRowDef),
+/* harmony export */ "CDK_ROW_TEMPLATE": () => (/* binding */ CDK_ROW_TEMPLATE),
+/* harmony export */ "CDK_TABLE": () => (/* binding */ CDK_TABLE),
+/* harmony export */ "CDK_TABLE_TEMPLATE": () => (/* binding */ CDK_TABLE_TEMPLATE),
+/* harmony export */ "CdkCell": () => (/* binding */ CdkCell),
+/* harmony export */ "CdkCellDef": () => (/* binding */ CdkCellDef),
+/* harmony export */ "CdkCellOutlet": () => (/* binding */ CdkCellOutlet),
+/* harmony export */ "CdkColumnDef": () => (/* binding */ CdkColumnDef),
+/* harmony export */ "CdkFooterCell": () => (/* binding */ CdkFooterCell),
+/* harmony export */ "CdkFooterCellDef": () => (/* binding */ CdkFooterCellDef),
+/* harmony export */ "CdkFooterRow": () => (/* binding */ CdkFooterRow),
+/* harmony export */ "CdkFooterRowDef": () => (/* binding */ CdkFooterRowDef),
+/* harmony export */ "CdkHeaderCell": () => (/* binding */ CdkHeaderCell),
+/* harmony export */ "CdkHeaderCellDef": () => (/* binding */ CdkHeaderCellDef),
+/* harmony export */ "CdkHeaderRow": () => (/* binding */ CdkHeaderRow),
+/* harmony export */ "CdkHeaderRowDef": () => (/* binding */ CdkHeaderRowDef),
+/* harmony export */ "CdkNoDataRow": () => (/* binding */ CdkNoDataRow),
+/* harmony export */ "CdkRecycleRows": () => (/* binding */ CdkRecycleRows),
+/* harmony export */ "CdkRow": () => (/* binding */ CdkRow),
+/* harmony export */ "CdkRowDef": () => (/* binding */ CdkRowDef),
+/* harmony export */ "CdkTable": () => (/* binding */ CdkTable),
+/* harmony export */ "CdkTableModule": () => (/* binding */ CdkTableModule),
+/* harmony export */ "CdkTextColumn": () => (/* binding */ CdkTextColumn),
+/* harmony export */ "DataRowOutlet": () => (/* binding */ DataRowOutlet),
+/* harmony export */ "DataSource": () => (/* reexport safe */ _angular_cdk_collections__WEBPACK_IMPORTED_MODULE_0__.DataSource),
+/* harmony export */ "FooterRowOutlet": () => (/* binding */ FooterRowOutlet),
+/* harmony export */ "HeaderRowOutlet": () => (/* binding */ HeaderRowOutlet),
+/* harmony export */ "NoDataRowOutlet": () => (/* binding */ NoDataRowOutlet),
+/* harmony export */ "STICKY_DIRECTIONS": () => (/* binding */ STICKY_DIRECTIONS),
+/* harmony export */ "STICKY_POSITIONING_LISTENER": () => (/* binding */ STICKY_POSITIONING_LISTENER),
+/* harmony export */ "StickyStyler": () => (/* binding */ StickyStyler),
+/* harmony export */ "TEXT_COLUMN_OPTIONS": () => (/* binding */ TEXT_COLUMN_OPTIONS),
+/* harmony export */ "_COALESCED_STYLE_SCHEDULER": () => (/* binding */ _COALESCED_STYLE_SCHEDULER),
+/* harmony export */ "_CoalescedStyleScheduler": () => (/* binding */ _CoalescedStyleScheduler),
+/* harmony export */ "_Schedule": () => (/* binding */ _Schedule),
+/* harmony export */ "mixinHasStickyInput": () => (/* binding */ mixinHasStickyInput)
+/* harmony export */ });
+/* harmony import */ var _angular_cdk_bidi__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! @angular/cdk/bidi */ 2867);
+/* harmony import */ var _angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @angular/cdk/coercion */ 8971);
+/* harmony import */ var _angular_cdk_collections__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @angular/cdk/collections */ 1755);
+/* harmony import */ var _angular_cdk_platform__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! @angular/cdk/platform */ 9107);
+/* harmony import */ var _angular_cdk_scrolling__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! @angular/cdk/scrolling */ 6328);
+/* harmony import */ var _angular_common__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! @angular/common */ 4666);
+/* harmony import */ var _angular_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @angular/core */ 2560);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! rxjs */ 228);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! rxjs */ 9346);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! rxjs */ 6317);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! rxjs */ 4437);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! rxjs */ 745);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! rxjs/operators */ 8951);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! rxjs/operators */ 9295);
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * @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.io/license
+ */
+
+/**
+ * Mixin to provide a directive with a function that checks if the sticky input has been
+ * changed since the last time the function was called. Essentially adds a dirty-check to the
+ * sticky value.
+ * @docs-private
+ */
+
+const _c0 = [[["caption"]], [["colgroup"], ["col"]]];
+const _c1 = ["caption", "colgroup, col"];
+
+function CdkTextColumn_th_1_Template(rf, ctx) {
+ if (rf & 1) {
+ _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵelementStart"](0, "th", 3);
+ _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵtext"](1);
+ _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵelementEnd"]();
+ }
+
+ if (rf & 2) {
+ const ctx_r0 = _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵnextContext"]();
+ _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵstyleProp"]("text-align", ctx_r0.justify);
+ _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵadvance"](1);
+ _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵtextInterpolate1"](" ", ctx_r0.headerText, " ");
+ }
+}
+
+function CdkTextColumn_td_2_Template(rf, ctx) {
+ if (rf & 1) {
+ _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵelementStart"](0, "td", 4);
+ _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵtext"](1);
+ _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵelementEnd"]();
+ }
+
+ if (rf & 2) {
+ const data_r2 = ctx.$implicit;
+ const ctx_r1 = _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵnextContext"]();
+ _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵstyleProp"]("text-align", ctx_r1.justify);
+ _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵadvance"](1);
+ _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵtextInterpolate1"](" ", ctx_r1.dataAccessor(data_r2, ctx_r1.name), " ");
+ }
+}
+
+function mixinHasStickyInput(base) {
+ return class extends base {
+ constructor(...args) {
+ super(...args);
+ this._sticky = false;
+ /** Whether the sticky input has changed since it was last checked. */
+
+ this._hasStickyChanged = false;
+ }
+ /** Whether sticky positioning should be applied. */
+
+
+ get sticky() {
+ return this._sticky;
+ }
+
+ set sticky(v) {
+ const prevValue = this._sticky;
+ this._sticky = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceBooleanProperty)(v);
+ this._hasStickyChanged = prevValue !== this._sticky;
+ }
+ /** Whether the sticky value has changed since this was last called. */
+
+
+ hasStickyChanged() {
+ const hasStickyChanged = this._hasStickyChanged;
+ this._hasStickyChanged = false;
+ return hasStickyChanged;
+ }
+ /** Resets the dirty check for cases where the sticky state has been used without checking. */
+
+
+ resetStickyChanged() {
+ this._hasStickyChanged = false;
+ }
+
+ };
+}
+/**
+ * @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.io/license
+ */
+
+/**
+ * Used to provide a table to some of the sub-components without causing a circular dependency.
+ * @docs-private
+ */
+
+
+const CDK_TABLE = new _angular_core__WEBPACK_IMPORTED_MODULE_1__.InjectionToken('CDK_TABLE');
+/** Injection token that can be used to specify the text column options. */
+
+const TEXT_COLUMN_OPTIONS = new _angular_core__WEBPACK_IMPORTED_MODULE_1__.InjectionToken('text-column-options');
+/**
+ * @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.io/license
+ */
+
+/**
+ * Cell definition for a CDK table.
+ * Captures the template of a column's data row cell as well as cell-specific properties.
+ */
+
+class CdkCellDef {
+ constructor(
+ /** @docs-private */
+ template) {
+ this.template = template;
+ }
+
+}
+
+CdkCellDef.ɵfac = function CdkCellDef_Factory(t) {
+ return new (t || CdkCellDef)(_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_1__.TemplateRef));
+};
+
+CdkCellDef.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdefineDirective"]({
+ type: CdkCellDef,
+ selectors: [["", "cdkCellDef", ""]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵsetClassMetadata"](CdkCellDef, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Directive,
+ args: [{
+ selector: '[cdkCellDef]'
+ }]
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.TemplateRef
+ }];
+ }, null);
+})();
+/**
+ * Header cell definition for a CDK table.
+ * Captures the template of a column's header cell and as well as cell-specific properties.
+ */
+
+
+class CdkHeaderCellDef {
+ constructor(
+ /** @docs-private */
+ template) {
+ this.template = template;
+ }
+
+}
+
+CdkHeaderCellDef.ɵfac = function CdkHeaderCellDef_Factory(t) {
+ return new (t || CdkHeaderCellDef)(_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_1__.TemplateRef));
+};
+
+CdkHeaderCellDef.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdefineDirective"]({
+ type: CdkHeaderCellDef,
+ selectors: [["", "cdkHeaderCellDef", ""]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵsetClassMetadata"](CdkHeaderCellDef, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Directive,
+ args: [{
+ selector: '[cdkHeaderCellDef]'
+ }]
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.TemplateRef
+ }];
+ }, null);
+})();
+/**
+ * Footer cell definition for a CDK table.
+ * Captures the template of a column's footer cell and as well as cell-specific properties.
+ */
+
+
+class CdkFooterCellDef {
+ constructor(
+ /** @docs-private */
+ template) {
+ this.template = template;
+ }
+
+}
+
+CdkFooterCellDef.ɵfac = function CdkFooterCellDef_Factory(t) {
+ return new (t || CdkFooterCellDef)(_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_1__.TemplateRef));
+};
+
+CdkFooterCellDef.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdefineDirective"]({
+ type: CdkFooterCellDef,
+ selectors: [["", "cdkFooterCellDef", ""]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵsetClassMetadata"](CdkFooterCellDef, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Directive,
+ args: [{
+ selector: '[cdkFooterCellDef]'
+ }]
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.TemplateRef
+ }];
+ }, null);
+})(); // Boilerplate for applying mixins to CdkColumnDef.
+
+/** @docs-private */
+
+
+class CdkColumnDefBase {}
+
+const _CdkColumnDefBase = mixinHasStickyInput(CdkColumnDefBase);
+/**
+ * Column definition for the CDK table.
+ * Defines a set of cells available for a table column.
+ */
+
+
+class CdkColumnDef extends _CdkColumnDefBase {
+ constructor(_table) {
+ super();
+ this._table = _table;
+ this._stickyEnd = false;
+ }
+ /** Unique name for this column. */
+
+
+ get name() {
+ return this._name;
+ }
+
+ set name(name) {
+ this._setNameInput(name);
+ }
+ /**
+ * Whether this column should be sticky positioned on the end of the row. Should make sure
+ * that it mimics the `CanStick` mixin such that `_hasStickyChanged` is set to true if the value
+ * has been changed.
+ */
+
+
+ get stickyEnd() {
+ return this._stickyEnd;
+ }
+
+ set stickyEnd(v) {
+ const prevValue = this._stickyEnd;
+ this._stickyEnd = (0,_angular_cdk_coercion__WEBPACK_IMPORTED_MODULE_2__.coerceBooleanProperty)(v);
+ this._hasStickyChanged = prevValue !== this._stickyEnd;
+ }
+ /**
+ * Overridable method that sets the css classes that will be added to every cell in this
+ * column.
+ * In the future, columnCssClassName will change from type string[] to string and this
+ * will set a single string value.
+ * @docs-private
+ */
+
+
+ _updateColumnCssClassName() {
+ this._columnCssClassName = [`cdk-column-${this.cssClassFriendlyName}`];
+ }
+ /**
+ * This has been extracted to a util because of TS 4 and VE.
+ * View Engine doesn't support property rename inheritance.
+ * TS 4.0 doesn't allow properties to override accessors or vice-versa.
+ * @docs-private
+ */
+
+
+ _setNameInput(value) {
+ // If the directive is set without a name (updated programmatically), then this setter will
+ // trigger with an empty string and should not overwrite the programmatically set value.
+ if (value) {
+ this._name = value;
+ this.cssClassFriendlyName = value.replace(/[^a-z0-9_-]/gi, '-');
+
+ this._updateColumnCssClassName();
+ }
+ }
+
+}
+
+CdkColumnDef.ɵfac = function CdkColumnDef_Factory(t) {
+ return new (t || CdkColumnDef)(_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdirectiveInject"](CDK_TABLE, 8));
+};
+
+CdkColumnDef.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdefineDirective"]({
+ type: CdkColumnDef,
+ selectors: [["", "cdkColumnDef", ""]],
+ contentQueries: function CdkColumnDef_ContentQueries(rf, ctx, dirIndex) {
+ if (rf & 1) {
+ _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵcontentQuery"](dirIndex, CdkCellDef, 5);
+ _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵcontentQuery"](dirIndex, CdkHeaderCellDef, 5);
+ _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵcontentQuery"](dirIndex, CdkFooterCellDef, 5);
+ }
+
+ if (rf & 2) {
+ let _t;
+
+ _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵqueryRefresh"](_t = _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵloadQuery"]()) && (ctx.cell = _t.first);
+ _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵqueryRefresh"](_t = _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵloadQuery"]()) && (ctx.headerCell = _t.first);
+ _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵqueryRefresh"](_t = _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵloadQuery"]()) && (ctx.footerCell = _t.first);
+ }
+ },
+ inputs: {
+ sticky: "sticky",
+ name: ["cdkColumnDef", "name"],
+ stickyEnd: "stickyEnd"
+ },
+ features: [_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵProvidersFeature"]([{
+ provide: 'MAT_SORT_HEADER_COLUMN_DEF',
+ useExisting: CdkColumnDef
+ }]), _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵInheritDefinitionFeature"]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵsetClassMetadata"](CdkColumnDef, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Directive,
+ args: [{
+ selector: '[cdkColumnDef]',
+ inputs: ['sticky'],
+ providers: [{
+ provide: 'MAT_SORT_HEADER_COLUMN_DEF',
+ useExisting: CdkColumnDef
+ }]
+ }]
+ }], function () {
+ return [{
+ type: undefined,
+ decorators: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Inject,
+ args: [CDK_TABLE]
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Optional
+ }]
+ }];
+ }, {
+ name: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Input,
+ args: ['cdkColumnDef']
+ }],
+ stickyEnd: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Input,
+ args: ['stickyEnd']
+ }],
+ cell: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.ContentChild,
+ args: [CdkCellDef]
+ }],
+ headerCell: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.ContentChild,
+ args: [CdkHeaderCellDef]
+ }],
+ footerCell: [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.ContentChild,
+ args: [CdkFooterCellDef]
+ }]
+ });
+})();
+/** Base class for the cells. Adds a CSS classname that identifies the column it renders in. */
+
+
+class BaseCdkCell {
+ constructor(columnDef, elementRef) {
+ // If IE 11 is dropped before we switch to setting a single class name, change to multi param
+ // with destructuring.
+ const classList = elementRef.nativeElement.classList;
+
+ for (const className of columnDef._columnCssClassName) {
+ classList.add(className);
+ }
+ }
+
+}
+/** Header cell template container that adds the right classes and role. */
+
+
+class CdkHeaderCell extends BaseCdkCell {
+ constructor(columnDef, elementRef) {
+ super(columnDef, elementRef);
+ }
+
+}
+
+CdkHeaderCell.ɵfac = function CdkHeaderCell_Factory(t) {
+ return new (t || CdkHeaderCell)(_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdirectiveInject"](CdkColumnDef), _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_1__.ElementRef));
+};
+
+CdkHeaderCell.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdefineDirective"]({
+ type: CdkHeaderCell,
+ selectors: [["cdk-header-cell"], ["th", "cdk-header-cell", ""]],
+ hostAttrs: ["role", "columnheader", 1, "cdk-header-cell"],
+ features: [_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵInheritDefinitionFeature"]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵsetClassMetadata"](CdkHeaderCell, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Directive,
+ args: [{
+ selector: 'cdk-header-cell, th[cdk-header-cell]',
+ host: {
+ 'class': 'cdk-header-cell',
+ 'role': 'columnheader'
+ }
+ }]
+ }], function () {
+ return [{
+ type: CdkColumnDef
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.ElementRef
+ }];
+ }, null);
+})();
+/** Footer cell template container that adds the right classes and role. */
+
+
+class CdkFooterCell extends BaseCdkCell {
+ constructor(columnDef, elementRef) {
+ super(columnDef, elementRef);
+
+ if (columnDef._table?._elementRef.nativeElement.nodeType === 1) {
+ const tableRole = columnDef._table._elementRef.nativeElement.getAttribute('role');
+
+ const role = tableRole === 'grid' || tableRole === 'treegrid' ? 'gridcell' : 'cell';
+ elementRef.nativeElement.setAttribute('role', role);
+ }
+ }
+
+}
+
+CdkFooterCell.ɵfac = function CdkFooterCell_Factory(t) {
+ return new (t || CdkFooterCell)(_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdirectiveInject"](CdkColumnDef), _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_1__.ElementRef));
+};
+
+CdkFooterCell.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdefineDirective"]({
+ type: CdkFooterCell,
+ selectors: [["cdk-footer-cell"], ["td", "cdk-footer-cell", ""]],
+ hostAttrs: [1, "cdk-footer-cell"],
+ features: [_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵInheritDefinitionFeature"]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵsetClassMetadata"](CdkFooterCell, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Directive,
+ args: [{
+ selector: 'cdk-footer-cell, td[cdk-footer-cell]',
+ host: {
+ 'class': 'cdk-footer-cell'
+ }
+ }]
+ }], function () {
+ return [{
+ type: CdkColumnDef
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.ElementRef
+ }];
+ }, null);
+})();
+/** Cell template container that adds the right classes and role. */
+
+
+class CdkCell extends BaseCdkCell {
+ constructor(columnDef, elementRef) {
+ super(columnDef, elementRef);
+
+ if (columnDef._table?._elementRef.nativeElement.nodeType === 1) {
+ const tableRole = columnDef._table._elementRef.nativeElement.getAttribute('role');
+
+ const role = tableRole === 'grid' || tableRole === 'treegrid' ? 'gridcell' : 'cell';
+ elementRef.nativeElement.setAttribute('role', role);
+ }
+ }
+
+}
+
+CdkCell.ɵfac = function CdkCell_Factory(t) {
+ return new (t || CdkCell)(_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdirectiveInject"](CdkColumnDef), _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdirectiveInject"](_angular_core__WEBPACK_IMPORTED_MODULE_1__.ElementRef));
+};
+
+CdkCell.ɵdir = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdefineDirective"]({
+ type: CdkCell,
+ selectors: [["cdk-cell"], ["td", "cdk-cell", ""]],
+ hostAttrs: [1, "cdk-cell"],
+ features: [_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵInheritDefinitionFeature"]]
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵsetClassMetadata"](CdkCell, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Directive,
+ args: [{
+ selector: 'cdk-cell, td[cdk-cell]',
+ host: {
+ 'class': 'cdk-cell'
+ }
+ }]
+ }], function () {
+ return [{
+ type: CdkColumnDef
+ }, {
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.ElementRef
+ }];
+ }, null);
+})();
+/**
+ * @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.io/license
+ */
+
+/**
+ * @docs-private
+ */
+
+
+class _Schedule {
+ constructor() {
+ this.tasks = [];
+ this.endTasks = [];
+ }
+
+}
+/** Injection token used to provide a coalesced style scheduler. */
+
+
+const _COALESCED_STYLE_SCHEDULER = new _angular_core__WEBPACK_IMPORTED_MODULE_1__.InjectionToken('_COALESCED_STYLE_SCHEDULER');
+/**
+ * Allows grouping up CSSDom mutations after the current execution context.
+ * This can significantly improve performance when separate consecutive functions are
+ * reading from the CSSDom and then mutating it.
+ *
+ * @docs-private
+ */
+
+
+class _CoalescedStyleScheduler {
+ constructor(_ngZone) {
+ this._ngZone = _ngZone;
+ this._currentSchedule = null;
+ this._destroyed = new rxjs__WEBPACK_IMPORTED_MODULE_3__.Subject();
+ }
+ /**
+ * Schedules the specified task to run at the end of the current VM turn.
+ */
+
+
+ schedule(task) {
+ this._createScheduleIfNeeded();
+
+ this._currentSchedule.tasks.push(task);
+ }
+ /**
+ * Schedules the specified task to run after other scheduled tasks at the end of the current
+ * VM turn.
+ */
+
+
+ scheduleEnd(task) {
+ this._createScheduleIfNeeded();
+
+ this._currentSchedule.endTasks.push(task);
+ }
+ /** Prevent any further tasks from running. */
+
+
+ ngOnDestroy() {
+ this._destroyed.next();
+
+ this._destroyed.complete();
+ }
+
+ _createScheduleIfNeeded() {
+ if (this._currentSchedule) {
+ return;
+ }
+
+ this._currentSchedule = new _Schedule();
+
+ this._getScheduleObservable().pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_4__.takeUntil)(this._destroyed)).subscribe(() => {
+ while (this._currentSchedule.tasks.length || this._currentSchedule.endTasks.length) {
+ const schedule = this._currentSchedule; // Capture new tasks scheduled by the current set of tasks.
+
+ this._currentSchedule = new _Schedule();
+
+ for (const task of schedule.tasks) {
+ task();
+ }
+
+ for (const task of schedule.endTasks) {
+ task();
+ }
+ }
+
+ this._currentSchedule = null;
+ });
+ }
+
+ _getScheduleObservable() {
+ // Use onStable when in the context of an ongoing change detection cycle so that we
+ // do not accidentally trigger additional cycles.
+ return this._ngZone.isStable ? (0,rxjs__WEBPACK_IMPORTED_MODULE_5__.from)(Promise.resolve(undefined)) : this._ngZone.onStable.pipe((0,rxjs_operators__WEBPACK_IMPORTED_MODULE_6__.take)(1));
+ }
+
+}
+
+_CoalescedStyleScheduler.ɵfac = function _CoalescedStyleScheduler_Factory(t) {
+ return new (t || _CoalescedStyleScheduler)(_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵinject"](_angular_core__WEBPACK_IMPORTED_MODULE_1__.NgZone));
+};
+
+_CoalescedStyleScheduler.ɵprov = /* @__PURE__ */_angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵɵdefineInjectable"]({
+ token: _CoalescedStyleScheduler,
+ factory: _CoalescedStyleScheduler.ɵfac
+});
+
+(function () {
+ (typeof ngDevMode === "undefined" || ngDevMode) && _angular_core__WEBPACK_IMPORTED_MODULE_1__["ɵsetClassMetadata"](_CoalescedStyleScheduler, [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.Injectable
+ }], function () {
+ return [{
+ type: _angular_core__WEBPACK_IMPORTED_MODULE_1__.NgZone
+ }];
+ }, null);
+})();
+/**
+ * The row template that can be used by the mat-table. Should not be used outside of the
+ * material library.
+ */
+
+
+const CDK_ROW_TEMPLATE = `| + {{headerText}} + | ++ {{dataAccessor(data, name)}} + | +
|---|