{"version":3,"sources":["node_modules/@angular/animations/fesm2022/animations.mjs","node_modules/primeng/fesm2022/primeng-dom.mjs","node_modules/primeng/fesm2022/primeng-baseicon.mjs"],"sourcesContent":["/**\n * @license Angular v17.3.3\n * (c) 2010-2022 Google LLC. https://angular.io/\n * License: MIT\n */\n\nimport { DOCUMENT } from '@angular/common';\nimport * as i0 from '@angular/core';\nimport { inject, Injectable, ANIMATION_MODULE_TYPE, ViewEncapsulation, ɵRuntimeError, Inject } from '@angular/core';\n\n/**\n * @description Constants for the categories of parameters that can be defined for animations.\n *\n * A corresponding function defines a set of parameters for each category, and\n * collects them into a corresponding `AnimationMetadata` object.\n *\n * @publicApi\n */\nvar AnimationMetadataType = /*#__PURE__*/function (AnimationMetadataType) {\n  /**\n   * Associates a named animation state with a set of CSS styles.\n   * See [`state()`](api/animations/state)\n   */\n  AnimationMetadataType[AnimationMetadataType[\"State\"] = 0] = \"State\";\n  /**\n   * Data for a transition from one animation state to another.\n   * See `transition()`\n   */\n  AnimationMetadataType[AnimationMetadataType[\"Transition\"] = 1] = \"Transition\";\n  /**\n   * Contains a set of animation steps.\n   * See `sequence()`\n   */\n  AnimationMetadataType[AnimationMetadataType[\"Sequence\"] = 2] = \"Sequence\";\n  /**\n   * Contains a set of animation steps.\n   * See `{@link animations/group group()}`\n   */\n  AnimationMetadataType[AnimationMetadataType[\"Group\"] = 3] = \"Group\";\n  /**\n   * Contains an animation step.\n   * See `animate()`\n   */\n  AnimationMetadataType[AnimationMetadataType[\"Animate\"] = 4] = \"Animate\";\n  /**\n   * Contains a set of animation steps.\n   * See `keyframes()`\n   */\n  AnimationMetadataType[AnimationMetadataType[\"Keyframes\"] = 5] = \"Keyframes\";\n  /**\n   * Contains a set of CSS property-value pairs into a named style.\n   * See `style()`\n   */\n  AnimationMetadataType[AnimationMetadataType[\"Style\"] = 6] = \"Style\";\n  /**\n   * Associates an animation with an entry trigger that can be attached to an element.\n   * See `trigger()`\n   */\n  AnimationMetadataType[AnimationMetadataType[\"Trigger\"] = 7] = \"Trigger\";\n  /**\n   * Contains a re-usable animation.\n   * See `animation()`\n   */\n  AnimationMetadataType[AnimationMetadataType[\"Reference\"] = 8] = \"Reference\";\n  /**\n   * Contains data to use in executing child animations returned by a query.\n   * See `animateChild()`\n   */\n  AnimationMetadataType[AnimationMetadataType[\"AnimateChild\"] = 9] = \"AnimateChild\";\n  /**\n   * Contains animation parameters for a re-usable animation.\n   * See `useAnimation()`\n   */\n  AnimationMetadataType[AnimationMetadataType[\"AnimateRef\"] = 10] = \"AnimateRef\";\n  /**\n   * Contains child-animation query data.\n   * See `query()`\n   */\n  AnimationMetadataType[AnimationMetadataType[\"Query\"] = 11] = \"Query\";\n  /**\n   * Contains data for staggering an animation sequence.\n   * See `stagger()`\n   */\n  AnimationMetadataType[AnimationMetadataType[\"Stagger\"] = 12] = \"Stagger\";\n  return AnimationMetadataType;\n}(AnimationMetadataType || {});\n/**\n * Specifies automatic styling.\n *\n * @publicApi\n */\nconst AUTO_STYLE = '*';\n/**\n * Creates a named animation trigger, containing a  list of [`state()`](api/animations/state)\n * and `transition()` entries to be evaluated when the expression\n * bound to the trigger changes.\n *\n * @param name An identifying string.\n * @param definitions  An animation definition object, containing an array of\n * [`state()`](api/animations/state) and `transition()` declarations.\n *\n * @return An object that encapsulates the trigger data.\n *\n * @usageNotes\n * Define an animation trigger in the `animations` section of `@Component` metadata.\n * In the template, reference the trigger by name and bind it to a trigger expression that\n * evaluates to a defined animation state, using the following format:\n *\n * `[@triggerName]=\"expression\"`\n *\n * Animation trigger bindings convert all values to strings, and then match the\n * previous and current values against any linked transitions.\n * Booleans can be specified as `1` or `true` and `0` or `false`.\n *\n * ### Usage Example\n *\n * The following example creates an animation trigger reference based on the provided\n * name value.\n * The provided animation value is expected to be an array consisting of state and\n * transition declarations.\n *\n * ```typescript\n * @Component({\n *   selector: \"my-component\",\n *   templateUrl: \"my-component-tpl.html\",\n *   animations: [\n *     trigger(\"myAnimationTrigger\", [\n *       state(...),\n *       state(...),\n *       transition(...),\n *       transition(...)\n *     ])\n *   ]\n * })\n * class MyComponent {\n *   myStatusExp = \"something\";\n * }\n * ```\n *\n * The template associated with this component makes use of the defined trigger\n * by binding to an element within its template code.\n *\n * ```html\n * <!-- somewhere inside of my-component-tpl.html -->\n * <div [@myAnimationTrigger]=\"myStatusExp\">...</div>\n * ```\n *\n * ### Using an inline function\n * The `transition` animation method also supports reading an inline function which can decide\n * if its associated animation should be run.\n *\n * ```typescript\n * // this method is run each time the `myAnimationTrigger` trigger value changes.\n * function myInlineMatcherFn(fromState: string, toState: string, element: any, params: {[key:\n string]: any}): boolean {\n *   // notice that `element` and `params` are also available here\n *   return toState == 'yes-please-animate';\n * }\n *\n * @Component({\n *   selector: 'my-component',\n *   templateUrl: 'my-component-tpl.html',\n *   animations: [\n *     trigger('myAnimationTrigger', [\n *       transition(myInlineMatcherFn, [\n *         // the animation sequence code\n *       ]),\n *     ])\n *   ]\n * })\n * class MyComponent {\n *   myStatusExp = \"yes-please-animate\";\n * }\n * ```\n *\n * ### Disabling Animations\n * When true, the special animation control binding `@.disabled` binding prevents\n * all animations from rendering.\n * Place the  `@.disabled` binding on an element to disable\n * animations on the element itself, as well as any inner animation triggers\n * within the element.\n *\n * The following example shows how to use this feature:\n *\n * ```typescript\n * @Component({\n *   selector: 'my-component',\n *   template: `\n *     <div [@.disabled]=\"isDisabled\">\n *       <div [@childAnimation]=\"exp\"></div>\n *     </div>\n *   `,\n *   animations: [\n *     trigger(\"childAnimation\", [\n *       // ...\n *     ])\n *   ]\n * })\n * class MyComponent {\n *   isDisabled = true;\n *   exp = '...';\n * }\n * ```\n *\n * When `@.disabled` is true, it prevents the `@childAnimation` trigger from animating,\n * along with any inner animations.\n *\n * ### Disable animations application-wide\n * When an area of the template is set to have animations disabled,\n * **all** inner components have their animations disabled as well.\n * This means that you can disable all animations for an app\n * by placing a host binding set on `@.disabled` on the topmost Angular component.\n *\n * ```typescript\n * import {Component, HostBinding} from '@angular/core';\n *\n * @Component({\n *   selector: 'app-component',\n *   templateUrl: 'app.component.html',\n * })\n * class AppComponent {\n *   @HostBinding('@.disabled')\n *   public animationsDisabled = true;\n * }\n * ```\n *\n * ### Overriding disablement of inner animations\n * Despite inner animations being disabled, a parent animation can `query()`\n * for inner elements located in disabled areas of the template and still animate\n * them if needed. This is also the case for when a sub animation is\n * queried by a parent and then later animated using `animateChild()`.\n *\n * ### Detecting when an animation is disabled\n * If a region of the DOM (or the entire application) has its animations disabled, the animation\n * trigger callbacks still fire, but for zero seconds. When the callback fires, it provides\n * an instance of an `AnimationEvent`. If animations are disabled,\n * the `.disabled` flag on the event is true.\n *\n * @publicApi\n */\nfunction trigger(name, definitions) {\n  return {\n    type: AnimationMetadataType.Trigger,\n    name,\n    definitions,\n    options: {}\n  };\n}\n/**\n * Defines an animation step that combines styling information with timing information.\n *\n * @param timings Sets `AnimateTimings` for the parent animation.\n * A string in the format \"duration [delay] [easing]\".\n *  - Duration and delay are expressed as a number and optional time unit,\n * such as \"1s\" or \"10ms\" for one second and 10 milliseconds, respectively.\n * The default unit is milliseconds.\n *  - The easing value controls how the animation accelerates and decelerates\n * during its runtime. Value is one of  `ease`, `ease-in`, `ease-out`,\n * `ease-in-out`, or a `cubic-bezier()` function call.\n * If not supplied, no easing is applied.\n *\n * For example, the string \"1s 100ms ease-out\" specifies a duration of\n * 1000 milliseconds, and delay of 100 ms, and the \"ease-out\" easing style,\n * which decelerates near the end of the duration.\n * @param styles Sets AnimationStyles for the parent animation.\n * A function call to either `style()` or `keyframes()`\n * that returns a collection of CSS style entries to be applied to the parent animation.\n * When null, uses the styles from the destination state.\n * This is useful when describing an animation step that will complete an animation;\n * see \"Animating to the final state\" in `transitions()`.\n * @returns An object that encapsulates the animation step.\n *\n * @usageNotes\n * Call within an animation `sequence()`, `{@link animations/group group()}`, or\n * `transition()` call to specify an animation step\n * that applies given style data to the parent animation for a given amount of time.\n *\n * ### Syntax Examples\n * **Timing examples**\n *\n * The following examples show various `timings` specifications.\n * - `animate(500)` : Duration is 500 milliseconds.\n * - `animate(\"1s\")` : Duration is 1000 milliseconds.\n * - `animate(\"100ms 0.5s\")` : Duration is 100 milliseconds, delay is 500 milliseconds.\n * - `animate(\"5s ease-in\")` : Duration is 5000 milliseconds, easing in.\n * - `animate(\"5s 10ms cubic-bezier(.17,.67,.88,.1)\")` : Duration is 5000 milliseconds, delay is 10\n * milliseconds, easing according to a bezier curve.\n *\n * **Style examples**\n *\n * The following example calls `style()` to set a single CSS style.\n * ```typescript\n * animate(500, style({ background: \"red\" }))\n * ```\n * The following example calls `keyframes()` to set a CSS style\n * to different values for successive keyframes.\n * ```typescript\n * animate(500, keyframes(\n *  [\n *   style({ background: \"blue\" }),\n *   style({ background: \"red\" })\n *  ])\n * ```\n *\n * @publicApi\n */\nfunction animate(timings, styles = null) {\n  return {\n    type: AnimationMetadataType.Animate,\n    styles,\n    timings\n  };\n}\n/**\n * @description Defines a list of animation steps to be run in parallel.\n *\n * @param steps An array of animation step objects.\n * - When steps are defined by `style()` or `animate()`\n * function calls, each call within the group is executed instantly.\n * - To specify offset styles to be applied at a later time, define steps with\n * `keyframes()`, or use `animate()` calls with a delay value.\n * For example:\n *\n * ```typescript\n * group([\n *   animate(\"1s\", style({ background: \"black\" })),\n *   animate(\"2s\", style({ color: \"white\" }))\n * ])\n * ```\n *\n * @param options An options object containing a delay and\n * developer-defined parameters that provide styling defaults and\n * can be overridden on invocation.\n *\n * @return An object that encapsulates the group data.\n *\n * @usageNotes\n * Grouped animations are useful when a series of styles must be\n * animated at different starting times and closed off at different ending times.\n *\n * When called within a `sequence()` or a\n * `transition()` call, does not continue to the next\n * instruction until all of the inner animation steps have completed.\n *\n * @publicApi\n */\nfunction group(steps, options = null) {\n  return {\n    type: AnimationMetadataType.Group,\n    steps,\n    options\n  };\n}\n/**\n * Defines a list of animation steps to be run sequentially, one by one.\n *\n * @param steps An array of animation step objects.\n * - Steps defined by `style()` calls apply the styling data immediately.\n * - Steps defined by `animate()` calls apply the styling data over time\n *   as specified by the timing data.\n *\n * ```typescript\n * sequence([\n *   style({ opacity: 0 }),\n *   animate(\"1s\", style({ opacity: 1 }))\n * ])\n * ```\n *\n * @param options An options object containing a delay and\n * developer-defined parameters that provide styling defaults and\n * can be overridden on invocation.\n *\n * @return An object that encapsulates the sequence data.\n *\n * @usageNotes\n * When you pass an array of steps to a\n * `transition()` call, the steps run sequentially by default.\n * Compare this to the `{@link animations/group group()}` call, which runs animation steps in\n *parallel.\n *\n * When a sequence is used within a `{@link animations/group group()}` or a `transition()` call,\n * execution continues to the next instruction only after each of the inner animation\n * steps have completed.\n *\n * @publicApi\n **/\nfunction sequence(steps, options = null) {\n  return {\n    type: AnimationMetadataType.Sequence,\n    steps,\n    options\n  };\n}\n/**\n * Declares a key/value object containing CSS properties/styles that\n * can then be used for an animation [`state`](api/animations/state), within an animation\n *`sequence`, or as styling data for calls to `animate()` and `keyframes()`.\n *\n * @param tokens A set of CSS styles or HTML styles associated with an animation state.\n * The value can be any of the following:\n * - A key-value style pair associating a CSS property with a value.\n * - An array of key-value style pairs.\n * - An asterisk (*), to use auto-styling, where styles are derived from the element\n * being animated and applied to the animation when it starts.\n *\n * Auto-styling can be used to define a state that depends on layout or other\n * environmental factors.\n *\n * @return An object that encapsulates the style data.\n *\n * @usageNotes\n * The following examples create animation styles that collect a set of\n * CSS property values:\n *\n * ```typescript\n * // string values for CSS properties\n * style({ background: \"red\", color: \"blue\" })\n *\n * // numerical pixel values\n * style({ width: 100, height: 0 })\n * ```\n *\n * The following example uses auto-styling to allow an element to animate from\n * a height of 0 up to its full height:\n *\n * ```\n * style({ height: 0 }),\n * animate(\"1s\", style({ height: \"*\" }))\n * ```\n *\n * @publicApi\n **/\nfunction style(tokens) {\n  return {\n    type: AnimationMetadataType.Style,\n    styles: tokens,\n    offset: null\n  };\n}\n/**\n * Declares an animation state within a trigger attached to an element.\n *\n * @param name One or more names for the defined state in a comma-separated string.\n * The following reserved state names can be supplied to define a style for specific use\n * cases:\n *\n * - `void` You can associate styles with this name to be used when\n * the element is detached from the application. For example, when an `ngIf` evaluates\n * to false, the state of the associated element is void.\n *  - `*` (asterisk) Indicates the default state. You can associate styles with this name\n * to be used as the fallback when the state that is being animated is not declared\n * within the trigger.\n *\n * @param styles A set of CSS styles associated with this state, created using the\n * `style()` function.\n * This set of styles persists on the element once the state has been reached.\n * @param options Parameters that can be passed to the state when it is invoked.\n * 0 or more key-value pairs.\n * @return An object that encapsulates the new state data.\n *\n * @usageNotes\n * Use the `trigger()` function to register states to an animation trigger.\n * Use the `transition()` function to animate between states.\n * When a state is active within a component, its associated styles persist on the element,\n * even when the animation ends.\n *\n * @publicApi\n **/\nfunction state(name, styles, options) {\n  return {\n    type: AnimationMetadataType.State,\n    name,\n    styles,\n    options\n  };\n}\n/**\n * Defines a set of animation styles, associating each style with an optional `offset` value.\n *\n * @param steps A set of animation styles with optional offset data.\n * The optional `offset` value for a style specifies a percentage of the total animation\n * time at which that style is applied.\n * @returns An object that encapsulates the keyframes data.\n *\n * @usageNotes\n * Use with the `animate()` call. Instead of applying animations\n * from the current state\n * to the destination state, keyframes describe how each style entry is applied and at what point\n * within the animation arc.\n * Compare [CSS Keyframe Animations](https://www.w3schools.com/css/css3_animations.asp).\n *\n * ### Usage\n *\n * In the following example, the offset values describe\n * when each `backgroundColor` value is applied. The color is red at the start, and changes to\n * blue when 20% of the total time has elapsed.\n *\n * ```typescript\n * // the provided offset values\n * animate(\"5s\", keyframes([\n *   style({ backgroundColor: \"red\", offset: 0 }),\n *   style({ backgroundColor: \"blue\", offset: 0.2 }),\n *   style({ backgroundColor: \"orange\", offset: 0.3 }),\n *   style({ backgroundColor: \"black\", offset: 1 })\n * ]))\n * ```\n *\n * If there are no `offset` values specified in the style entries, the offsets\n * are calculated automatically.\n *\n * ```typescript\n * animate(\"5s\", keyframes([\n *   style({ backgroundColor: \"red\" }) // offset = 0\n *   style({ backgroundColor: \"blue\" }) // offset = 0.33\n *   style({ backgroundColor: \"orange\" }) // offset = 0.66\n *   style({ backgroundColor: \"black\" }) // offset = 1\n * ]))\n *```\n\n * @publicApi\n */\nfunction keyframes(steps) {\n  return {\n    type: AnimationMetadataType.Keyframes,\n    steps\n  };\n}\n/**\n * Declares an animation transition which is played when a certain specified condition is met.\n *\n * @param stateChangeExpr A string with a specific format or a function that specifies when the\n * animation transition should occur (see [State Change Expression](#state-change-expression)).\n *\n * @param steps One or more animation objects that represent the animation's instructions.\n *\n * @param options An options object that can be used to specify a delay for the animation or provide\n * custom parameters for it.\n *\n * @returns An object that encapsulates the transition data.\n *\n * @usageNotes\n *\n * ### State Change Expression\n *\n * The State Change Expression instructs Angular when to run the transition's animations, it can\n *either be\n *  - a string with a specific syntax\n *  - or a function that compares the previous and current state (value of the expression bound to\n *    the element's trigger) and returns `true` if the transition should occur or `false` otherwise\n *\n * The string format can be:\n *  - `fromState => toState`, which indicates that the transition's animations should occur then the\n *    expression bound to the trigger's element goes from `fromState` to `toState`\n *\n *    _Example:_\n *      ```typescript\n *        transition('open => closed', animate('.5s ease-out', style({ height: 0 }) ))\n *      ```\n *\n *  - `fromState <=> toState`, which indicates that the transition's animations should occur then\n *    the expression bound to the trigger's element goes from `fromState` to `toState` or vice versa\n *\n *    _Example:_\n *      ```typescript\n *        transition('enabled <=> disabled', animate('1s cubic-bezier(0.8,0.3,0,1)'))\n *      ```\n *\n *  - `:enter`/`:leave`, which indicates that the transition's animations should occur when the\n *    element enters or exists the DOM\n *\n *    _Example:_\n *      ```typescript\n *        transition(':enter', [\n *          style({ opacity: 0 }),\n *          animate('500ms', style({ opacity: 1 }))\n *        ])\n *      ```\n *\n *  - `:increment`/`:decrement`, which indicates that the transition's animations should occur when\n *    the numerical expression bound to the trigger's element has increased in value or decreased\n *\n *    _Example:_\n *      ```typescript\n *        transition(':increment', query('@counter', animateChild()))\n *      ```\n *\n *  - a sequence of any of the above divided by commas, which indicates that transition's animations\n *    should occur whenever one of the state change expressions matches\n *\n *    _Example:_\n *      ```typescript\n *        transition(':increment, * => enabled, :enter', animate('1s ease', keyframes([\n *          style({ transform: 'scale(1)', offset: 0}),\n *          style({ transform: 'scale(1.1)', offset: 0.7}),\n *          style({ transform: 'scale(1)', offset: 1})\n *        ]))),\n *      ```\n *\n * Also note that in such context:\n *  - `void` can be used to indicate the absence of the element\n *  - asterisks can be used as wildcards that match any state\n *  - (as a consequence of the above, `void => *` is equivalent to `:enter` and `* => void` is\n *    equivalent to `:leave`)\n *  - `true` and `false` also match expression values of `1` and `0` respectively (but do not match\n *    _truthy_ and _falsy_ values)\n *\n * <div class=\"alert is-helpful\">\n *\n *  Be careful about entering end leaving elements as their transitions present a common\n *  pitfall for developers.\n *\n *  Note that when an element with a trigger enters the DOM its `:enter` transition always\n *  gets executed, but its `:leave` transition will not be executed if the element is removed\n *  alongside its parent (as it will be removed \"without warning\" before its transition has\n *  a chance to be executed, the only way that such transition can occur is if the element\n *  is exiting the DOM on its own).\n *\n *\n * </div>\n *\n * ### Animating to a Final State\n *\n * If the final step in a transition is a call to `animate()` that uses a timing value\n * with no `style` data, that step is automatically considered the final animation arc,\n * for the element to reach the final state, in such case Angular automatically adds or removes\n * CSS styles to ensure that the element is in the correct final state.\n *\n *\n * ### Usage Examples\n *\n *  - Transition animations applied based on\n *    the trigger's expression value\n *\n *   ```HTML\n *   <div [@myAnimationTrigger]=\"myStatusExp\">\n *    ...\n *   </div>\n *   ```\n *\n *   ```typescript\n *   trigger(\"myAnimationTrigger\", [\n *     ..., // states\n *     transition(\"on => off, open => closed\", animate(500)),\n *     transition(\"* <=> error\", query('.indicator', animateChild()))\n *   ])\n *   ```\n *\n *  - Transition animations applied based on custom logic dependent\n *    on the trigger's expression value and provided parameters\n *\n *    ```HTML\n *    <div [@myAnimationTrigger]=\"{\n *     value: stepName,\n *     params: { target: currentTarget }\n *    }\">\n *     ...\n *    </div>\n *    ```\n *\n *    ```typescript\n *    trigger(\"myAnimationTrigger\", [\n *      ..., // states\n *      transition(\n *        (fromState, toState, _element, params) =>\n *          ['firststep', 'laststep'].includes(fromState.toLowerCase())\n *          && toState === params?.['target'],\n *        animate('1s')\n *      )\n *    ])\n *    ```\n *\n * @publicApi\n **/\nfunction transition(stateChangeExpr, steps, options = null) {\n  return {\n    type: AnimationMetadataType.Transition,\n    expr: stateChangeExpr,\n    animation: steps,\n    options\n  };\n}\n/**\n * Produces a reusable animation that can be invoked in another animation or sequence,\n * by calling the `useAnimation()` function.\n *\n * @param steps One or more animation objects, as returned by the `animate()`\n * or `sequence()` function, that form a transformation from one state to another.\n * A sequence is used by default when you pass an array.\n * @param options An options object that can contain a delay value for the start of the\n * animation, and additional developer-defined parameters.\n * Provided values for additional parameters are used as defaults,\n * and override values can be passed to the caller on invocation.\n * @returns An object that encapsulates the animation data.\n *\n * @usageNotes\n * The following example defines a reusable animation, providing some default parameter\n * values.\n *\n * ```typescript\n * var fadeAnimation = animation([\n *   style({ opacity: '{{ start }}' }),\n *   animate('{{ time }}',\n *   style({ opacity: '{{ end }}'}))\n *   ],\n *   { params: { time: '1000ms', start: 0, end: 1 }});\n * ```\n *\n * The following invokes the defined animation with a call to `useAnimation()`,\n * passing in override parameter values.\n *\n * ```js\n * useAnimation(fadeAnimation, {\n *   params: {\n *     time: '2s',\n *     start: 1,\n *     end: 0\n *   }\n * })\n * ```\n *\n * If any of the passed-in parameter values are missing from this call,\n * the default values are used. If one or more parameter values are missing before a step is\n * animated, `useAnimation()` throws an error.\n *\n * @publicApi\n */\nfunction animation(steps, options = null) {\n  return {\n    type: AnimationMetadataType.Reference,\n    animation: steps,\n    options\n  };\n}\n/**\n * Executes a queried inner animation element within an animation sequence.\n *\n * @param options An options object that can contain a delay value for the start of the\n * animation, and additional override values for developer-defined parameters.\n * @return An object that encapsulates the child animation data.\n *\n * @usageNotes\n * Each time an animation is triggered in Angular, the parent animation\n * has priority and any child animations are blocked. In order\n * for a child animation to run, the parent animation must query each of the elements\n * containing child animations, and run them using this function.\n *\n * Note that this feature is designed to be used with `query()` and it will only work\n * with animations that are assigned using the Angular animation library. CSS keyframes\n * and transitions are not handled by this API.\n *\n * @publicApi\n */\nfunction animateChild(options = null) {\n  return {\n    type: AnimationMetadataType.AnimateChild,\n    options\n  };\n}\n/**\n * Starts a reusable animation that is created using the `animation()` function.\n *\n * @param animation The reusable animation to start.\n * @param options An options object that can contain a delay value for the start of\n * the animation, and additional override values for developer-defined parameters.\n * @return An object that contains the animation parameters.\n *\n * @publicApi\n */\nfunction useAnimation(animation, options = null) {\n  return {\n    type: AnimationMetadataType.AnimateRef,\n    animation,\n    options\n  };\n}\n/**\n * Finds one or more inner elements within the current element that is\n * being animated within a sequence. Use with `animate()`.\n *\n * @param selector The element to query, or a set of elements that contain Angular-specific\n * characteristics, specified with one or more of the following tokens.\n *  - `query(\":enter\")` or `query(\":leave\")` : Query for newly inserted/removed elements (not\n *     all elements can be queried via these tokens, see\n *     [Entering and Leaving Elements](#entering-and-leaving-elements))\n *  - `query(\":animating\")` : Query all currently animating elements.\n *  - `query(\"@triggerName\")` : Query elements that contain an animation trigger.\n *  - `query(\"@*\")` : Query all elements that contain an animation triggers.\n *  - `query(\":self\")` : Include the current element into the animation sequence.\n *\n * @param animation One or more animation steps to apply to the queried element or elements.\n * An array is treated as an animation sequence.\n * @param options An options object. Use the 'limit' field to limit the total number of\n * items to collect.\n * @return An object that encapsulates the query data.\n *\n * @usageNotes\n *\n * ### Multiple Tokens\n *\n * Tokens can be merged into a combined query selector string. For example:\n *\n * ```typescript\n *  query(':self, .record:enter, .record:leave, @subTrigger', [...])\n * ```\n *\n * The `query()` function collects multiple elements and works internally by using\n * `element.querySelectorAll`. Use the `limit` field of an options object to limit\n * the total number of items to be collected. For example:\n *\n * ```js\n * query('div', [\n *   animate(...),\n *   animate(...)\n * ], { limit: 1 })\n * ```\n *\n * By default, throws an error when zero items are found. Set the\n * `optional` flag to ignore this error. For example:\n *\n * ```js\n * query('.some-element-that-may-not-be-there', [\n *   animate(...),\n *   animate(...)\n * ], { optional: true })\n * ```\n *\n * ### Entering and Leaving Elements\n *\n * Not all elements can be queried via the `:enter` and `:leave` tokens, the only ones\n * that can are those that Angular assumes can enter/leave based on their own logic\n * (if their insertion/removal is simply a consequence of that of their parent they\n * should be queried via a different token in their parent's `:enter`/`:leave` transitions).\n *\n * The only elements Angular assumes can enter/leave based on their own logic (thus the only\n * ones that can be queried via the `:enter` and `:leave` tokens) are:\n *  - Those inserted dynamically (via `ViewContainerRef`)\n *  - Those that have a structural directive (which, under the hood, are a subset of the above ones)\n *\n * <div class=\"alert is-helpful\">\n *\n *  Note that elements will be successfully queried via `:enter`/`:leave` even if their\n *  insertion/removal is not done manually via `ViewContainerRef`or caused by their structural\n *  directive (e.g. they enter/exit alongside their parent).\n *\n * </div>\n *\n * <div class=\"alert is-important\">\n *\n *  There is an exception to what previously mentioned, besides elements entering/leaving based on\n *  their own logic, elements with an animation trigger can always be queried via `:leave` when\n * their parent is also leaving.\n *\n * </div>\n *\n * ### Usage Example\n *\n * The following example queries for inner elements and animates them\n * individually using `animate()`.\n *\n * ```typescript\n * @Component({\n *   selector: 'inner',\n *   template: `\n *     <div [@queryAnimation]=\"exp\">\n *       <h1>Title</h1>\n *       <div class=\"content\">\n *         Blah blah blah\n *       </div>\n *     </div>\n *   `,\n *   animations: [\n *    trigger('queryAnimation', [\n *      transition('* => goAnimate', [\n *        // hide the inner elements\n *        query('h1', style({ opacity: 0 })),\n *        query('.content', style({ opacity: 0 })),\n *\n *        // animate the inner elements in, one by one\n *        query('h1', animate(1000, style({ opacity: 1 }))),\n *        query('.content', animate(1000, style({ opacity: 1 }))),\n *      ])\n *    ])\n *  ]\n * })\n * class Cmp {\n *   exp = '';\n *\n *   goAnimate() {\n *     this.exp = 'goAnimate';\n *   }\n * }\n * ```\n *\n * @publicApi\n */\nfunction query(selector, animation, options = null) {\n  return {\n    type: AnimationMetadataType.Query,\n    selector,\n    animation,\n    options\n  };\n}\n/**\n * Use within an animation `query()` call to issue a timing gap after\n * each queried item is animated.\n *\n * @param timings A delay value.\n * @param animation One ore more animation steps.\n * @returns An object that encapsulates the stagger data.\n *\n * @usageNotes\n * In the following example, a container element wraps a list of items stamped out\n * by an `ngFor`. The container element contains an animation trigger that will later be set\n * to query for each of the inner items.\n *\n * Each time items are added, the opacity fade-in animation runs,\n * and each removed item is faded out.\n * When either of these animations occur, the stagger effect is\n * applied after each item's animation is started.\n *\n * ```html\n * <!-- list.component.html -->\n * <button (click)=\"toggle()\">Show / Hide Items</button>\n * <hr />\n * <div [@listAnimation]=\"items.length\">\n *   <div *ngFor=\"let item of items\">\n *     {{ item }}\n *   </div>\n * </div>\n * ```\n *\n * Here is the component code:\n *\n * ```typescript\n * import {trigger, transition, style, animate, query, stagger} from '@angular/animations';\n * @Component({\n *   templateUrl: 'list.component.html',\n *   animations: [\n *     trigger('listAnimation', [\n *     ...\n *     ])\n *   ]\n * })\n * class ListComponent {\n *   items = [];\n *\n *   showItems() {\n *     this.items = [0,1,2,3,4];\n *   }\n *\n *   hideItems() {\n *     this.items = [];\n *   }\n *\n *   toggle() {\n *     this.items.length ? this.hideItems() : this.showItems();\n *    }\n *  }\n * ```\n *\n * Here is the animation trigger code:\n *\n * ```typescript\n * trigger('listAnimation', [\n *   transition('* => *', [ // each time the binding value changes\n *     query(':leave', [\n *       stagger(100, [\n *         animate('0.5s', style({ opacity: 0 }))\n *       ])\n *     ]),\n *     query(':enter', [\n *       style({ opacity: 0 }),\n *       stagger(100, [\n *         animate('0.5s', style({ opacity: 1 }))\n *       ])\n *     ])\n *   ])\n * ])\n * ```\n *\n * @publicApi\n */\nfunction stagger(timings, animation) {\n  return {\n    type: AnimationMetadataType.Stagger,\n    timings,\n    animation\n  };\n}\n\n/**\n * An injectable service that produces an animation sequence programmatically within an\n * Angular component or directive.\n * Provided by the `BrowserAnimationsModule` or `NoopAnimationsModule`.\n *\n * @usageNotes\n *\n * To use this service, add it to your component or directive as a dependency.\n * The service is instantiated along with your component.\n *\n * Apps do not typically need to create their own animation players, but if you\n * do need to, follow these steps:\n *\n * 1. Use the <code>[AnimationBuilder.build](api/animations/AnimationBuilder#build)()</code> method\n * to create a programmatic animation. The method returns an `AnimationFactory` instance.\n *\n * 2. Use the factory object to create an `AnimationPlayer` and attach it to a DOM element.\n *\n * 3. Use the player object to control the animation programmatically.\n *\n * For example:\n *\n * ```ts\n * // import the service from BrowserAnimationsModule\n * import {AnimationBuilder} from '@angular/animations';\n * // require the service as a dependency\n * class MyCmp {\n *   constructor(private _builder: AnimationBuilder) {}\n *\n *   makeAnimation(element: any) {\n *     // first define a reusable animation\n *     const myAnimation = this._builder.build([\n *       style({ width: 0 }),\n *       animate(1000, style({ width: '100px' }))\n *     ]);\n *\n *     // use the returned factory object to create a player\n *     const player = myAnimation.create(element);\n *\n *     player.play();\n *   }\n * }\n * ```\n *\n * @publicApi\n */\nlet AnimationBuilder = /*#__PURE__*/(() => {\n  class AnimationBuilder {\n    static {\n      this.ɵfac = function AnimationBuilder_Factory(t) {\n        return new (t || AnimationBuilder)();\n      };\n    }\n    static {\n      this.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n        token: AnimationBuilder,\n        factory: () => (() => inject(BrowserAnimationBuilder))(),\n        providedIn: 'root'\n      });\n    }\n  }\n  return AnimationBuilder;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n/**\n * A factory object returned from the\n * <code>[AnimationBuilder.build](api/animations/AnimationBuilder#build)()</code>\n * method.\n *\n * @publicApi\n */\nclass AnimationFactory {}\nlet BrowserAnimationBuilder = /*#__PURE__*/(() => {\n  class BrowserAnimationBuilder extends AnimationBuilder {\n    constructor(rootRenderer, doc) {\n      super();\n      this.animationModuleType = inject(ANIMATION_MODULE_TYPE, {\n        optional: true\n      });\n      this._nextAnimationId = 0;\n      const typeData = {\n        id: '0',\n        encapsulation: ViewEncapsulation.None,\n        styles: [],\n        data: {\n          animation: []\n        }\n      };\n      this._renderer = rootRenderer.createRenderer(doc.body, typeData);\n      if (this.animationModuleType === null && !isAnimationRenderer(this._renderer)) {\n        // We only support AnimationRenderer & DynamicDelegationRenderer for this AnimationBuilder\n        throw new ɵRuntimeError(3600 /* RuntimeErrorCode.BROWSER_ANIMATION_BUILDER_INJECTED_WITHOUT_ANIMATIONS */, (typeof ngDevMode === 'undefined' || ngDevMode) && 'Angular detected that the `AnimationBuilder` was injected, but animation support was not enabled. ' + 'Please make sure that you enable animations in your application by calling `provideAnimations()` or `provideAnimationsAsync()` function.');\n      }\n    }\n    build(animation) {\n      const id = this._nextAnimationId;\n      this._nextAnimationId++;\n      const entry = Array.isArray(animation) ? sequence(animation) : animation;\n      issueAnimationCommand(this._renderer, null, id, 'register', [entry]);\n      return new BrowserAnimationFactory(id, this._renderer);\n    }\n    static {\n      this.ɵfac = function BrowserAnimationBuilder_Factory(t) {\n        return new (t || BrowserAnimationBuilder)(i0.ɵɵinject(i0.RendererFactory2), i0.ɵɵinject(DOCUMENT));\n      };\n    }\n    static {\n      this.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n        token: BrowserAnimationBuilder,\n        factory: BrowserAnimationBuilder.ɵfac,\n        providedIn: 'root'\n      });\n    }\n  }\n  return BrowserAnimationBuilder;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nclass BrowserAnimationFactory extends AnimationFactory {\n  constructor(_id, _renderer) {\n    super();\n    this._id = _id;\n    this._renderer = _renderer;\n  }\n  create(element, options) {\n    return new RendererAnimationPlayer(this._id, element, options || {}, this._renderer);\n  }\n}\nclass RendererAnimationPlayer {\n  constructor(id, element, options, _renderer) {\n    this.id = id;\n    this.element = element;\n    this._renderer = _renderer;\n    this.parentPlayer = null;\n    this._started = false;\n    this.totalTime = 0;\n    this._command('create', options);\n  }\n  _listen(eventName, callback) {\n    return this._renderer.listen(this.element, `@@${this.id}:${eventName}`, callback);\n  }\n  _command(command, ...args) {\n    issueAnimationCommand(this._renderer, this.element, this.id, command, args);\n  }\n  onDone(fn) {\n    this._listen('done', fn);\n  }\n  onStart(fn) {\n    this._listen('start', fn);\n  }\n  onDestroy(fn) {\n    this._listen('destroy', fn);\n  }\n  init() {\n    this._command('init');\n  }\n  hasStarted() {\n    return this._started;\n  }\n  play() {\n    this._command('play');\n    this._started = true;\n  }\n  pause() {\n    this._command('pause');\n  }\n  restart() {\n    this._command('restart');\n  }\n  finish() {\n    this._command('finish');\n  }\n  destroy() {\n    this._command('destroy');\n  }\n  reset() {\n    this._command('reset');\n    this._started = false;\n  }\n  setPosition(p) {\n    this._command('setPosition', p);\n  }\n  getPosition() {\n    return unwrapAnimationRenderer(this._renderer)?.engine?.players[this.id]?.getPosition() ?? 0;\n  }\n}\nfunction issueAnimationCommand(renderer, element, id, command, args) {\n  renderer.setProperty(element, `@@${id}:${command}`, args);\n}\n/**\n * The following 2 methods cannot reference their correct types (AnimationRenderer &\n * DynamicDelegationRenderer) since this would introduce a import cycle.\n */\nfunction unwrapAnimationRenderer(renderer) {\n  const type = renderer.ɵtype;\n  if (type === 0 /* AnimationRendererType.Regular */) {\n    return renderer;\n  } else if (type === 1 /* AnimationRendererType.Delegated */) {\n    return renderer.animationRenderer;\n  }\n  return null;\n}\nfunction isAnimationRenderer(renderer) {\n  const type = renderer.ɵtype;\n  return type === 0 /* AnimationRendererType.Regular */ || type === 1 /* AnimationRendererType.Delegated */;\n}\n\n/**\n * An empty programmatic controller for reusable animations.\n * Used internally when animations are disabled, to avoid\n * checking for the null case when an animation player is expected.\n *\n * @see {@link animate}\n * @see {@link AnimationPlayer}\n * @see {@link ɵAnimationGroupPlayer AnimationGroupPlayer}\n *\n * @publicApi\n */\nclass NoopAnimationPlayer {\n  constructor(duration = 0, delay = 0) {\n    this._onDoneFns = [];\n    this._onStartFns = [];\n    this._onDestroyFns = [];\n    this._originalOnDoneFns = [];\n    this._originalOnStartFns = [];\n    this._started = false;\n    this._destroyed = false;\n    this._finished = false;\n    this._position = 0;\n    this.parentPlayer = null;\n    this.totalTime = duration + delay;\n  }\n  _onFinish() {\n    if (!this._finished) {\n      this._finished = true;\n      this._onDoneFns.forEach(fn => fn());\n      this._onDoneFns = [];\n    }\n  }\n  onStart(fn) {\n    this._originalOnStartFns.push(fn);\n    this._onStartFns.push(fn);\n  }\n  onDone(fn) {\n    this._originalOnDoneFns.push(fn);\n    this._onDoneFns.push(fn);\n  }\n  onDestroy(fn) {\n    this._onDestroyFns.push(fn);\n  }\n  hasStarted() {\n    return this._started;\n  }\n  init() {}\n  play() {\n    if (!this.hasStarted()) {\n      this._onStart();\n      this.triggerMicrotask();\n    }\n    this._started = true;\n  }\n  /** @internal */\n  triggerMicrotask() {\n    queueMicrotask(() => this._onFinish());\n  }\n  _onStart() {\n    this._onStartFns.forEach(fn => fn());\n    this._onStartFns = [];\n  }\n  pause() {}\n  restart() {}\n  finish() {\n    this._onFinish();\n  }\n  destroy() {\n    if (!this._destroyed) {\n      this._destroyed = true;\n      if (!this.hasStarted()) {\n        this._onStart();\n      }\n      this.finish();\n      this._onDestroyFns.forEach(fn => fn());\n      this._onDestroyFns = [];\n    }\n  }\n  reset() {\n    this._started = false;\n    this._finished = false;\n    this._onStartFns = this._originalOnStartFns;\n    this._onDoneFns = this._originalOnDoneFns;\n  }\n  setPosition(position) {\n    this._position = this.totalTime ? position * this.totalTime : 1;\n  }\n  getPosition() {\n    return this.totalTime ? this._position / this.totalTime : 1;\n  }\n  /** @internal */\n  triggerCallback(phaseName) {\n    const methods = phaseName == 'start' ? this._onStartFns : this._onDoneFns;\n    methods.forEach(fn => fn());\n    methods.length = 0;\n  }\n}\n\n/**\n * A programmatic controller for a group of reusable animations.\n * Used internally to control animations.\n *\n * @see {@link AnimationPlayer}\n * @see {@link animations/group group}\n *\n */\nclass AnimationGroupPlayer {\n  constructor(_players) {\n    this._onDoneFns = [];\n    this._onStartFns = [];\n    this._finished = false;\n    this._started = false;\n    this._destroyed = false;\n    this._onDestroyFns = [];\n    this.parentPlayer = null;\n    this.totalTime = 0;\n    this.players = _players;\n    let doneCount = 0;\n    let destroyCount = 0;\n    let startCount = 0;\n    const total = this.players.length;\n    if (total == 0) {\n      queueMicrotask(() => this._onFinish());\n    } else {\n      this.players.forEach(player => {\n        player.onDone(() => {\n          if (++doneCount == total) {\n            this._onFinish();\n          }\n        });\n        player.onDestroy(() => {\n          if (++destroyCount == total) {\n            this._onDestroy();\n          }\n        });\n        player.onStart(() => {\n          if (++startCount == total) {\n            this._onStart();\n          }\n        });\n      });\n    }\n    this.totalTime = this.players.reduce((time, player) => Math.max(time, player.totalTime), 0);\n  }\n  _onFinish() {\n    if (!this._finished) {\n      this._finished = true;\n      this._onDoneFns.forEach(fn => fn());\n      this._onDoneFns = [];\n    }\n  }\n  init() {\n    this.players.forEach(player => player.init());\n  }\n  onStart(fn) {\n    this._onStartFns.push(fn);\n  }\n  _onStart() {\n    if (!this.hasStarted()) {\n      this._started = true;\n      this._onStartFns.forEach(fn => fn());\n      this._onStartFns = [];\n    }\n  }\n  onDone(fn) {\n    this._onDoneFns.push(fn);\n  }\n  onDestroy(fn) {\n    this._onDestroyFns.push(fn);\n  }\n  hasStarted() {\n    return this._started;\n  }\n  play() {\n    if (!this.parentPlayer) {\n      this.init();\n    }\n    this._onStart();\n    this.players.forEach(player => player.play());\n  }\n  pause() {\n    this.players.forEach(player => player.pause());\n  }\n  restart() {\n    this.players.forEach(player => player.restart());\n  }\n  finish() {\n    this._onFinish();\n    this.players.forEach(player => player.finish());\n  }\n  destroy() {\n    this._onDestroy();\n  }\n  _onDestroy() {\n    if (!this._destroyed) {\n      this._destroyed = true;\n      this._onFinish();\n      this.players.forEach(player => player.destroy());\n      this._onDestroyFns.forEach(fn => fn());\n      this._onDestroyFns = [];\n    }\n  }\n  reset() {\n    this.players.forEach(player => player.reset());\n    this._destroyed = false;\n    this._finished = false;\n    this._started = false;\n  }\n  setPosition(p) {\n    const timeAtPosition = p * this.totalTime;\n    this.players.forEach(player => {\n      const position = player.totalTime ? Math.min(1, timeAtPosition / player.totalTime) : 1;\n      player.setPosition(position);\n    });\n  }\n  getPosition() {\n    const longestPlayer = this.players.reduce((longestSoFar, player) => {\n      const newPlayerIsLongest = longestSoFar === null || player.totalTime > longestSoFar.totalTime;\n      return newPlayerIsLongest ? player : longestSoFar;\n    }, null);\n    return longestPlayer != null ? longestPlayer.getPosition() : 0;\n  }\n  beforeDestroy() {\n    this.players.forEach(player => {\n      if (player.beforeDestroy) {\n        player.beforeDestroy();\n      }\n    });\n  }\n  /** @internal */\n  triggerCallback(phaseName) {\n    const methods = phaseName == 'start' ? this._onStartFns : this._onDoneFns;\n    methods.forEach(fn => fn());\n    methods.length = 0;\n  }\n}\nconst ɵPRE_STYLE = '!';\n\n/**\n * @module\n * @description\n * Entry point for all animation APIs of the animation package.\n */\n\n/**\n * @module\n * @description\n * Entry point for all public APIs of this package.\n */\n\n// This file is not used to build this module. It is only used during editing\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { AUTO_STYLE, AnimationBuilder, AnimationFactory, AnimationMetadataType, NoopAnimationPlayer, animate, animateChild, animation, group, keyframes, query, sequence, stagger, state, style, transition, trigger, useAnimation, AnimationGroupPlayer as ɵAnimationGroupPlayer, BrowserAnimationBuilder as ɵBrowserAnimationBuilder, ɵPRE_STYLE };\n","/**\n * @dynamic is for runtime initializing DomHandler.browser\n *\n * If delete below comment, we can see this error message:\n *  Metadata collected contains an error that will be reported at runtime:\n *  Only initialized variables and constants can be referenced\n *  because the value of this variable is needed by the template compiler.\n */\n// @dynamic\nlet DomHandler = /*#__PURE__*/(() => {\n  class DomHandler {\n    static zindex = 1000;\n    static calculatedScrollbarWidth = null;\n    static calculatedScrollbarHeight = null;\n    static browser;\n    static addClass(element, className) {\n      if (element && className) {\n        if (element.classList) element.classList.add(className);else element.className += ' ' + className;\n      }\n    }\n    static addMultipleClasses(element, className) {\n      if (element && className) {\n        if (element.classList) {\n          let styles = className.trim().split(' ');\n          for (let i = 0; i < styles.length; i++) {\n            element.classList.add(styles[i]);\n          }\n        } else {\n          let styles = className.split(' ');\n          for (let i = 0; i < styles.length; i++) {\n            element.className += ' ' + styles[i];\n          }\n        }\n      }\n    }\n    static removeClass(element, className) {\n      if (element && className) {\n        if (element.classList) element.classList.remove(className);else element.className = element.className.replace(new RegExp('(^|\\\\b)' + className.split(' ').join('|') + '(\\\\b|$)', 'gi'), ' ');\n      }\n    }\n    static removeMultipleClasses(element, classNames) {\n      if (element && classNames) {\n        [classNames].flat().filter(Boolean).forEach(cNames => cNames.split(' ').forEach(className => this.removeClass(element, className)));\n      }\n    }\n    static hasClass(element, className) {\n      if (element && className) {\n        if (element.classList) return element.classList.contains(className);else return new RegExp('(^| )' + className + '( |$)', 'gi').test(element.className);\n      }\n      return false;\n    }\n    static siblings(element) {\n      return Array.prototype.filter.call(element.parentNode.children, function (child) {\n        return child !== element;\n      });\n    }\n    static find(element, selector) {\n      return Array.from(element.querySelectorAll(selector));\n    }\n    static findSingle(element, selector) {\n      return this.isElement(element) ? element.querySelector(selector) : null;\n    }\n    static index(element) {\n      let children = element.parentNode.childNodes;\n      let num = 0;\n      for (var i = 0; i < children.length; i++) {\n        if (children[i] == element) return num;\n        if (children[i].nodeType == 1) num++;\n      }\n      return -1;\n    }\n    static indexWithinGroup(element, attributeName) {\n      let children = element.parentNode ? element.parentNode.childNodes : [];\n      let num = 0;\n      for (var i = 0; i < children.length; i++) {\n        if (children[i] == element) return num;\n        if (children[i].attributes && children[i].attributes[attributeName] && children[i].nodeType == 1) num++;\n      }\n      return -1;\n    }\n    static appendOverlay(overlay, target, appendTo = 'self') {\n      if (appendTo !== 'self' && overlay && target) {\n        this.appendChild(overlay, target);\n      }\n    }\n    static alignOverlay(overlay, target, appendTo = 'self', calculateMinWidth = true) {\n      if (overlay && target) {\n        if (calculateMinWidth) {\n          overlay.style.minWidth = `${DomHandler.getOuterWidth(target)}px`;\n        }\n        if (appendTo === 'self') {\n          this.relativePosition(overlay, target);\n        } else {\n          this.absolutePosition(overlay, target);\n        }\n      }\n    }\n    static relativePosition(element, target) {\n      const getClosestRelativeElement = el => {\n        if (!el) return;\n        return getComputedStyle(el).getPropertyValue('position') === 'relative' ? el : getClosestRelativeElement(el.parentElement);\n      };\n      const elementDimensions = element.offsetParent ? {\n        width: element.offsetWidth,\n        height: element.offsetHeight\n      } : this.getHiddenElementDimensions(element);\n      const targetHeight = target.offsetHeight;\n      const targetOffset = target.getBoundingClientRect();\n      const windowScrollTop = this.getWindowScrollTop();\n      const windowScrollLeft = this.getWindowScrollLeft();\n      const viewport = this.getViewport();\n      const relativeElement = getClosestRelativeElement(element);\n      const relativeElementOffset = relativeElement?.getBoundingClientRect() || {\n        top: -1 * windowScrollTop,\n        left: -1 * windowScrollLeft\n      };\n      let top, left;\n      if (targetOffset.top + targetHeight + elementDimensions.height > viewport.height) {\n        top = targetOffset.top - relativeElementOffset.top - elementDimensions.height;\n        element.style.transformOrigin = 'bottom';\n        if (targetOffset.top + top < 0) {\n          top = -1 * targetOffset.top;\n        }\n      } else {\n        top = targetHeight + targetOffset.top - relativeElementOffset.top;\n        element.style.transformOrigin = 'top';\n      }\n      const horizontalOverflow = targetOffset.left + elementDimensions.width - viewport.width;\n      const targetLeftOffsetInSpaceOfRelativeElement = targetOffset.left - relativeElementOffset.left;\n      if (elementDimensions.width > viewport.width) {\n        // element wider then viewport and cannot fit on screen (align at left side of viewport)\n        left = (targetOffset.left - relativeElementOffset.left) * -1;\n      } else if (horizontalOverflow > 0) {\n        // element wider then viewport but can be fit on screen (align at right side of viewport)\n        left = targetLeftOffsetInSpaceOfRelativeElement - horizontalOverflow;\n      } else {\n        // element fits on screen (align with target)\n        left = targetOffset.left - relativeElementOffset.left;\n      }\n      element.style.top = top + 'px';\n      element.style.left = left + 'px';\n    }\n    static absolutePosition(element, target) {\n      const elementDimensions = element.offsetParent ? {\n        width: element.offsetWidth,\n        height: element.offsetHeight\n      } : this.getHiddenElementDimensions(element);\n      const elementOuterHeight = elementDimensions.height;\n      const elementOuterWidth = elementDimensions.width;\n      const targetOuterHeight = target.offsetHeight;\n      const targetOuterWidth = target.offsetWidth;\n      const targetOffset = target.getBoundingClientRect();\n      const windowScrollTop = this.getWindowScrollTop();\n      const windowScrollLeft = this.getWindowScrollLeft();\n      const viewport = this.getViewport();\n      let top, left;\n      if (targetOffset.top + targetOuterHeight + elementOuterHeight > viewport.height) {\n        top = targetOffset.top + windowScrollTop - elementOuterHeight;\n        element.style.transformOrigin = 'bottom';\n        if (top < 0) {\n          top = windowScrollTop;\n        }\n      } else {\n        top = targetOuterHeight + targetOffset.top + windowScrollTop;\n        element.style.transformOrigin = 'top';\n      }\n      if (targetOffset.left + elementOuterWidth > viewport.width) left = Math.max(0, targetOffset.left + windowScrollLeft + targetOuterWidth - elementOuterWidth);else left = targetOffset.left + windowScrollLeft;\n      element.style.top = top + 'px';\n      element.style.left = left + 'px';\n    }\n    static getParents(element, parents = []) {\n      return element['parentNode'] === null ? parents : this.getParents(element.parentNode, parents.concat([element.parentNode]));\n    }\n    static getScrollableParents(element) {\n      let scrollableParents = [];\n      if (element) {\n        let parents = this.getParents(element);\n        const overflowRegex = /(auto|scroll)/;\n        const overflowCheck = node => {\n          let styleDeclaration = window['getComputedStyle'](node, null);\n          return overflowRegex.test(styleDeclaration.getPropertyValue('overflow')) || overflowRegex.test(styleDeclaration.getPropertyValue('overflowX')) || overflowRegex.test(styleDeclaration.getPropertyValue('overflowY'));\n        };\n        for (let parent of parents) {\n          let scrollSelectors = parent.nodeType === 1 && parent.dataset['scrollselectors'];\n          if (scrollSelectors) {\n            let selectors = scrollSelectors.split(',');\n            for (let selector of selectors) {\n              let el = this.findSingle(parent, selector);\n              if (el && overflowCheck(el)) {\n                scrollableParents.push(el);\n              }\n            }\n          }\n          if (parent.nodeType !== 9 && overflowCheck(parent)) {\n            scrollableParents.push(parent);\n          }\n        }\n      }\n      return scrollableParents;\n    }\n    static getHiddenElementOuterHeight(element) {\n      element.style.visibility = 'hidden';\n      element.style.display = 'block';\n      let elementHeight = element.offsetHeight;\n      element.style.display = 'none';\n      element.style.visibility = 'visible';\n      return elementHeight;\n    }\n    static getHiddenElementOuterWidth(element) {\n      element.style.visibility = 'hidden';\n      element.style.display = 'block';\n      let elementWidth = element.offsetWidth;\n      element.style.display = 'none';\n      element.style.visibility = 'visible';\n      return elementWidth;\n    }\n    static getHiddenElementDimensions(element) {\n      let dimensions = {};\n      element.style.visibility = 'hidden';\n      element.style.display = 'block';\n      dimensions.width = element.offsetWidth;\n      dimensions.height = element.offsetHeight;\n      element.style.display = 'none';\n      element.style.visibility = 'visible';\n      return dimensions;\n    }\n    static scrollInView(container, item) {\n      let borderTopValue = getComputedStyle(container).getPropertyValue('borderTopWidth');\n      let borderTop = borderTopValue ? parseFloat(borderTopValue) : 0;\n      let paddingTopValue = getComputedStyle(container).getPropertyValue('paddingTop');\n      let paddingTop = paddingTopValue ? parseFloat(paddingTopValue) : 0;\n      let containerRect = container.getBoundingClientRect();\n      let itemRect = item.getBoundingClientRect();\n      let offset = itemRect.top + document.body.scrollTop - (containerRect.top + document.body.scrollTop) - borderTop - paddingTop;\n      let scroll = container.scrollTop;\n      let elementHeight = container.clientHeight;\n      let itemHeight = this.getOuterHeight(item);\n      if (offset < 0) {\n        container.scrollTop = scroll + offset;\n      } else if (offset + itemHeight > elementHeight) {\n        container.scrollTop = scroll + offset - elementHeight + itemHeight;\n      }\n    }\n    static fadeIn(element, duration) {\n      element.style.opacity = 0;\n      let last = +new Date();\n      let opacity = 0;\n      let tick = function () {\n        opacity = +element.style.opacity.replace(',', '.') + (new Date().getTime() - last) / duration;\n        element.style.opacity = opacity;\n        last = +new Date();\n        if (+opacity < 1) {\n          window.requestAnimationFrame && requestAnimationFrame(tick) || setTimeout(tick, 16);\n        }\n      };\n      tick();\n    }\n    static fadeOut(element, ms) {\n      var opacity = 1,\n        interval = 50,\n        duration = ms,\n        gap = interval / duration;\n      let fading = setInterval(() => {\n        opacity = opacity - gap;\n        if (opacity <= 0) {\n          opacity = 0;\n          clearInterval(fading);\n        }\n        element.style.opacity = opacity;\n      }, interval);\n    }\n    static getWindowScrollTop() {\n      let doc = document.documentElement;\n      return (window.pageYOffset || doc.scrollTop) - (doc.clientTop || 0);\n    }\n    static getWindowScrollLeft() {\n      let doc = document.documentElement;\n      return (window.pageXOffset || doc.scrollLeft) - (doc.clientLeft || 0);\n    }\n    static matches(element, selector) {\n      var p = Element.prototype;\n      var f = p['matches'] || p.webkitMatchesSelector || p['mozMatchesSelector'] || p['msMatchesSelector'] || function (s) {\n        return [].indexOf.call(document.querySelectorAll(s), this) !== -1;\n      };\n      return f.call(element, selector);\n    }\n    static getOuterWidth(el, margin) {\n      let width = el.offsetWidth;\n      if (margin) {\n        let style = getComputedStyle(el);\n        width += parseFloat(style.marginLeft) + parseFloat(style.marginRight);\n      }\n      return width;\n    }\n    static getHorizontalPadding(el) {\n      let style = getComputedStyle(el);\n      return parseFloat(style.paddingLeft) + parseFloat(style.paddingRight);\n    }\n    static getHorizontalMargin(el) {\n      let style = getComputedStyle(el);\n      return parseFloat(style.marginLeft) + parseFloat(style.marginRight);\n    }\n    static innerWidth(el) {\n      let width = el.offsetWidth;\n      let style = getComputedStyle(el);\n      width += parseFloat(style.paddingLeft) + parseFloat(style.paddingRight);\n      return width;\n    }\n    static width(el) {\n      let width = el.offsetWidth;\n      let style = getComputedStyle(el);\n      width -= parseFloat(style.paddingLeft) + parseFloat(style.paddingRight);\n      return width;\n    }\n    static getInnerHeight(el) {\n      let height = el.offsetHeight;\n      let style = getComputedStyle(el);\n      height += parseFloat(style.paddingTop) + parseFloat(style.paddingBottom);\n      return height;\n    }\n    static getOuterHeight(el, margin) {\n      let height = el.offsetHeight;\n      if (margin) {\n        let style = getComputedStyle(el);\n        height += parseFloat(style.marginTop) + parseFloat(style.marginBottom);\n      }\n      return height;\n    }\n    static getHeight(el) {\n      let height = el.offsetHeight;\n      let style = getComputedStyle(el);\n      height -= parseFloat(style.paddingTop) + parseFloat(style.paddingBottom) + parseFloat(style.borderTopWidth) + parseFloat(style.borderBottomWidth);\n      return height;\n    }\n    static getWidth(el) {\n      let width = el.offsetWidth;\n      let style = getComputedStyle(el);\n      width -= parseFloat(style.paddingLeft) + parseFloat(style.paddingRight) + parseFloat(style.borderLeftWidth) + parseFloat(style.borderRightWidth);\n      return width;\n    }\n    static getViewport() {\n      let win = window,\n        d = document,\n        e = d.documentElement,\n        g = d.getElementsByTagName('body')[0],\n        w = win.innerWidth || e.clientWidth || g.clientWidth,\n        h = win.innerHeight || e.clientHeight || g.clientHeight;\n      return {\n        width: w,\n        height: h\n      };\n    }\n    static getOffset(el) {\n      var rect = el.getBoundingClientRect();\n      return {\n        top: rect.top + (window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0),\n        left: rect.left + (window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft || 0)\n      };\n    }\n    static replaceElementWith(element, replacementElement) {\n      let parentNode = element.parentNode;\n      if (!parentNode) throw `Can't replace element`;\n      return parentNode.replaceChild(replacementElement, element);\n    }\n    static getUserAgent() {\n      if (navigator && this.isClient()) {\n        return navigator.userAgent;\n      }\n    }\n    static isIE() {\n      var ua = window.navigator.userAgent;\n      var msie = ua.indexOf('MSIE ');\n      if (msie > 0) {\n        // IE 10 or older => return version number\n        return true;\n      }\n      var trident = ua.indexOf('Trident/');\n      if (trident > 0) {\n        // IE 11 => return version number\n        var rv = ua.indexOf('rv:');\n        return true;\n      }\n      var edge = ua.indexOf('Edge/');\n      if (edge > 0) {\n        // Edge (IE 12+) => return version number\n        return true;\n      }\n      // other browser\n      return false;\n    }\n    static isIOS() {\n      return /iPad|iPhone|iPod/.test(navigator.userAgent) && !window['MSStream'];\n    }\n    static isAndroid() {\n      return /(android)/i.test(navigator.userAgent);\n    }\n    static isTouchDevice() {\n      return 'ontouchstart' in window || navigator.maxTouchPoints > 0;\n    }\n    static appendChild(element, target) {\n      if (this.isElement(target)) target.appendChild(element);else if (target && target.el && target.el.nativeElement) target.el.nativeElement.appendChild(element);else throw 'Cannot append ' + target + ' to ' + element;\n    }\n    static removeChild(element, target) {\n      if (this.isElement(target)) target.removeChild(element);else if (target.el && target.el.nativeElement) target.el.nativeElement.removeChild(element);else throw 'Cannot remove ' + element + ' from ' + target;\n    }\n    static removeElement(element) {\n      if (!('remove' in Element.prototype)) element.parentNode.removeChild(element);else element.remove();\n    }\n    static isElement(obj) {\n      return typeof HTMLElement === 'object' ? obj instanceof HTMLElement : obj && typeof obj === 'object' && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === 'string';\n    }\n    static calculateScrollbarWidth(el) {\n      if (el) {\n        let style = getComputedStyle(el);\n        return el.offsetWidth - el.clientWidth - parseFloat(style.borderLeftWidth) - parseFloat(style.borderRightWidth);\n      } else {\n        if (this.calculatedScrollbarWidth !== null) return this.calculatedScrollbarWidth;\n        let scrollDiv = document.createElement('div');\n        scrollDiv.className = 'p-scrollbar-measure';\n        document.body.appendChild(scrollDiv);\n        let scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;\n        document.body.removeChild(scrollDiv);\n        this.calculatedScrollbarWidth = scrollbarWidth;\n        return scrollbarWidth;\n      }\n    }\n    static calculateScrollbarHeight() {\n      if (this.calculatedScrollbarHeight !== null) return this.calculatedScrollbarHeight;\n      let scrollDiv = document.createElement('div');\n      scrollDiv.className = 'p-scrollbar-measure';\n      document.body.appendChild(scrollDiv);\n      let scrollbarHeight = scrollDiv.offsetHeight - scrollDiv.clientHeight;\n      document.body.removeChild(scrollDiv);\n      this.calculatedScrollbarWidth = scrollbarHeight;\n      return scrollbarHeight;\n    }\n    static invokeElementMethod(element, methodName, args) {\n      element[methodName].apply(element, args);\n    }\n    static clearSelection() {\n      if (window.getSelection) {\n        if (window.getSelection().empty) {\n          window.getSelection().empty();\n        } else if (window.getSelection().removeAllRanges && window.getSelection().rangeCount > 0 && window.getSelection().getRangeAt(0).getClientRects().length > 0) {\n          window.getSelection().removeAllRanges();\n        }\n      } else if (document['selection'] && document['selection'].empty) {\n        try {\n          document['selection'].empty();\n        } catch (error) {\n          //ignore IE bug\n        }\n      }\n    }\n    static getBrowser() {\n      if (!this.browser) {\n        let matched = this.resolveUserAgent();\n        this.browser = {};\n        if (matched.browser) {\n          this.browser[matched.browser] = true;\n          this.browser['version'] = matched.version;\n        }\n        if (this.browser['chrome']) {\n          this.browser['webkit'] = true;\n        } else if (this.browser['webkit']) {\n          this.browser['safari'] = true;\n        }\n      }\n      return this.browser;\n    }\n    static resolveUserAgent() {\n      let ua = navigator.userAgent.toLowerCase();\n      let match = /(chrome)[ \\/]([\\w.]+)/.exec(ua) || /(webkit)[ \\/]([\\w.]+)/.exec(ua) || /(opera)(?:.*version|)[ \\/]([\\w.]+)/.exec(ua) || /(msie) ([\\w.]+)/.exec(ua) || ua.indexOf('compatible') < 0 && /(mozilla)(?:.*? rv:([\\w.]+)|)/.exec(ua) || [];\n      return {\n        browser: match[1] || '',\n        version: match[2] || '0'\n      };\n    }\n    static isInteger(value) {\n      if (Number.isInteger) {\n        return Number.isInteger(value);\n      } else {\n        return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;\n      }\n    }\n    static isHidden(element) {\n      return !element || element.offsetParent === null;\n    }\n    static isVisible(element) {\n      return element && element.offsetParent != null;\n    }\n    static isExist(element) {\n      return element !== null && typeof element !== 'undefined' && element.nodeName && element.parentNode;\n    }\n    static focus(element, options) {\n      element && document.activeElement !== element && element.focus(options);\n    }\n    static getFocusableElements(element, selector = '') {\n      let focusableElements = this.find(element, `button:not([tabindex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])${selector},\n                [href][clientHeight][clientWidth]:not([tabindex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])${selector},\n                input:not([tabindex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])${selector},\n                select:not([tabindex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])${selector},\n                textarea:not([tabindex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])${selector},\n                [tabIndex]:not([tabIndex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])${selector},\n                [contenteditable]:not([tabIndex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])${selector}`);\n      let visibleFocusableElements = [];\n      for (let focusableElement of focusableElements) {\n        const computedStyle = getComputedStyle(focusableElement);\n        if (this.isVisible(focusableElement) && computedStyle.display != 'none' && computedStyle.visibility != 'hidden') visibleFocusableElements.push(focusableElement);\n      }\n      return visibleFocusableElements;\n    }\n    static getFirstFocusableElement(element, selector) {\n      const focusableElements = this.getFocusableElements(element, selector);\n      return focusableElements.length > 0 ? focusableElements[0] : null;\n    }\n    static getLastFocusableElement(element, selector) {\n      const focusableElements = this.getFocusableElements(element, selector);\n      return focusableElements.length > 0 ? focusableElements[focusableElements.length - 1] : null;\n    }\n    static getNextFocusableElement(element, reverse = false) {\n      const focusableElements = DomHandler.getFocusableElements(element);\n      let index = 0;\n      if (focusableElements && focusableElements.length > 0) {\n        const focusedIndex = focusableElements.indexOf(focusableElements[0].ownerDocument.activeElement);\n        if (reverse) {\n          if (focusedIndex == -1 || focusedIndex === 0) {\n            index = focusableElements.length - 1;\n          } else {\n            index = focusedIndex - 1;\n          }\n        } else if (focusedIndex != -1 && focusedIndex !== focusableElements.length - 1) {\n          index = focusedIndex + 1;\n        }\n      }\n      return focusableElements[index];\n    }\n    static generateZIndex() {\n      this.zindex = this.zindex || 999;\n      return ++this.zindex;\n    }\n    static getSelection() {\n      if (window.getSelection) return window.getSelection().toString();else if (document.getSelection) return document.getSelection().toString();else if (document['selection']) return document['selection'].createRange().text;\n      return null;\n    }\n    static getTargetElement(target, el) {\n      if (!target) return null;\n      switch (target) {\n        case 'document':\n          return document;\n        case 'window':\n          return window;\n        case '@next':\n          return el?.nextElementSibling;\n        case '@prev':\n          return el?.previousElementSibling;\n        case '@parent':\n          return el?.parentElement;\n        case '@grandparent':\n          return el?.parentElement.parentElement;\n        default:\n          const type = typeof target;\n          if (type === 'string') {\n            return document.querySelector(target);\n          } else if (type === 'object' && target.hasOwnProperty('nativeElement')) {\n            return this.isExist(target.nativeElement) ? target.nativeElement : undefined;\n          }\n          const isFunction = obj => !!(obj && obj.constructor && obj.call && obj.apply);\n          const element = isFunction(target) ? target() : target;\n          return element && element.nodeType === 9 || this.isExist(element) ? element : null;\n      }\n    }\n    static isClient() {\n      return !!(typeof window !== 'undefined' && window.document && window.document.createElement);\n    }\n    static getAttribute(element, name) {\n      if (element) {\n        const value = element.getAttribute(name);\n        if (!isNaN(value)) {\n          return +value;\n        }\n        if (value === 'true' || value === 'false') {\n          return value === 'true';\n        }\n        return value;\n      }\n      return undefined;\n    }\n    static calculateBodyScrollbarWidth() {\n      return window.innerWidth - document.documentElement.offsetWidth;\n    }\n    static blockBodyScroll(className = 'p-overflow-hidden') {\n      document.body.style.setProperty('--scrollbar-width', this.calculateBodyScrollbarWidth() + 'px');\n      this.addClass(document.body, className);\n    }\n    static unblockBodyScroll(className = 'p-overflow-hidden') {\n      document.body.style.removeProperty('--scrollbar-width');\n      this.removeClass(document.body, className);\n    }\n  }\n  return DomHandler;\n})();\nclass ConnectedOverlayScrollHandler {\n  element;\n  listener;\n  scrollableParents;\n  constructor(element, listener = () => {}) {\n    this.element = element;\n    this.listener = listener;\n  }\n  bindScrollListener() {\n    this.scrollableParents = DomHandler.getScrollableParents(this.element);\n    for (let i = 0; i < this.scrollableParents.length; i++) {\n      this.scrollableParents[i].addEventListener('scroll', this.listener);\n    }\n  }\n  unbindScrollListener() {\n    if (this.scrollableParents) {\n      for (let i = 0; i < this.scrollableParents.length; i++) {\n        this.scrollableParents[i].removeEventListener('scroll', this.listener);\n      }\n    }\n  }\n  destroy() {\n    this.unbindScrollListener();\n    this.element = null;\n    this.listener = null;\n    this.scrollableParents = null;\n  }\n}\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { ConnectedOverlayScrollHandler, DomHandler };\n","import * as i0 from '@angular/core';\nimport { Component, ChangeDetectionStrategy, ViewEncapsulation, Input } from '@angular/core';\nimport { ObjectUtils } from 'primeng/utils';\nconst _c0 = [\"*\"];\nlet BaseIcon = /*#__PURE__*/(() => {\n  class BaseIcon {\n    label;\n    spin = false;\n    styleClass;\n    role;\n    ariaLabel;\n    ariaHidden;\n    ngOnInit() {\n      this.getAttributes();\n    }\n    getAttributes() {\n      const isLabelEmpty = ObjectUtils.isEmpty(this.label);\n      this.role = !isLabelEmpty ? 'img' : undefined;\n      this.ariaLabel = !isLabelEmpty ? this.label : undefined;\n      this.ariaHidden = isLabelEmpty;\n    }\n    getClassNames() {\n      return `p-icon ${this.styleClass ? this.styleClass + ' ' : ''}${this.spin ? 'p-icon-spin' : ''}`;\n    }\n    static ɵfac = function BaseIcon_Factory(t) {\n      return new (t || BaseIcon)();\n    };\n    static ɵcmp = /* @__PURE__ */i0.ɵɵdefineComponent({\n      type: BaseIcon,\n      selectors: [[\"ng-component\"]],\n      hostAttrs: [1, \"p-element\", \"p-icon-wrapper\"],\n      inputs: {\n        label: \"label\",\n        spin: \"spin\",\n        styleClass: \"styleClass\"\n      },\n      standalone: true,\n      features: [i0.ɵɵStandaloneFeature],\n      ngContentSelectors: _c0,\n      decls: 1,\n      vars: 0,\n      template: function BaseIcon_Template(rf, ctx) {\n        if (rf & 1) {\n          i0.ɵɵprojectionDef();\n          i0.ɵɵprojection(0);\n        }\n      },\n      encapsulation: 2,\n      changeDetection: 0\n    });\n  }\n  return BaseIcon;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { BaseIcon };\n"],"mappings":"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","names":["init_define_NGX_ENV","AnimationMetadataType","AUTO_STYLE","trigger","name","definitions","animate","timings","styles","sequence","steps","options","AnimationMetadataType","style","tokens","state","name","styles","transition","stateChangeExpr","steps","options","AnimationMetadataType","animation","animateChild","useAnimation","query","selector","NoopAnimationPlayer","duration","delay","fn","position","phaseName","methods","AnimationGroupPlayer","_players","doneCount","destroyCount","startCount","total","player","time","p","timeAtPosition","longestPlayer","longestSoFar","ɵPRE_STYLE","init_define_NGX_ENV","DomHandler","element","className","styles","i","classNames","cNames","child","selector","children","num","attributeName","overlay","target","appendTo","calculateMinWidth","getClosestRelativeElement","el","elementDimensions","targetHeight","targetOffset","windowScrollTop","windowScrollLeft","viewport","relativeElementOffset","top","left","horizontalOverflow","targetLeftOffsetInSpaceOfRelativeElement","elementOuterHeight","elementOuterWidth","targetOuterHeight","targetOuterWidth","parents","scrollableParents","overflowRegex","overflowCheck","node","styleDeclaration","parent","scrollSelectors","selectors","elementHeight","elementWidth","dimensions","container","item","borderTopValue","borderTop","paddingTopValue","paddingTop","containerRect","offset","scroll","itemHeight","duration","last","opacity","tick","ms","interval","gap","fading","doc","p","f","s","margin","width","style","height","win","d","e","g","w","h","rect","replacementElement","parentNode","ua","msie","trident","rv","edge","obj","scrollDiv","scrollbarWidth","scrollbarHeight","methodName","args","matched","match","value","options","focusableElements","visibleFocusableElements","focusableElement","computedStyle","reverse","index","focusedIndex","type","name","ConnectedOverlayScrollHandler","listener","init_define_NGX_ENV","_c0","BaseIcon","isLabelEmpty","ObjectUtils","t","ɵɵdefineComponent","ɵɵStandaloneFeature","rf","ctx","ɵɵprojectionDef","ɵɵprojection"],"x_google_ignoreList":[0,1,2]}