http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/f85188ec/node_modules/@angular/animations/bundles/animations.umd.min.js.map
----------------------------------------------------------------------
diff --git a/node_modules/@angular/animations/bundles/animations.umd.min.js.map
b/node_modules/@angular/animations/bundles/animations.umd.min.js.map
index 42dc35f..68c277c 100644
--- a/node_modules/@angular/animations/bundles/animations.umd.min.js.map
+++ b/node_modules/@angular/animations/bundles/animations.umd.min.js.map
@@ -1 +1 @@
-{"version":3,"file":"animations.umd.min.js","sources":["../../../../packages/animations/src/players/animation_player.ts","../../../../packages/animations/src/players/animation_group_player.ts","../../../../packages/animations/src/animation_builder.ts"],"sourcesContent":["/**\n
* @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this
source code is governed by an MIT-style license that can be\n * found in the
LICENSE file at https://angular.io/license\n */\n\nimport {scheduleMicroTask}
from '../util';\n\n/**\n * AnimationPlayer controls an animation sequence that
was produced from a programmatic animation.\n * (see {@link AnimationBuilder
AnimationBuilder} for more information on how to create programmatic\n *
animations.)\n *\n * @experimental Animation support is experimental.\n
*/\nexport interface AnimationPlayer {\n onDone(fn: () => void): void;\n
onStart(fn: () => void): void;\n onDestroy(fn: () => void): void;\n init():
void;\n hasStarted(): boolean;\
n play(): void;\n pause(): void;\n restart(): void;\n finish(): void;\n
destroy(): void;\n reset(): void;\n setPosition(p: any /** TODO #9100 */):
void;\n getPosition(): number;\n parentPlayer: AnimationPlayer|null;\n
readonly totalTime: number;\n beforeDestroy?: () => any;\n}\n/**\n *
\\@experimental Animation support is experimental.\n */\nexport class
NoopAnimationPlayer implements AnimationPlayer {\nprivate _onDoneFns:
Function[] = [];\nprivate _onStartFns: Function[] = [];\nprivate _onDestroyFns:
Function[] = [];\nprivate _started = false;\nprivate _destroyed =
false;\nprivate _finished = false;\npublic parentPlayer: AnimationPlayer|null =
null;\npublic totalTime = 0;\nconstructor() {}\n/**\n * @return {?}\n
*/\nprivate _onFinish() {\n if (!this._finished) {\n this._finished =
true;\n this._onDoneFns.forEach(fn => fn());\n this._onDoneFns =
[];\n }\n }\n/**\n * @param {?} fn\n * @return {?}\n */\nonStart(fn: () =>
void): void { this._onStartFns.
push(fn); }\n/**\n * @param {?} fn\n * @return {?}\n */\nonDone(fn: () =>
void): void { this._onDoneFns.push(fn); }\n/**\n * @param {?} fn\n * @return
{?}\n */\nonDestroy(fn: () => void): void { this._onDestroyFns.push(fn);
}\n/**\n * @return {?}\n */\nhasStarted(): boolean { return this._started;
}\n/**\n * @return {?}\n */\ninit(): void {}\n/**\n * @return {?}\n */\nplay():
void {\n if (!this.hasStarted()) {\n this.triggerMicrotask();\n
this._onStart();\n }\n this._started = true;\n }\n/**\n * @return {?}\n
*/\ntriggerMicrotask() { scheduleMicroTask(() => this._onFinish()); }\n/**\n *
@return {?}\n */\nprivate _onStart() {\n this._onStartFns.forEach(fn =>
fn());\n this._onStartFns = [];\n }\n/**\n * @return {?}\n */\npause():
void {}\n/**\n * @return {?}\n */\nrestart(): void {}\n/**\n * @return {?}\n
*/\nfinish(): void { this._onFinish(); }\n/**\n * @return {?}\n */\ndestroy():
void {\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/**\n * @return {?}\n */\nreset(): void
{}\n/**\n * @param {?} p\n * @return {?}\n */\nsetPosition(p: number): void
{}\n/**\n * @return {?}\n */\ngetPosition(): number { return 0;
}\n}\n\nfunction NoopAnimationPlayer_tsickle_Closure_declarations() {\n/**
@type {?} */\nNoopAnimationPlayer.prototype._onDoneFns;\n/** @type {?}
*/\nNoopAnimationPlayer.prototype._onStartFns;\n/** @type {?}
*/\nNoopAnimationPlayer.prototype._onDestroyFns;\n/** @type {?}
*/\nNoopAnimationPlayer.prototype._started;\n/** @type {?}
*/\nNoopAnimationPlayer.prototype._destroyed;\n/** @type {?}
*/\nNoopAnimationPlayer.prototype._finished;\n/** @type {?}
*/\nNoopAnimationPlayer.prototype.parentPlayer;\n/** @type {?}
*/\nNoopAnimationPlayer.prototype.totalTime;\n}\n\n","/**\n * @license\n *
Copyright Google Inc. All Rights Reserved.\n *\n * Use
of this source code is governed by an MIT-style license that can be\n * found
in the LICENSE file at https://angular.io/license\n */\n\n\nimport
{scheduleMicroTask} from '../util';\nimport {AnimationPlayer} from
'./animation_player';\nexport class AnimationGroupPlayer implements
AnimationPlayer {\nprivate _onDoneFns: Function[] = [];\nprivate _onStartFns:
Function[] = [];\nprivate _finished = false;\nprivate _started =
false;\nprivate _destroyed = false;\nprivate _onDestroyFns: Function[] =
[];\npublic parentPlayer: AnimationPlayer|null = null;\npublic totalTime:
number = 0;\n/**\n * @param {?} _players\n */\nconstructor(private _players:
AnimationPlayer[]) {\n let doneCount = 0;\n let destroyCount = 0;\n
let startCount = 0;\n const total = this._players.length;\n\n if (total
== 0) {\n scheduleMicroTask(() => this._onFinish());\n } else {\n
this._players.forEach(player => {\n player.parentPlayer = this;\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\n
this.totalTime = this._players.reduce((time, player) => Math.max(time,
player.totalTime), 0);\n }\n/**\n * @return {?}\n */\nprivate _onFinish() {\n
if (!this._finished) {\n this._finished = true;\n
this._onDoneFns.forEach(fn => fn());\n this._onDoneFns = [];\n }\n
}\n/**\n * @return {?}\n */\ninit(): void { this._players.forEach(player =>
player.init()); }\n/**\n * @param {?} fn\n * @return {?}\n */\nonStart(fn: ()
=> void): void { this._onStartFns.push(fn); }\n/**\n * @return {?}\n
*/\nprivate _onStart() {\n if (!this.hasStarted()) {\n
this._onStartFns.forEach(fn => fn());\n this._o
nStartFns = [];\n this._started = true;\n }\n }\n/**\n * @param {?}
fn\n * @return {?}\n */\nonDone(fn: () => void): void {
this._onDoneFns.push(fn); }\n/**\n * @param {?} fn\n * @return {?}\n
*/\nonDestroy(fn: () => void): void { this._onDestroyFns.push(fn); }\n/**\n *
@return {?}\n */\nhasStarted() { return this._started; }\n/**\n * @return {?}\n
*/\nplay() {\n if (!this.parentPlayer) {\n this.init();\n }\n
this._onStart();\n this._players.forEach(player => player.play());\n
}\n/**\n * @return {?}\n */\npause(): void { this._players.forEach(player =>
player.pause()); }\n/**\n * @return {?}\n */\nrestart(): void {
this._players.forEach(player => player.restart()); }\n/**\n * @return {?}\n
*/\nfinish(): void {\n this._onFinish();\n this._players.forEach(player
=> player.finish());\n }\n/**\n * @return {?}\n */\ndestroy(): void {
this._onDestroy(); }\n/**\n * @return {?}\n */\nprivate _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/**\n * @return {?}\n */\nreset(): void
{\n this._players.forEach(player => player.reset());\n this._destroyed =
false;\n this._finished = false;\n this._started = false;\n }\n/**\n *
@param {?} p\n * @return {?}\n */\nsetPosition(p: number): void {\n const
/** @type {?} */ timeAtPosition = p * this.totalTime;\n
this._players.forEach(player => {\n const /** @type {?} */ position =
player.totalTime ? Math.min(1, timeAtPosition / player.totalTime) : 1;\n
player.setPosition(position);\n });\n }\n/**\n * @return {?}\n
*/\ngetPosition(): number {\n let /** @type {?} */ min = 0;\n
this._players.forEach(player => {\n const /** @type {?} */ p =
player.getPosition();\n min = Math.min(p, min);\n });\n return
min;\n }\n/**\n * @return {?}\n */\nget players()
: AnimationPlayer[] { return this._players; }\n/**\n * @return {?}\n
*/\nbeforeDestroy(): void {\n this.players.forEach(player => {\n if
(player.beforeDestroy) {\n player.beforeDestroy();\n }\n });\n
}\n}\n\nfunction AnimationGroupPlayer_tsickle_Closure_declarations() {\n/**
@type {?} */\nAnimationGroupPlayer.prototype._onDoneFns;\n/** @type {?}
*/\nAnimationGroupPlayer.prototype._onStartFns;\n/** @type {?}
*/\nAnimationGroupPlayer.prototype._finished;\n/** @type {?}
*/\nAnimationGroupPlayer.prototype._started;\n/** @type {?}
*/\nAnimationGroupPlayer.prototype._destroyed;\n/** @type {?}
*/\nAnimationGroupPlayer.prototype._onDestroyFns;\n/** @type {?}
*/\nAnimationGroupPlayer.prototype.parentPlayer;\n/** @type {?}
*/\nAnimationGroupPlayer.prototype.totalTime;\n/** @type {?}
*/\nAnimationGroupPlayer.prototype._players;\n}\n\n","/**\n * @license\n *
Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is
governed by an MIT-style license tha
t can be\n * found in the LICENSE file at https://angular.io/license\n
*/\n\nimport {AnimationMetadata, AnimationOptions} from
'./animation_metadata';\nimport {AnimationPlayer} from
'./players/animation_player';\n/**\n * AnimationBuilder is an injectable
service that is available when the {\\@link\n * BrowserAnimationsModule
BrowserAnimationsModule} or {\\@link NoopAnimationsModule\n *
NoopAnimationsModule} modules are used within an application.\n * \n * The
purpose if this service is to produce an animation sequence programmatically
within an\n * angular component or directive.\n * \n * Programmatic animations
are first built and then a player is created when the build animation is\n *
attached to an element.\n * \n * ```ts\n * // remember to include the
BrowserAnimationsModule module for this to work...\n * import
{AnimationBuilder} from '\\@angular/animations';\n * \n * class MyCmp {\n *
constructor(private _builder: AnimationBuilder) {}\n * \n *
makeAnimation(element: any)
{\n * // first build the animation\n * const myAnimation =
this._builder.build([\n * style({ width: 0 }),\n * animate(1000,
style({ width: '100px' }))\n * ]);\n * \n * // then create a player
from it\n * const player = myAnimation.create(element);\n * \n *
player.play();\n * }\n * }\n * ```\n * \n * When an animation is built an
instance of {\\@link AnimationFactory AnimationFactory} will be\n * returned.
Using that an {\\@link AnimationPlayer AnimationPlayer} can be created which
can then be\n * used to start the animation.\n * \n * \\@experimental Animation
support is experimental.\n * @abstract\n */\nexport abstract class
AnimationBuilder {\n/**\n * @abstract\n * @param {?} animation\n * @return
{?}\n */\nbuild(animation: AnimationMetadata|AnimationMetadata[]) {}\n}\n/**\n
* An instance of `AnimationFactory` is returned from {\\@link
AnimationBuilder#build\n * AnimationBuilder.build}.\n * \n * \\@experimental
Animation support is experimental
.\n * @abstract\n */\nexport abstract class AnimationFactory {\n/**\n *
@abstract\n * @param {?} element\n * @param {?=} options\n * @return {?}\n
*/\ncreate(element: any, options?: AnimationOptions)
{}\n}\n"],"names":["NoopAnimationPlayer","this","_onDestroyFns","_started","totalTime","_finished","prototype","onStart","fn","_onStartFns","push","init","play","finish","_onFinish","destroy","_onStart","reset","AnimationGroupPlayer","_players","_this","_onDoneFns","_destroyed","parentPlayer","doneCount","destroyCount","startCount","total","length","scheduleMicroTask","forEach","player","onDone","onDestroy","_onDestroy","reduce","time","Math","max","hasStarted","setPosition","p","timeAtPosition","min","getPosition","configurable","beforeDestroy","exports","module","factory"],"mappings":";;;;;0BEAA,gBAAA+C,UAAA,mBAAAC,QAAAC,QAAAF;;;;;;;;;;;;;;;;;;;;;iSF+CA/C,oBAAA,iFACAC,KAAGC,iBAIHD,KAAAE,UAAA,8DAIAF,KAAAG,UAAA,4DAMAH,KAAAI,sGAUAL,oBAAAM,UAAAC,QAAA,SAAAC,IAAAP,KAAAQ,YAAAC,KAAAF,6OAkBAR,
oBAAAM,UAAAK,KAAA,aAIAX,oBAAAM,UAAAM,KAAA,wEAKAX,KAAAE,UAAA,oWAwBAH,oBAAAM,UAAAO,OAAA,WAAAZ,KAAAa,aAIAd,oBAAAM,UAAAS,QAAA,mEArCAd,KAAAe,uGAmDAhB,oBAAAM,UAAAW,MAAA,2JC9HAC,qBAAA,WAKA,QAAAA,sBAAAC,UAII,GAAIC,OAARnB,IACIA,MAAJkB,SAAAA,SACIlB,KAAJoB,cACIpB,KAAJQ,eAEIR,KAAJI,WAAA,EACAJ,KAAAE,UAAA,EACAF,KAAAqB,YAAA,EAAArB,KAAAC,iBACAD,KAAAsB,aAAA,KACAtB,KAAAG,UAAA,CACA,IAAAoB,WAAA,EACAC,aAAA,EACAC,WAAA,EACAC,MAAA1B,KAAAkB,SAAAS,MACA,IAAAD,MACAE,kBAAA,WAAA,MAAAT,OAAAN,cAGAb,KAAAkB,SAAAW,QAAA,SAAAC,QACAA,OAAAR,aAAAH,MACQW,OAAOC,OAAf,aACgBR,WAAhBG,OACYP,MAAKN,cAGjBiB,OAAAE,UAAA,aACAR,cAAAE,OAEAP,MAAyBc,8DAEzBd,MAAAJ,eAQAf,KAAAG,UAAAH,KAAAkB,SAAAgB,OAAA,SAAAC,KAAAL,QAAA,MAAAM,MAAAC,IAAAF,KAAAL,OAAA3B,YAAA,SAKAc,sBAAAZ,UAAAQ,UAAA,sHAUAI,qBAAAZ,UAAAK,KAAA,WAAAV,KAVckB,SAUdW,QAAA,SAAAC,QAAA,MAAAA,QAAApB,UAKAO,qBAAAZ,UAAAC,QAAA,SAAAC,IAAAP,KAAAQ,YAAAC,KAAAF,wDAKAP,KAAAsC,0QAmBArB,qBAAAZ,UAAAiC,WAAA,WAAA,MAAAtC,MAAAE,UAIAe,qBAAAZ,UAAAM,KAAA,+ZAoBAX,KAAAkB,SAAAW,QAAA,SAAAC,QAAA,MAAAA,QAAAlB,YAKAK,q
BAAAZ,UAAAS,QAAA,WAAAd,KAAAiC,qFA1BAjC,KAAAqB,YAAA,EAiCArB,KAAAa,2JASAI,qBAAAZ,UAAAW,MAAA,iIAUAC,qBAAAZ,UAAAkC,YAAA,SAAAC,GACA,GAAAC,gBAAAD,EAAAxC,KAAAG,mNA7BG,GAAHuC,KAAA,gDA4CA,GAAAF,GAAAV,OAAAa,4JAIAC,cAAA,wHA/JAd,OAAAe"}
\ No newline at end of file
+{"version":3,"sources":["animations.umd.js"],"names":["global","factory","exports","module","define","amd","ng","animations","this","trigger","name","definitions","type","options","animate","timings","styles","group","steps","sequence","style","tokens","offset","state","keyframes","transition","stateChangeExpr","expr","animation","animateChild","useAnimation","query","selector","stagger","scheduleMicroTask","cb","Promise","resolve","then","AnimationBuilder","AnimationFactory","NoopAnimationPlayer","_onDoneFns","_onStartFns","_onDestroyFns","_started","_destroyed","_finished","parentPlayer","totalTime","prototype","_onFinish","forEach","fn","onStart","push","onDone","onDestroy","hasStarted","init","play","_onStart","triggerMicrotask","_this","pause","restart","finish","destroy","reset","setPosition","p","getPosition","triggerCallback","phaseName","methods","length","AnimationGroupPlayer","_players","players","doneCount","destroyCount","startCount","total","player","_onDestroy","reduc
e","time","Math","max","timeAtPosition","position","min","beforeDestroy","AUTO_STYLE","ɵAnimationGroupPlayer","ɵPRE_STYLE","Object","defineProperty","value"],"mappings":"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","file":"animations.umd.min.js","sourcesContent":["/**\n
* @license Angular v5.2.10\n * (c) 2010-2018 Google, Inc.
https://angular.io/\n * License: MIT\n *
/\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof
module !== 'undefined' ? factory(exports) :\n\ttypeof define === 'function' &&
define.amd ? define('@angular/animations', ['exports'], factory)
:\n\t(factory((global.ng = global.ng || {}, global.ng.animations =
{})));\n}(this, (function (exports) { 'use strict';\n\n/**\n * @license Angular
v5.2.10\n * (c) 2010-2018 Google, Inc. https://angular.io/\n * License: MIT\n
*/\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked
by tsc\n */\n/**\n * AnimationBuilder is an injectable service that is
available when the {\\@link\n * BrowserAnimationsModule
BrowserAnimationsModule} or {\\@link NoopAnimationsModule\n *
NoopAnimationsModule} modules are used within an application.\n *\n * The
purpose if this service is to produce an animation sequence programmatically
within an\n * angular component or directive.\n *\n * Programmatic animations
are first built and then a player is created when the buil
d animation is\n * attached to an element.\n *\n * ```ts\n * // remember to
include the BrowserAnimationsModule module for this to work...\n * import
{AnimationBuilder} from '\\@angular/animations';\n *\n * class MyCmp {\n *
constructor(private _builder: AnimationBuilder) {}\n *\n *
makeAnimation(element: any) {\n * // first build the animation\n *
const myAnimation = this._builder.build([\n * style({ width: 0 }),\n *
animate(1000, style({ width: '100px' }))\n * ]);\n *\n * // then
create a player from it\n * const player = myAnimation.create(element);\n
*\n * player.play();\n * }\n * }\n * ```\n *\n * When an animation is
built an instance of {\\@link AnimationFactory AnimationFactory} will be\n *
returned. Using that an {\\@link AnimationPlayer AnimationPlayer} can be
created which can then be\n * used to start the animation.\n *\n *
\\@experimental Animation support is experimental.\n * @abstract\n */\nvar
AnimationBuilder = /** @class */
(function () {\n function AnimationBuilder() {\n }\n return
AnimationBuilder;\n}());\n/**\n * An instance of `AnimationFactory` is returned
from {\\@link AnimationBuilder#build\n * AnimationBuilder.build}.\n *\n *
\\@experimental Animation support is experimental.\n * @abstract\n */\nvar
AnimationFactory = /** @class */ (function () {\n function
AnimationFactory() {\n }\n return AnimationFactory;\n}());\n\n/**\n *
@fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n
*/\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use
of this source code is governed by an MIT-style license that can be\n * found
in the LICENSE file at https://angular.io/license\n * @record\n */\n\n/**\n *
\\@experimental Animation support is experimental.\n */\nvar AUTO_STYLE =
'*';\n/**\n * \\@experimental Animation support is experimental.\n * @record\n
*/\n\n/**\n * Metadata representing the entry of animations. Instances of this
interface are pro
vided via the\n * animation DSL when the {\\@link trigger trigger animation
function} is called.\n *\n * \\@experimental Animation support is
experimental.\n * @record\n */\n\n/**\n * Metadata representing the entry of
animations. Instances of this interface are provided via the\n * animation DSL
when the {\\@link state state animation function} is called.\n *\n *
\\@experimental Animation support is experimental.\n * @record\n */\n\n/**\n *
Metadata representing the entry of animations. Instances of this interface are
provided via the\n * animation DSL when the {\\@link transition transition
animation function} is called.\n *\n * \\@experimental Animation support is
experimental.\n * @record\n */\n\n/**\n * \\@experimental Animation support is
experimental.\n * @record\n */\n\n/**\n * \\@experimental Animation support is
experimental.\n * @record\n */\n\n/**\n * Metadata representing the entry of
animations. Instances of this interface are provided via the\n * animation DSL
when th
e {\\@link keyframes keyframes animation function} is called.\n *\n *
\\@experimental Animation support is experimental.\n * @record\n */\n\n/**\n *
Metadata representing the entry of animations. Instances of this interface are
provided via the\n * animation DSL when the {\\@link style style animation
function} is called.\n *\n * \\@experimental Animation support is
experimental.\n * @record\n */\n\n/**\n * Metadata representing the entry of
animations. Instances of this interface are provided via the\n * animation DSL
when the {\\@link animate animate animation function} is called.\n *\n *
\\@experimental Animation support is experimental.\n * @record\n */\n\n/**\n *
Metadata representing the entry of animations. Instances of this interface are
provided via the\n * animation DSL when the {\\@link animateChild animateChild
animation function} is called.\n *\n * \\@experimental Animation support is
experimental.\n * @record\n */\n\n/**\n * Metadata representing the entry of
animation
s. Instances of this interface are provided via the\n * animation DSL when the
{\\@link useAnimation useAnimation animation function} is called.\n *\n *
\\@experimental Animation support is experimental.\n * @record\n */\n\n/**\n *
Metadata representing the entry of animations. Instances of this interface are
provided via the\n * animation DSL when the {\\@link sequence sequence
animation function} is called.\n *\n * \\@experimental Animation support is
experimental.\n * @record\n */\n\n/**\n * Metadata representing the entry of
animations. Instances of this interface are provided via the\n * animation DSL
when the {\\@link group group animation function} is called.\n *\n *
\\@experimental Animation support is experimental.\n * @record\n */\n\n/**\n *
Metadata representing the entry of animations. Instances of this interface are
provided via the\n * animation DSL when the {\\@link stagger stagger animation
function} is called.\n *\n * \\@experimental Animation support is experimenta
l.\n * @record\n */\n\n/**\n * `trigger` is an animation-specific function
that is designed to be used inside of Angular's\n * animation DSL language. If
this information is new, please navigate to the\n * {\\@link
Component#animations component animations metadata page} to gain a better\n *
understanding of how animations in Angular are used.\n *\n * `trigger` Creates
an animation trigger which will a list of {\\@link state state} and\n *
{\\@link transition transition} entries that will be evaluated when the
expression\n * bound to the trigger changes.\n *\n * Triggers are registered
within the component annotation data under the\n * {\\@link
Component#animations animations section}. An animation trigger can be placed on
an element\n * within a template by referencing the name of the trigger
followed by the expression value that\n * the\n * trigger is bound to (in the
form of `[\\@triggerName]=\"expression\"`.\n *\n * Animation trigger bindings
strigify values and then match the p
revious and current values against\n * any linked transitions. If a boolean
value is provided into the trigger binding then it will both\n * be represented
as `1` or `true` and `0` or `false` for a true and false boolean values\n *
respectively.\n *\n * ### Usage\n *\n * `trigger` will create an animation
trigger reference based on the provided `name` value. The\n * provided
`animation` value is expected to be an array consisting of {\\@link state
state} and\n * {\\@link transition 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 will make use of the
`myAnimationTrigger` animation\n * t
rigger 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 * ## Disable
Animations\n * A special animation control binding called `\\@.disabled` can be
placed on an element which will\n * then disable animations for any inner
animation triggers situated within the element as well as\n * any animations on
the element itself.\n *\n * When true, the `\\@.disabled` binding will prevent
all animations from rendering. The example\n * below shows how to use this
feature:\n *\n * ```ts\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 * The `\\@childAnimation` trigger will not animate because `\\@.disabled`
prevents it from happening\n * (when true).\n *\n * Note that `\\@.disabled`
will only disable all animations (this means any animations running on\n * the
same element will also be disabled).\n *\n * ### Disabling Animations
Application-wide\n * When an area of the template is set to have animations
disabled, **all** inner components will\n * also have their animations disabled
as well. This means that all animations for an angular\n * application can be
disabled by placing a host binding set on `\\@.disabled` on the topmost
Angular\n * component.\n *\n * ```ts\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 * ### What about animations that us `query()` and `animateChild
()`?\n * Despite inner animations being disabled, a parent animation can
{\\@link query query} for inner\n * elements located in disabled areas of the
template and still animate them as it sees fit. This is\n * also the case for
when a sub animation is queried by a parent and then later animated using
{\\@link\n * animateChild animateChild}.\n *\n * \\@experimental Animation
support is experimental.\n * @param {?} name\n * @param {?} definitions\n *
@return {?}\n */\nfunction trigger(name, definitions) {\n return { type: 7
/* Trigger */, name: name, definitions: definitions, options: {} };\n}\n/**\n *
`animate` is an animation-specific function that is designed to be used inside
of Angular's\n * animation DSL language. If this information is new, please
navigate to the {\\@link\n * Component#animations component animations metadata
page} to gain a better understanding of\n * how animations in Angular are
used.\n *\n * `animate` specifies an animation step that will apply the prov
ided `styles` data for a given\n * amount of time based on the provided
`timing` expression value. Calls to `animate` are expected\n * to be used
within {\\@link sequence an animation sequence}, {\\@link group group}, or
{\\@link\n * transition transition}.\n *\n * ### Usage\n *\n * The `animate`
function accepts two input parameters: `timing` and `styles`:\n *\n * -
`timing` is a string based value that can be a combination of a duration with
optional delay\n * and easing values. The format for the expression breaks down
to `duration delay easing`\n * (therefore a value such as `1s 100ms ease-out`
will be parse itself into `duration=1000,\n * delay=100, easing=ease-out`. If a
numeric value is provided then that will be used as the\n * `duration` value in
millisecond form.\n * - `styles` is the style input data which can either be a
call to {\\@link style style} or {\\@link\n * keyframes keyframes}. If left
empty then the styles from the destination state will be collected\n * and u
sed (this is useful when describing an animation step that will complete an
animation by\n * {\\@link transition#the-final-animate-call animating to the
final state}).\n *\n * ```typescript\n * // various functions for specifying
timing data\n * animate(500, style(...))\n * animate(\"1s\", style(...))\n *
animate(\"100ms 0.5s\", style(...))\n * animate(\"5s ease\", style(...))\n *
animate(\"5s 10ms cubic-bezier(.17,.67,.88,.1)\", style(...))\n *\n * // either
style() of keyframes() can be used\n * animate(500, style({ background: \"red\"
}))\n * animate(500, keyframes([\n * style({ background: \"blue\" })),\n *
style({ background: \"red\" }))\n * ])\n * ```\n *\n * {\\@example
core/animation/ts/dsl/animation_example.ts region='Component'}\n *\n *
\\@experimental Animation support is experimental.\n * @param {?} timings\n *
@param {?=} styles\n * @return {?}\n */\nfunction animate(timings, styles) {\n
if (styles === void 0) { styles = null; }\n return { type: 4 /* Animate *
/, styles: styles, timings: timings };\n}\n/**\n * `group` is an
animation-specific function that is designed to be used inside of Angular's\n *
animation DSL language. If this information is new, please navigate to the
{\\@link\n * Component#animations component animations metadata page} to gain a
better understanding of\n * how animations in Angular are used.\n *\n * `group`
specifies a list of animation steps that are all run in parallel. Grouped
animations are\n * useful when a series of styles must be animated/closed off
at different starting/ending times.\n *\n * The `group` function can either be
used within a {\\@link sequence sequence} or a {\\@link transition\n *
transition} and it will only continue to the next instruction once all of the
inner animation\n * steps have completed.\n *\n * ### Usage\n *\n * The `steps`
data that is passed into the `group` animation function can either consist of
{\\@link\n * style style} or {\\@link animate animate} function calls. Each cal
l to `style()` or `animate()`\n * within a group will be executed instantly
(use {\\@link keyframes keyframes} or a {\\@link\n * animate#usage animate()
with a delay value} to offset styles to be applied at a later time).\n *\n *
```typescript\n * group([\n * animate(\"1s\", { background: \"black\" }))\n *
animate(\"2s\", { color: \"white\" }))\n * ])\n * ```\n *\n * {\\@example
core/animation/ts/dsl/animation_example.ts region='Component'}\n *\n *
\\@experimental Animation support is experimental.\n * @param {?} steps\n *
@param {?=} options\n * @return {?}\n */\nfunction group(steps, options) {\n
if (options === void 0) { options = null; }\n return { type: 3 /* Group */,
steps: steps, options: options };\n}\n/**\n * `sequence` is an
animation-specific function that is designed to be used inside of Angular's\n *
animation DSL language. If this information is new, please navigate to the
{\\@link\n * Component#animations component animations metadata page} to gain a
better
understanding of\n * how animations in Angular are used.\n *\n * `sequence`
Specifies a list of animation steps that are run one by one. (`sequence` is
used by\n * default when an array is passed as animation data into {\\@link
transition transition}.)\n *\n * The `sequence` function can either be used
within a {\\@link group group} or a {\\@link transition\n * transition} and it
will only continue to the next instruction once each of the inner animation\n *
steps have completed.\n *\n * To perform animation styling in parallel with
other animation steps then have a look at the\n * {\\@link group group}
animation function.\n *\n * ### Usage\n *\n * The `steps` data that is passed
into the `sequence` animation function can either consist of\n * {\\@link style
style} or {\\@link animate animate} function calls. A call to `style()` will
apply the\n * provided styling data immediately while a call to `animate()`
will apply its styling data over a\n * given time depending on its timing d
ata.\n *\n * ```typescript\n * sequence([\n * style({ opacity: 0 })),\n *
animate(\"1s\", { opacity: 1 }))\n * ])\n * ```\n *\n * {\\@example
core/animation/ts/dsl/animation_example.ts region='Component'}\n *\n *
\\@experimental Animation support is experimental.\n * @param {?} steps\n *
@param {?=} options\n * @return {?}\n */\nfunction sequence(steps, options) {\n
if (options === void 0) { options = null; }\n return { type: 2 /*
Sequence */, steps: steps, options: options };\n}\n/**\n * `style` is an
animation-specific function that is designed to be used inside of Angular's\n *
animation DSL language. If this information is new, please navigate to the
{\\@link\n * Component#animations component animations metadata page} to gain a
better understanding of\n * how animations in Angular are used.\n *\n * `style`
declares a key/value object containing CSS properties/styles that can then be
used for\n * {\\@link state animation states}, within an {\\@link sequence
animation s
equence}, or as styling data\n * for both {\\@link animate animate} and
{\\@link keyframes keyframes}.\n *\n * ### Usage\n *\n * `style` takes in a
key/value string map as data and expects one or more CSS property/value pairs\n
* to be defined.\n *\n * ```typescript\n * // string values are used for css
properties\n * style({ background: \"red\", color: \"blue\" })\n *\n * //
numerical (pixel) values are also supported\n * style({ width: 100, height: 0
})\n * ```\n *\n * #### Auto-styles (using `*`)\n *\n * When an asterix (`*`)
character is used as a value then it will be detected from the element\n *
being animated and applied as animation data when the animation starts.\n *\n *
This feature proves useful for a state depending on layout and/or environment
factors; in such\n * cases the styles are calculated just before the animation
starts.\n *\n * ```typescript\n * // the steps below will animate from 0 to
the\n * // actual height of the element\n * style({ height: 0 }),\n * anim
ate(\"1s\", style({ height: \"*\" }))\n * ```\n *\n * {\\@example
core/animation/ts/dsl/animation_example.ts region='Component'}\n *\n *
\\@experimental Animation support is experimental.\n * @param {?} tokens\n *
@return {?}\n */\nfunction style(tokens) {\n return { type: 6 /* Style */,
styles: tokens, offset: null };\n}\n/**\n * `state` is an animation-specific
function that is designed to be used inside of Angular's\n * animation DSL
language. If this information is new, please navigate to the {\\@link\n *
Component#animations component animations metadata page} to gain a better
understanding of\n * how animations in Angular are used.\n *\n * `state`
declares an animation state within the given trigger. When a state is active
within a\n * component then its associated styles will persist on the element
that the trigger is attached to\n * (even when the animation ends).\n *\n * To
animate between states, have a look at the animation {\\@link transition
transition} DSL\n * funct
ion. To register states to an animation trigger please have a look at the
{\\@link trigger\n * trigger} function.\n *\n * #### The `void` state\n *\n *
The `void` state value is a reserved word that angular uses to determine when
the element is not\n * apart of the application anymore (e.g. when an `ngIf`
evaluates to false then the state of the\n * associated element is void).\n *\n
* #### The `*` (default) state\n *\n * The `*` state (when styled) is a
fallback state that will be used if the state that is being\n * animated is not
declared within the trigger.\n *\n * ### Usage\n *\n * `state` will declare an
animation state with its associated styles\n * within the given trigger.\n *\n
* - `stateNameExpr` can be one or more state names separated by commas.\n * -
`styles` refers to the {\\@link style styling data} that will be persisted on
the element once\n * the state has been reached.\n *\n * ```typescript\n * //
\"void\" is a reserved name for a state and is used to represent\n
* // the state in which an element is detached from from the application.\n *
state(\"void\", style({ height: 0 }))\n *\n * // user-defined states\n *
state(\"closed\", style({ height: 0 }))\n * state(\"open, visible\", style({
height: \"*\" }))\n * ```\n *\n * {\\@example
core/animation/ts/dsl/animation_example.ts region='Component'}\n *\n *
\\@experimental Animation support is experimental.\n * @param {?} name\n *
@param {?} styles\n * @param {?=} options\n * @return {?}\n */\nfunction
state(name, styles, options) {\n return { type: 0 /* State */, name: name,
styles: styles, options: options };\n}\n/**\n * `keyframes` is an
animation-specific function that is designed to be used inside of Angular's\n *
animation DSL language. If this information is new, please navigate to the
{\\@link\n * Component#animations component animations metadata page} to gain a
better understanding of\n * how animations in Angular are used.\n *\n *
`keyframes` specifies a collection of {\\@link style
style} entries each optionally characterized\n * by an `offset` value.\n *\n
* ### Usage\n *\n * The `keyframes` animation function is designed to be used
alongside the {\\@link animate animate}\n * animation function. Instead of
applying animations from where they are currently to their\n * destination,
keyframes can describe how each style entry is applied and at what point within
the\n * animation arc (much like CSS Keyframe Animations do).\n *\n * For each
`style()` entry an `offset` value can be set. Doing so allows to specifiy at
what\n * percentage of the animate time the styles will be applied.\n *\n *
```typescript\n * // the provided offset values describe when each
backgroundColor value is applied.\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 * Alternatively, if there are no `offset` values used within the style
entries then the offsets\n * will be 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 *
{\\@example core/animation/ts/dsl/animation_example.ts region='Component'}\n
*\n * \\@experimental Animation support is experimental.\n * @param {?} steps\n
* @return {?}\n */\nfunction keyframes(steps) {\n return { type: 5 /*
Keyframes */, steps: steps };\n}\n/**\n * `transition` is an animation-specific
function that is designed to be used inside of Angular's\n * animation DSL
language. If this information is new, please navigate to the {\\@link\n *
Component#animations component animations metadata page} to gain a better
understanding
of\n * how animations in Angular are used.\n *\n * `transition` declares the
{\\@link sequence sequence of animation steps} that will be run when the\n *
provided `stateChangeExpr` value is satisfied. The `stateChangeExpr` consists
of a `state1 =>\n * state2` which consists of two known states (use an asterix
(`*`) to refer to a dynamic starting\n * and/or ending state).\n *\n * A
function can also be provided as the `stateChangeExpr` argument for a
transition and this\n * function will be executed each time a state change
occurs. If the value returned within the\n * function is true then the
associated animation will be run.\n *\n * Animation transitions are placed
within an {\\@link trigger animation trigger}. For an transition\n * to animate
to a state value and persist its styles then one or more {\\@link state
animation\n * states} is expected to be defined.\n *\n * ### Usage\n *\n * An
animation transition is kicked off the `stateChangeExpr` predicate evaluates to
true based o
n\n * what the previous state is and what the current state has become. In
other words, if a transition\n * is defined that matches the old/current state
criteria then the associated animation will be\n * triggered.\n *\n *
```typescript\n * // all transition/state changes are defined within an
animation trigger\n * trigger(\"myAnimationTrigger\", [\n * // if a state is
defined then its styles will be persisted when the\n * // animation has fully
completed itself\n * state(\"on\", style({ background: \"green\" })),\n *
state(\"off\", style({ background: \"grey\" })),\n *\n * // a transition
animation that will be kicked off when the state value\n * // bound to
\"myAnimationTrigger\" changes from \"on\" to \"off\"\n * transition(\"on =>
off\", animate(500)),\n *\n * // it is also possible to do run the same
animation for both directions\n * transition(\"on <=> off\", animate(500)),\n
*\n * // or to define multiple states pairs separated by commas\n *
transition(
\"on => off, off => void\", animate(500)),\n *\n * // this is a catch-all
state change for when an element is inserted into\n * // the page and the
destination state is unknown\n * transition(\"void => *\", [\n * style({
opacity: 0 }),\n * animate(500)\n * ]),\n *\n * // this will capture a
state change between any states\n * transition(\"* => *\", animate(\"1s
0s\")),\n *\n * // you can also go full out and include a function\n *
transition((fromState, toState) => {\n * // when `true` then it will allow
the animation below to be invoked\n * return fromState == \"off\" &&
toState == \"on\";\n * }, animate(\"1s 0s\"))\n * ])\n * ```\n *\n * The
template associated with this component will make use of the
`myAnimationTrigger` animation\n * trigger 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 * #### The f
inal `animate` call\n *\n * If the final step within the transition steps is a
call to `animate()` that **only** uses a\n * timing value with **no style
data** then it will be automatically used as the final animation arc\n * for
the element to animate itself to the final state. This involves an automatic
mix of\n * adding/removing CSS styles so that the element will be in the exact
state it should be for the\n * applied state to be presented correctly.\n *\n *
```\n * // start off by hiding the element, but make sure that it animates
properly to whatever state\n * // is currently active for
\"myAnimationTrigger\"\n * transition(\"void => *\", [\n * style({ opacity: 0
}),\n * animate(500)\n * ])\n * ```\n *\n * ### Using :enter and :leave\n *\n
* Given that enter (insertion) and leave (removal) animations are so common,
the `transition`\n * function accepts both `:enter` and `:leave` values which
are aliases for the `void => *` and `*\n * => void` state changes.\n *\n *
```\n *
transition(\":enter\", [\n * style({ opacity: 0 }),\n * animate(500,
style({ opacity: 1 }))\n * ]),\n * transition(\":leave\", [\n * animate(500,
style({ opacity: 0 }))\n * ])\n * ```\n *\n * ### Boolean values\n * if a
trigger binding value is a boolean value then it can be matched using a
transition\n * expression that compares `true` and `false` or `1` and `0`.\n
*\n * ```\n * // in the template\n * <div [\\@openClose]=\"open ? true :
false\">...</div>\n *\n * // in the component metadata\n * trigger('openClose',
[\n * state('true', style({ height: '*' })),\n * state('false', style({
height: '0px' })),\n * transition('false <=> true', animate(500))\n * ])\n *
```\n *\n * ### Using :increment and :decrement\n * In addition to the :enter
and :leave transition aliases, the :increment and :decrement aliases\n * can be
used to kick off a transition when a numeric value has increased or decreased
in value.\n *\n * ```\n * import {group, animate, query, transition, style, tr
igger} from '\\@angular/animations';\n * import {Component} from
'\\@angular/core';\n *\n * \\@Component({\n * selector:
'banner-carousel-component',\n * styles: [`\n * .banner-container {\n *
position:relative;\n * height:500px;\n * overflow:hidden;\n
* }\n * .banner-container > .banner {\n * position:absolute;\n
* left:0;\n * top:0;\n * font-size:200px;\n *
line-height:500px;\n * font-weight:bold;\n * text-align:center;\n
* width:100%;\n * }\n * `],\n * template: `\n * <button
(click)=\"previous()\">Previous</button>\n * <button
(click)=\"next()\">Next</button>\n * <hr>\n * <div
[\\@bannerAnimation]=\"selectedIndex\" class=\"banner-container\">\n *
<div class=\"banner\" *ngFor=\"let banner of banners\"> {{ banner }} </div>\n *
</div>\n * `,\n * animations: [\n * trigger('bannerAnimation', [\n
* transition(\":increment\", group([\n *
query(':enter', [\n * style({ left: '100%' }),\n *
animate('0.5s ease-out', style('*'))\n * ]),\n *
query(':leave', [\n * animate('0.5s ease-out', style({ left: '-100%'
}))\n * ])\n * ])),\n * transition(\":decrement\",
group([\n * query(':enter', [\n * style({ left: '-100%' }),\n
* animate('0.5s ease-out', style('*'))\n * ]),\n *
query(':leave', [\n * animate('0.5s ease-out', style({ left: '100%'
}))\n * ])\n * ]))\n * ])\n * ]\n * })\n * class
BannerCarouselComponent {\n * allBanners: string[] = ['1', '2', '3', '4'];\n
* selectedIndex: number = 0;\n *\n * get banners() {\n * return
[this.allBanners[this.selectedIndex]];\n * }\n *\n * previous() {\n *
this.selectedIndex = Math.max(this.selectedIndex - 1, 0);\n * }\n *\n *
next() {\n * this.selectedIndex = Math.min(this.selectedIndex + 1,
this.allBanners.length - 1);\
n * }\n * }\n * ```\n *\n * {\\@example
core/animation/ts/dsl/animation_example.ts region='Component'}\n *\n *
\\@experimental Animation support is experimental.\n * @param {?}
stateChangeExpr\n * @param {?} steps\n * @param {?=} options\n * @return {?}\n
*/\nfunction transition(stateChangeExpr, steps, options) {\n if (options ===
void 0) { options = null; }\n return { type: 1 /* Transition */, expr:
stateChangeExpr, animation: steps, options: options };\n}\n/**\n * `animation`
is an animation-specific function that is designed to be used inside of
Angular's\n * animation DSL language.\n *\n * `var myAnimation =
animation(...)` is designed to produce a reusable animation that can be later\n
* invoked in another animation or sequence. Reusable animations are designed to
make use of\n * animation parameters and the produced animation can be used via
the `useAnimation` method.\n *\n * ```\n * var fadeAnimation = animation([\n *
style({ opacity: '{{ start }}' }),\n * animate
('{{ time }}',\n * style({ opacity: '{{ end }}'}))\n * ], { params: {
time: '1000ms', start: 0, end: 1 }});\n * ```\n *\n * If parameters are
attached to an animation then they act as **default parameter values**. When
an\n * animation is invoked via `useAnimation` then parameter values are
allowed to be passed in\n * directly. If any of the passed in parameter values
are missing then the default values will be\n * used.\n *\n * ```\n *
useAnimation(fadeAnimation, {\n * params: {\n * time: '2s',\n *
start: 1,\n * end: 0\n * }\n * })\n * ```\n *\n * If one or more
parameter values are missing before animated then an error will be thrown.\n
*\n * \\@experimental Animation support is experimental.\n * @param {?} steps\n
* @param {?=} options\n * @return {?}\n */\nfunction animation(steps, options)
{\n if (options === void 0) { options = null; }\n return { type: 8 /*
Reference */, animation: steps, options: options };\n}\n/**\n * `animateChild`
is an animation-
specific function that is designed to be used inside of Angular's\n *
animation DSL language. It works by allowing a queried element to execute its
own\n * animation within the animation sequence.\n *\n * Each time an animation
is triggered in angular, the parent animation\n * will always get priority and
any child animations will be blocked. In order\n * for a child animation to
run, the parent animation must query each of the elements\n * containing child
animations and then allow the animations to run using `animateChild`.\n *\n *
The example HTML code below shows both parent and child elements that have
animation\n * triggers that will execute at the same time.\n *\n * ```html\n *
<!-- parent-child.component.html -->\n * <button (click)=\"exp =!
exp\">Toggle</button>\n * <hr>\n *\n * <div [\\@parentAnimation]=\"exp\">\n *
<header>Hello</header>\n * <div [\\@childAnimation]=\"exp\">\n * one\n
* </div>\n * <div [\\@childAnimation]=\"exp\">\n * two\n * </div>\
n * <div [\\@childAnimation]=\"exp\">\n * three\n * </div>\n *
</div>\n * ```\n *\n * Now when the `exp` value changes to true, only the
`parentAnimation` animation will animate\n * because it has priority. However,
using `query` and `animateChild` each of the inner animations\n * can also
fire:\n *\n * ```ts\n * // parent-child.component.ts\n * import {trigger,
transition, animate, style, query, animateChild} from
'\\@angular/animations';\n * \\@Component({\n * selector:
'parent-child-component',\n * animations: [\n *
trigger('parentAnimation', [\n * transition('false => true', [\n *
query('header', [\n * style({ opacity: 0 }),\n *
animate(500, style({ opacity: 1 }))\n * ]),\n *
query('\\@childAnimation', [\n * animateChild()\n * ])\n *
])\n * ]),\n * trigger('childAnimation', [\n *
transition('false => true', [\n * style({ opacity: 0 }),\n *
animate(500, style(
{ opacity: 1 }))\n * ])\n * ])\n * ]\n * })\n * class
ParentChildCmp {\n * exp: boolean = false;\n * }\n * ```\n *\n * In the
animation code above, when the `parentAnimation` transition kicks off it first
queries to\n * find the header element and fades it in. It then finds each of
the sub elements that contain the\n * `\\@childAnimation` trigger and then
allows for their animations to fire.\n *\n * This example can be further
extended by using stagger:\n *\n * ```ts\n * query('\\@childAnimation',
stagger(100, [\n * animateChild()\n * ]))\n * ```\n *\n * Now each of the sub
animations start off with respect to the `100ms` staggering step.\n *\n * ##
The first frame of child animations\n * When sub animations are executed using
`animateChild` the animation engine will always apply the\n * first frame of
every sub animation immediately at the start of the animation sequence. This
way\n * the parent animation does not need to set any initial styling data on
the sub elem
ents before the\n * sub animations kick off.\n *\n * In the example above the
first frame of the `childAnimation`'s `false => true` transition\n * consists
of a style of `opacity: 0`. This is applied immediately when the
`parentAnimation`\n * animation transition sequence starts. Only then when the
`\\@childAnimation` is queried and called\n * with `animateChild` will it then
animate to its destination of `opacity: 1`.\n *\n * Note that this feature
designed to be used alongside {\\@link query query()} and it will only work\n *
with animations that are assigned using the Angular animation DSL (this means
that CSS keyframes\n * and transitions are not handled by this API).\n *\n *
\\@experimental Animation support is experimental.\n * @param {?=} options\n *
@return {?}\n */\nfunction animateChild(options) {\n if (options === void 0)
{ options = null; }\n return { type: 9 /* AnimateChild */, options: options
};\n}\n/**\n * `useAnimation` is an animation-specific function that i
s designed to be used inside of Angular's\n * animation DSL language. It is
used to kick off a reusable animation that is created using {\\@link\n *
animation animation()}.\n *\n * \\@experimental Animation support is
experimental.\n * @param {?} animation\n * @param {?=} options\n * @return
{?}\n */\nfunction useAnimation(animation, options) {\n if (options === void
0) { options = null; }\n return { type: 10 /* AnimateRef */, animation:
animation, options: options };\n}\n/**\n * `query` is an animation-specific
function that is designed to be used inside of Angular's\n * animation DSL
language.\n *\n * query() is used to find one or more inner elements within the
current element that is\n * being animated within the sequence. The provided
animation steps are applied\n * to the queried element (by default, an array is
provided, then this will be\n * treated as an animation sequence).\n *\n * ###
Usage\n *\n * query() is designed to collect mutiple elements and works
internally
by using\n * `element.querySelectorAll`. An additional options object can be
provided which\n * can be used to limit the total amount of items to be
collected.\n *\n * ```js\n * query('div', [\n * animate(...),\n *
animate(...)\n * ], { limit: 1 })\n * ```\n *\n * query(), by default, will
throw an error when zero items are found. If a query\n * has the `optional`
flag set to true then this error will be ignored.\n *\n * ```js\n *
query('.some-element-that-may-not-be-there', [\n * animate(...),\n *
animate(...)\n * ], { optional: true })\n * ```\n *\n * ### Special Selector
Values\n *\n * The selector value within a query can collect elements that
contain angular-specific\n * characteristics\n * using special pseudo-selectors
tokens.\n *\n * These include:\n *\n * - Querying for newly inserted/removed
elements using `query(\":enter\")`/`query(\":leave\")`\n * - Querying all
currently animating elements using `query(\":animating\")`\n * - Querying
elements that contain an
animation trigger using `query(\"\\@triggerName\")`\n * - Querying all
elements that contain an animation triggers using `query(\"\\@*\")`\n * -
Including the current element into the animation sequence using
`query(\":self\")`\n *\n *\n * Each of these pseudo-selector tokens can be
merged together into a combined query selector\n * string:\n *\n * ```\n *
query(':self, .record:enter, .record:leave, \\@subTrigger', [...])\n * ```\n
*\n * ### Demo\n *\n * ```\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 * \\@experimental Animation
support is experimental.\n * @param {?} selector\n * @param {?} animation\n *
@param {?=} options\n * @return {?}\n */\nfunction query(selector, animation,
options) {\n if (options === void 0) { options = null; }\n return { type:
11 /* Query */, selector: selector, animation: animation, options: options
};\n}\n/**\n * `stagger` is an animation-specific function that is designed to
be used inside of Angular's\n * animation DSL language. It is designed to be
used inside of an animation {\\@link query query()}\n * and works by issuing a
timing gap between after each queried item is animated.\n *\n * ### Usage\n *\n
* In the example below there is a container element that wraps a l
ist 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 * ```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 * The component code for
this looks as such:\n *\n * ```ts\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 * And now for the animation trigger code:\n *\n * ```ts\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 * Now each time the items are added/removed then either
the opacity\n * fade-in animation will run or each removed item will be faded
out.\n * When either of these animations occur then a stagger effect will be\n
* applied after each item's animation is started.\n *\n * \\@experimental
Animation support is experimental.\n * @param {?} timings\n * @param {?}
animation\n * @return {?}\n */\nfunction stagger(timings, animation) {\n
return { type: 12 /* Stagger */, timings: timings, animation: animatio
n };\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes}
checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights
Reserved.\n *\n * Use of this source code is governed by an MIT-style license
that can be\n * found in the LICENSE file at https://angular.io/license\n *
@param {?} cb\n * @return {?}\n */\nfunction scheduleMicroTask(cb) {\n
Promise.resolve(null).then(cb);\n}\n\n/**\n * @fileoverview added by tsickle\n
* @suppress {checkTypes} checked by tsc\n */\n/**\n * AnimationPlayer controls
an animation sequence that was produced from a programmatic animation.\n * (see
{\\@link AnimationBuilder AnimationBuilder} for more information on how to
create programmatic\n * animations.)\n *\n * \\@experimental Animation support
is experimental.\n * @record\n */\n\n/**\n * \\@experimental Animation support
is experimental.\n */\nvar NoopAnimationPlayer = /** @class */ (function () {\n
function NoopAnimationPlayer() {\n this._onDoneFns = [];
\n this._onStartFns = [];\n this._onDestroyFns = [];\n
this._started = false;\n this._destroyed = false;\n
this._finished = false;\n this.parentPlayer = null;\n
this.totalTime = 0;\n }\n /**\n * @return {?}\n */\n
NoopAnimationPlayer.prototype._onFinish = /**\n * @return {?}\n */\n
function () {\n if (!this._finished) {\n this._finished =
true;\n this._onDoneFns.forEach(function (fn) { return fn(); });\n
this._onDoneFns = [];\n }\n };\n /**\n * @param {?}
fn\n * @return {?}\n */\n NoopAnimationPlayer.prototype.onStart =
/**\n * @param {?} fn\n * @return {?}\n */\n function (fn) {
this._onStartFns.push(fn); };\n /**\n * @param {?} fn\n * @return
{?}\n */\n NoopAnimationPlayer.prototype.onDone = /**\n * @param {?}
fn\n * @return {?}\n */\n function (fn) { this._onDoneFns.push(fn);
};\n /**\n
* @param {?} fn\n * @return {?}\n */\n
NoopAnimationPlayer.prototype.onDestroy = /**\n * @param {?} fn\n *
@return {?}\n */\n function (fn) { this._onDestroyFns.push(fn); };\n
/**\n * @return {?}\n */\n NoopAnimationPlayer.prototype.hasStarted
= /**\n * @return {?}\n */\n function () { return this._started;
};\n /**\n * @return {?}\n */\n
NoopAnimationPlayer.prototype.init = /**\n * @return {?}\n */\n
function () { };\n /**\n * @return {?}\n */\n
NoopAnimationPlayer.prototype.play = /**\n * @return {?}\n */\n
function () {\n if (!this.hasStarted()) {\n
this._onStart();\n this.triggerMicrotask();\n }\n
this._started = true;\n };\n /* @internal */\n /**\n * @return
{?}\n */\n NoopAnimationPlayer.prototype.triggerMicrotask = /**\n *
@return {?}\n */\n function () {\n var _this = this;\n
scheduleM
icroTask(function () { return _this._onFinish(); });\n };\n /**\n *
@return {?}\n */\n NoopAnimationPlayer.prototype._onStart = /**\n *
@return {?}\n */\n function () {\n
this._onStartFns.forEach(function (fn) { return fn(); });\n
this._onStartFns = [];\n };\n /**\n * @return {?}\n */\n
NoopAnimationPlayer.prototype.pause = /**\n * @return {?}\n */\n
function () { };\n /**\n * @return {?}\n */\n
NoopAnimationPlayer.prototype.restart = /**\n * @return {?}\n */\n
function () { };\n /**\n * @return {?}\n */\n
NoopAnimationPlayer.prototype.finish = /**\n * @return {?}\n */\n
function () { this._onFinish(); };\n /**\n * @return {?}\n */\n
NoopAnimationPlayer.prototype.destroy = /**\n * @return {?}\n */\n
function () {\n if (!this._destroyed) {\n this._destroyed =
true;\n if (!this.hasStarted()) {\n thi
s._onStart();\n }\n this.finish();\n
this._onDestroyFns.forEach(function (fn) { return fn(); });\n
this._onDestroyFns = [];\n }\n };\n /**\n * @return {?}\n
*/\n NoopAnimationPlayer.prototype.reset = /**\n * @return {?}\n
*/\n function () { };\n /**\n * @param {?} p\n * @return {?}\n
*/\n NoopAnimationPlayer.prototype.setPosition = /**\n * @param {?} p\n
* @return {?}\n */\n function (p) { };\n /**\n * @return
{?}\n */\n NoopAnimationPlayer.prototype.getPosition = /**\n *
@return {?}\n */\n function () { return 0; };\n /* @internal */\n
/**\n * @param {?} phaseName\n * @return {?}\n */\n
NoopAnimationPlayer.prototype.triggerCallback = /**\n * @param {?}
phaseName\n * @return {?}\n */\n function (phaseName) {\n var
/** @type {?} */ methods = phaseName == 'start' ? this._onStartFns :
this._onDoneFns;\n
methods.forEach(function (fn) { return fn(); });\n methods.length =
0;\n };\n return NoopAnimationPlayer;\n}());\n\n/**\n * @fileoverview
added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n *
@license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this
source code is governed by an MIT-style license that can be\n * found in the
LICENSE file at https://angular.io/license\n */\nvar AnimationGroupPlayer = /**
@class */ (function () {\n function AnimationGroupPlayer(_players) {\n
var _this = this;\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 var /** @type {?} */ doneCount = 0;\n var /** @type
{?} */ destroyCount = 0;\n var /** @type {?} */ startCount = 0;\n
var /** @type {?} */ total = this.players.length;\n if (total == 0)
{\n scheduleMicroTask(function () { return _this._onFinish(); });\n
}\n else {\n this.players.forEach(function (player) {\n
player.onDone(function () {\n if (++doneCount
== total) {\n _this._onFinish();\n
}\n });\n player.onDestroy(function () {\n
if (++destroyCount == total) {\n
_this._onDestroy();\n }\n });\n
player.onStart(function () {\n if (++startCount == total)
{\n _this._onStart();\n }\n
});\n });\n }\n this.totalTime =
this.players.reduce(function (time, player) { return Math.max(time,
player.totalTime); }, 0);\n }\n /**\n * @return {?}\n */\n
Animation
GroupPlayer.prototype._onFinish = /**\n * @return {?}\n */\n
function () {\n if (!this._finished) {\n this._finished =
true;\n this._onDoneFns.forEach(function (fn) { return fn(); });\n
this._onDoneFns = [];\n }\n };\n /**\n * @return
{?}\n */\n AnimationGroupPlayer.prototype.init = /**\n * @return
{?}\n */\n function () { this.players.forEach(function (player) { return
player.init(); }); };\n /**\n * @param {?} fn\n * @return {?}\n
*/\n AnimationGroupPlayer.prototype.onStart = /**\n * @param {?} fn\n
* @return {?}\n */\n function (fn) { this._onStartFns.push(fn); };\n
/**\n * @return {?}\n */\n AnimationGroupPlayer.prototype._onStart =
/**\n * @return {?}\n */\n function () {\n if
(!this.hasStarted()) {\n this._started = true;\n
this._onStartFns.forEach(function (fn) { return fn(); });\n
this._onStart
Fns = [];\n }\n };\n /**\n * @param {?} fn\n * @return
{?}\n */\n AnimationGroupPlayer.prototype.onDone = /**\n * @param
{?} fn\n * @return {?}\n */\n function (fn) {
this._onDoneFns.push(fn); };\n /**\n * @param {?} fn\n * @return
{?}\n */\n AnimationGroupPlayer.prototype.onDestroy = /**\n * @param
{?} fn\n * @return {?}\n */\n function (fn) {
this._onDestroyFns.push(fn); };\n /**\n * @return {?}\n */\n
AnimationGroupPlayer.prototype.hasStarted = /**\n * @return {?}\n */\n
function () { return this._started; };\n /**\n * @return {?}\n
*/\n AnimationGroupPlayer.prototype.play = /**\n * @return {?}\n
*/\n function () {\n if (!this.parentPlayer) {\n
this.init();\n }\n this._onStart();\n
this.players.forEach(function (player) { return player.play(); });\n };\n
/**\n * @return {?}\n */\n AnimationGroupPlayer
.prototype.pause = /**\n * @return {?}\n */\n function () {
this.players.forEach(function (player) { return player.pause(); }); };\n
/**\n * @return {?}\n */\n AnimationGroupPlayer.prototype.restart =
/**\n * @return {?}\n */\n function () {
this.players.forEach(function (player) { return player.restart(); }); };\n
/**\n * @return {?}\n */\n AnimationGroupPlayer.prototype.finish =
/**\n * @return {?}\n */\n function () {\n
this._onFinish();\n this.players.forEach(function (player) { return
player.finish(); });\n };\n /**\n * @return {?}\n */\n
AnimationGroupPlayer.prototype.destroy = /**\n * @return {?}\n */\n
function () { this._onDestroy(); };\n /**\n * @return {?}\n */\n
AnimationGroupPlayer.prototype._onDestroy = /**\n * @return {?}\n */\n
function () {\n if (!this._destroyed) {\n this._destroyed =
true;\n this._onFinish();\
n this.players.forEach(function (player) { return player.destroy();
});\n this._onDestroyFns.forEach(function (fn) { return fn(); });\n
this._onDestroyFns = [];\n }\n };\n /**\n * @return
{?}\n */\n AnimationGroupPlayer.prototype.reset = /**\n * @return
{?}\n */\n function () {\n this.players.forEach(function (player)
{ return player.reset(); });\n this._destroyed = false;\n
this._finished = false;\n this._started = false;\n };\n /**\n
* @param {?} p\n * @return {?}\n */\n
AnimationGroupPlayer.prototype.setPosition = /**\n * @param {?} p\n *
@return {?}\n */\n function (p) {\n var /** @type {?} */
timeAtPosition = p * this.totalTime;\n this.players.forEach(function
(player) {\n var /** @type {?} */ position = player.totalTime ?
Math.min(1, timeAtPosition / player.totalTime) : 1;\n
player.setPosition(position);\n
});\n };\n /**\n * @return {?}\n */\n
AnimationGroupPlayer.prototype.getPosition = /**\n * @return {?}\n */\n
function () {\n var /** @type {?} */ min = 0;\n
this.players.forEach(function (player) {\n var /** @type {?} */ p =
player.getPosition();\n min = Math.min(p, min);\n });\n
return min;\n };\n /**\n * @return {?}\n */\n
AnimationGroupPlayer.prototype.beforeDestroy = /**\n * @return {?}\n
*/\n function () {\n this.players.forEach(function (player) {\n
if (player.beforeDestroy) {\n player.beforeDestroy();\n
}\n });\n };\n /* @internal */\n /**\n * @param {?}
phaseName\n * @return {?}\n */\n
AnimationGroupPlayer.prototype.triggerCallback = /**\n * @param {?}
phaseName\n * @return {?}\n */\n function (phaseName) {\n var
/** @type {?} */ methods = phaseName == 'start' ? this._onSt
artFns : this._onDoneFns;\n methods.forEach(function (fn) { return
fn(); });\n methods.length = 0;\n };\n return
AnimationGroupPlayer;\n}());\n\n/**\n * @fileoverview added by tsickle\n *
@suppress {checkTypes} checked by tsc\n */\nvar ɵPRE_STYLE =
'!';\n\nexports.AnimationBuilder = AnimationBuilder;\nexports.AnimationFactory
= AnimationFactory;\nexports.AUTO_STYLE = AUTO_STYLE;\nexports.animate =
animate;\nexports.animateChild = animateChild;\nexports.animation =
animation;\nexports.group = group;\nexports.keyframes =
keyframes;\nexports.query = query;\nexports.sequence =
sequence;\nexports.stagger = stagger;\nexports.state = state;\nexports.style =
style;\nexports.transition = transition;\nexports.trigger =
trigger;\nexports.useAnimation = useAnimation;\nexports.NoopAnimationPlayer =
NoopAnimationPlayer;\nexports.ɵAnimationGroupPlayer =
AnimationGroupPlayer;\nexports.ɵPRE_STYLE =
ɵPRE_STYLE;\n\nObject.defineProperty(exports, '__esModule', { value: true });\
n\n})));\n//# sourceMappingURL=animations.umd.js.map\n"]}
\ No newline at end of file
