You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@nifi.apache.org by sc...@apache.org on 2018/04/30 21:03:18 UTC
[22/51] [partial] nifi-fds git commit: gh-pages update
http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/d07dd0f2/node_modules/@angular/animations/esm5/browser.js.map
----------------------------------------------------------------------
diff --git a/node_modules/@angular/animations/esm5/browser.js.map b/node_modules/@angular/animations/esm5/browser.js.map
new file mode 100644
index 0000000..f7e160f
--- /dev/null
+++ b/node_modules/@angular/animations/esm5/browser.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"browser.js","sources":["../../../packages/animations/esm5/browser/src/render/shared.js","../../../packages/animations/esm5/browser/src/render/animation_driver.js","../../../packages/animations/esm5/browser/src/util.js","../../../packages/animations/esm5/browser/src/dsl/animation_transition_expr.js","../../../packages/animations/esm5/browser/src/dsl/animation_ast_builder.js","../../../packages/animations/esm5/browser/src/dsl/animation_timeline_instruction.js","../../../packages/animations/esm5/browser/src/dsl/element_instruction_map.js","../../../packages/animations/esm5/browser/src/dsl/animation_timeline_builder.js","../../../packages/animations/esm5/browser/src/dsl/animation.js","../../../packages/animations/esm5/browser/src/dsl/style_normalization/animation_style_normalizer.js","../../../packages/animations/esm5/browser/src/dsl/style_normalization/web_animations_style_normalizer.js","../../../packages/animations/esm5/browser/src/dsl/animation_transition_instru
ction.js","../../../packages/animations/esm5/browser/src/dsl/animation_transition_factory.js","../../../packages/animations/esm5/browser/src/dsl/animation_trigger.js","../../../packages/animations/esm5/browser/src/render/timeline_animation_engine.js","../../../packages/animations/esm5/browser/src/render/transition_animation_engine.js","../../../packages/animations/esm5/browser/src/render/animation_engine_next.js","../../../packages/animations/esm5/browser/src/render/web_animations/web_animations_player.js","../../../packages/animations/esm5/browser/src/render/web_animations/web_animations_driver.js","../../../packages/animations/esm5/browser/src/private_export.js","../../../packages/animations/esm5/browser/src/browser.js","../../../packages/animations/esm5/browser/public_api.js","../../../packages/animations/esm5/browser/browser.js"],"sourcesContent":["/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\nimport { AUTO_STYLE, NoopAnimationPlayer, ɵA
nimationGroupPlayer, ɵPRE_STYLE as PRE_STYLE } from '@angular/animations';\n/**\n * @param {?} players\n * @return {?}\n */\nexport function optimizeGroupPlayer(players) {\n switch (players.length) {\n case 0:\n return new NoopAnimationPlayer();\n case 1:\n return players[0];\n default:\n return new ɵAnimationGroupPlayer(players);\n }\n}\n/**\n * @param {?} driver\n * @param {?} normalizer\n * @param {?} element\n * @param {?} keyframes\n * @param {?=} preStyles\n * @param {?=} postStyles\n * @return {?}\n */\nexport function normalizeKeyframes(driver, normalizer, element, keyframes, preStyles, postStyles) {\n if (preStyles === void 0) { preStyles = {}; }\n if (postStyles === void 0) { postStyles = {}; }\n var /** @type {?} */ errors = [];\n var /** @type {?} */ normalizedKeyframes = [];\n var /** @type {?} */ previousOffset = -1;\n var /** @type {?} */ previousKeyframe = null;\n keyframes.forEach(fun
ction (kf) {\n var /** @type {?} */ offset = /** @type {?} */ (kf['offset']);\n var /** @type {?} */ isSameOffset = offset == previousOffset;\n var /** @type {?} */ normalizedKeyframe = (isSameOffset && previousKeyframe) || {};\n Object.keys(kf).forEach(function (prop) {\n var /** @type {?} */ normalizedProp = prop;\n var /** @type {?} */ normalizedValue = kf[prop];\n if (prop !== 'offset') {\n normalizedProp = normalizer.normalizePropertyName(normalizedProp, errors);\n switch (normalizedValue) {\n case PRE_STYLE:\n normalizedValue = preStyles[prop];\n break;\n case AUTO_STYLE:\n normalizedValue = postStyles[prop];\n break;\n default:\n normalizedValue =\n normalizer.normalizeStyleValue(prop, norma
lizedProp, normalizedValue, errors);\n break;\n }\n }\n normalizedKeyframe[normalizedProp] = normalizedValue;\n });\n if (!isSameOffset) {\n normalizedKeyframes.push(normalizedKeyframe);\n }\n previousKeyframe = normalizedKeyframe;\n previousOffset = offset;\n });\n if (errors.length) {\n var /** @type {?} */ LINE_START = '\\n - ';\n throw new Error(\"Unable to animate due to the following errors:\" + LINE_START + errors.join(LINE_START));\n }\n return normalizedKeyframes;\n}\n/**\n * @param {?} player\n * @param {?} eventName\n * @param {?} event\n * @param {?} callback\n * @return {?}\n */\nexport function listenOnPlayer(player, eventName, event, callback) {\n switch (eventName) {\n case 'start':\n player.onStart(function () { return callback(event && copyAnimationEvent(event, 'start', player.totalTime)); });\n break;\n
case 'done':\n player.onDone(function () { return callback(event && copyAnimationEvent(event, 'done', player.totalTime)); });\n break;\n case 'destroy':\n player.onDestroy(function () { return callback(event && copyAnimationEvent(event, 'destroy', player.totalTime)); });\n break;\n }\n}\n/**\n * @param {?} e\n * @param {?=} phaseName\n * @param {?=} totalTime\n * @return {?}\n */\nexport function copyAnimationEvent(e, phaseName, totalTime) {\n var /** @type {?} */ event = makeAnimationEvent(e.element, e.triggerName, e.fromState, e.toState, phaseName || e.phaseName, totalTime == undefined ? e.totalTime : totalTime);\n var /** @type {?} */ data = (/** @type {?} */ (e))['_data'];\n if (data != null) {\n (/** @type {?} */ (event))['_data'] = data;\n }\n return event;\n}\n/**\n * @param {?} element\n * @param {?} triggerName\n * @param {?} fromState\n * @param {?} toState\n * @param {?=} phaseName\n * @pa
ram {?=} totalTime\n * @return {?}\n */\nexport function makeAnimationEvent(element, triggerName, fromState, toState, phaseName, totalTime) {\n if (phaseName === void 0) { phaseName = ''; }\n if (totalTime === void 0) { totalTime = 0; }\n return { element: element, triggerName: triggerName, fromState: fromState, toState: toState, phaseName: phaseName, totalTime: totalTime };\n}\n/**\n * @param {?} map\n * @param {?} key\n * @param {?} defaultValue\n * @return {?}\n */\nexport function getOrSetAsInMap(map, key, defaultValue) {\n var /** @type {?} */ value;\n if (map instanceof Map) {\n value = map.get(key);\n if (!value) {\n map.set(key, value = defaultValue);\n }\n }\n else {\n value = map[key];\n if (!value) {\n value = map[key] = defaultValue;\n }\n }\n return value;\n}\n/**\n * @param {?} command\n * @return {?}\n */\nexport function parseTimelineCommand(command) {\n var /** @type {?} */
separatorPos = command.indexOf(':');\n var /** @type {?} */ id = command.substring(1, separatorPos);\n var /** @type {?} */ action = command.substr(separatorPos + 1);\n return [id, action];\n}\nvar /** @type {?} */ _contains = function (elm1, elm2) { return false; };\nvar ɵ0 = _contains;\nvar /** @type {?} */ _matches = function (element, selector) {\n return false;\n};\nvar ɵ1 = _matches;\nvar /** @type {?} */ _query = function (element, selector, multi) {\n return [];\n};\nvar ɵ2 = _query;\nif (typeof Element != 'undefined') {\n // this is well supported in all browsers\n _contains = function (elm1, elm2) { return /** @type {?} */ (elm1.contains(elm2)); };\n if (Element.prototype.matches) {\n _matches = function (element, selector) { return element.matches(selector); };\n }\n else {\n var /** @type {?} */ proto = /** @type {?} */ (Element.prototype);\n var /** @type {?} */ fn_1 = proto.matchesSelector || proto.mozMatchesSelect
or || proto.msMatchesSelector ||\n proto.oMatchesSelector || proto.webkitMatchesSelector;\n if (fn_1) {\n _matches = function (element, selector) { return fn_1.apply(element, [selector]); };\n }\n }\n _query = function (element, selector, multi) {\n var /** @type {?} */ results = [];\n if (multi) {\n results.push.apply(results, element.querySelectorAll(selector));\n }\n else {\n var /** @type {?} */ elm = element.querySelector(selector);\n if (elm) {\n results.push(elm);\n }\n }\n return results;\n };\n}\n/**\n * @param {?} prop\n * @return {?}\n */\nfunction containsVendorPrefix(prop) {\n // Webkit is the only real popular vendor prefix nowadays\n // cc: http://shouldiprefix.com/\n return prop.substring(1, 6) == 'ebkit'; // webkit or Webkit\n}\nvar /** @type {?} */ _CACHED_BODY = null;\nvar /** @type {?} */ _IS_WEBKIT = false;\n/
**\n * @param {?} prop\n * @return {?}\n */\nexport function validateStyleProperty(prop) {\n if (!_CACHED_BODY) {\n _CACHED_BODY = getBodyNode() || {};\n _IS_WEBKIT = /** @type {?} */ ((_CACHED_BODY)).style ? ('WebkitAppearance' in /** @type {?} */ ((_CACHED_BODY)).style) : false;\n }\n var /** @type {?} */ result = true;\n if (/** @type {?} */ ((_CACHED_BODY)).style && !containsVendorPrefix(prop)) {\n result = prop in /** @type {?} */ ((_CACHED_BODY)).style;\n if (!result && _IS_WEBKIT) {\n var /** @type {?} */ camelProp = 'Webkit' + prop.charAt(0).toUpperCase() + prop.substr(1);\n result = camelProp in /** @type {?} */ ((_CACHED_BODY)).style;\n }\n }\n return result;\n}\n/**\n * @return {?}\n */\nexport function getBodyNode() {\n if (typeof document != 'undefined') {\n return document.body;\n }\n return null;\n}\nexport var /** @type {?} */ matchesElement = _matches;\nexport var /** @type {?
} */ containsElement = _contains;\nexport var /** @type {?} */ invokeQuery = _query;\nexport { ɵ0, ɵ1, ɵ2 };\n//# sourceMappingURL=shared.js.map","/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\nimport { NoopAnimationPlayer } from '@angular/animations';\nimport { containsElement, invokeQuery, matchesElement, validateStyleProperty } from './shared';\n/**\n * \\@experimental\n */\nvar /**\n * \\@experimental\n */\nNoopAnimationDriver = /** @class */ (function () {\n function NoopAnimationDriver() {\n }\n /**\n * @param {?} prop\n * @return {?}\n */\n NoopAnimationDriver.prototype.validateStyleProperty = /**\n * @param {?} prop\n * @return {?}\n */\n function (prop) { return validateStyleProperty(prop); };\n /**\n * @param {?} element\n * @param {?} selector\n * @return {?}\n */\n NoopAnimationDriver.prototype.matchesElement = /**\n * @param {?} element\n * @param {?} selector
\n * @return {?}\n */\n function (element, selector) {\n return matchesElement(element, selector);\n };\n /**\n * @param {?} elm1\n * @param {?} elm2\n * @return {?}\n */\n NoopAnimationDriver.prototype.containsElement = /**\n * @param {?} elm1\n * @param {?} elm2\n * @return {?}\n */\n function (elm1, elm2) { return containsElement(elm1, elm2); };\n /**\n * @param {?} element\n * @param {?} selector\n * @param {?} multi\n * @return {?}\n */\n NoopAnimationDriver.prototype.query = /**\n * @param {?} element\n * @param {?} selector\n * @param {?} multi\n * @return {?}\n */\n function (element, selector, multi) {\n return invokeQuery(element, selector, multi);\n };\n /**\n * @param {?} element\n * @param {?} prop\n * @param {?=} defaultValue\n * @return {?}\n */\n NoopAnimationDriver.prototype.computeStyle = /**\n * @param {?} element\n
* @param {?} prop\n * @param {?=} defaultValue\n * @return {?}\n */\n function (element, prop, defaultValue) {\n return defaultValue || '';\n };\n /**\n * @param {?} element\n * @param {?} keyframes\n * @param {?} duration\n * @param {?} delay\n * @param {?} easing\n * @param {?=} previousPlayers\n * @return {?}\n */\n NoopAnimationDriver.prototype.animate = /**\n * @param {?} element\n * @param {?} keyframes\n * @param {?} duration\n * @param {?} delay\n * @param {?} easing\n * @param {?=} previousPlayers\n * @return {?}\n */\n function (element, keyframes, duration, delay, easing, previousPlayers) {\n if (previousPlayers === void 0) { previousPlayers = []; }\n return new NoopAnimationPlayer();\n };\n return NoopAnimationDriver;\n}());\n/**\n * \\@experimental\n */\nexport { NoopAnimationDriver };\n/**\n * \\@experimental\n * @abstract\n */\nvar AnimationDriver
= /** @class */ (function () {\n function AnimationDriver() {\n }\n AnimationDriver.NOOP = new NoopAnimationDriver();\n return AnimationDriver;\n}());\nexport { AnimationDriver };\nfunction AnimationDriver_tsickle_Closure_declarations() {\n /** @type {?} */\n AnimationDriver.NOOP;\n /**\n * @abstract\n * @param {?} prop\n * @return {?}\n */\n AnimationDriver.prototype.validateStyleProperty = function (prop) { };\n /**\n * @abstract\n * @param {?} element\n * @param {?} selector\n * @return {?}\n */\n AnimationDriver.prototype.matchesElement = function (element, selector) { };\n /**\n * @abstract\n * @param {?} elm1\n * @param {?} elm2\n * @return {?}\n */\n AnimationDriver.prototype.containsElement = function (elm1, elm2) { };\n /**\n * @abstract\n * @param {?} element\n * @param {?} selector\n * @param {?} multi\n * @return {?}\n */\n AnimationDriver.prototype.
query = function (element, selector, multi) { };\n /**\n * @abstract\n * @param {?} element\n * @param {?} prop\n * @param {?=} defaultValue\n * @return {?}\n */\n AnimationDriver.prototype.computeStyle = function (element, prop, defaultValue) { };\n /**\n * @abstract\n * @param {?} element\n * @param {?} keyframes\n * @param {?} duration\n * @param {?} delay\n * @param {?=} easing\n * @param {?=} previousPlayers\n * @return {?}\n */\n AnimationDriver.prototype.animate = function (element, keyframes, duration, delay, easing, previousPlayers) { };\n}\n//# sourceMappingURL=animation_driver.js.map","/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\nimport { sequence } from '@angular/animations';\nexport var /** @type {?} */ ONE_SECOND = 1000;\nexport var /** @type {?} */ SUBSTITUTION_EXPR_START = '{{';\nexport var /** @type {?} */ SUBSTITUTION_EXPR_END = '}}';\nexport var /** @t
ype {?} */ ENTER_CLASSNAME = 'ng-enter';\nexport var /** @type {?} */ LEAVE_CLASSNAME = 'ng-leave';\nexport var /** @type {?} */ ENTER_SELECTOR = '.ng-enter';\nexport var /** @type {?} */ LEAVE_SELECTOR = '.ng-leave';\nexport var /** @type {?} */ NG_TRIGGER_CLASSNAME = 'ng-trigger';\nexport var /** @type {?} */ NG_TRIGGER_SELECTOR = '.ng-trigger';\nexport var /** @type {?} */ NG_ANIMATING_CLASSNAME = 'ng-animating';\nexport var /** @type {?} */ NG_ANIMATING_SELECTOR = '.ng-animating';\n/**\n * @param {?} value\n * @return {?}\n */\nexport function resolveTimingValue(value) {\n if (typeof value == 'number')\n return value;\n var /** @type {?} */ matches = (/** @type {?} */ (value)).match(/^(-?[\\.\\d]+)(m?s)/);\n if (!matches || matches.length < 2)\n return 0;\n return _convertTimeValueToMS(parseFloat(matches[1]), matches[2]);\n}\n/**\n * @param {?} value\n * @param {?} unit\n * @return {?}\n */\nfunction _convertTimeValueToMS(value, unit) {\n switch (uni
t) {\n case 's':\n return value * ONE_SECOND;\n default:\n // ms or something else\n return value;\n }\n}\n/**\n * @param {?} timings\n * @param {?} errors\n * @param {?=} allowNegativeValues\n * @return {?}\n */\nexport function resolveTiming(timings, errors, allowNegativeValues) {\n return timings.hasOwnProperty('duration') ? /** @type {?} */ (timings) :\n parseTimeExpression(/** @type {?} */ (timings), errors, allowNegativeValues);\n}\n/**\n * @param {?} exp\n * @param {?} errors\n * @param {?=} allowNegativeValues\n * @return {?}\n */\nfunction parseTimeExpression(exp, errors, allowNegativeValues) {\n var /** @type {?} */ regex = /^(-?[\\.\\d]+)(m?s)(?:\\s+(-?[\\.\\d]+)(m?s))?(?:\\s+([-a-z]+(?:\\(.+?\\))?))?$/i;\n var /** @type {?} */ duration;\n var /** @type {?} */ delay = 0;\n var /** @type {?} */ easing = '';\n if (typeof exp === 'string') {\n var /** @type {?} */ matches = exp.match(regex);\n
if (matches === null) {\n errors.push(\"The provided timing value \\\"\" + exp + \"\\\" is invalid.\");\n return { duration: 0, delay: 0, easing: '' };\n }\n duration = _convertTimeValueToMS(parseFloat(matches[1]), matches[2]);\n var /** @type {?} */ delayMatch = matches[3];\n if (delayMatch != null) {\n delay = _convertTimeValueToMS(Math.floor(parseFloat(delayMatch)), matches[4]);\n }\n var /** @type {?} */ easingVal = matches[5];\n if (easingVal) {\n easing = easingVal;\n }\n }\n else {\n duration = /** @type {?} */ (exp);\n }\n if (!allowNegativeValues) {\n var /** @type {?} */ containsErrors = false;\n var /** @type {?} */ startIndex = errors.length;\n if (duration < 0) {\n errors.push(\"Duration values below 0 are not allowed for this animation step.\");\n containsErrors = true;\n }\n if (delay < 0
) {\n errors.push(\"Delay values below 0 are not allowed for this animation step.\");\n containsErrors = true;\n }\n if (containsErrors) {\n errors.splice(startIndex, 0, \"The provided timing value \\\"\" + exp + \"\\\" is invalid.\");\n }\n }\n return { duration: duration, delay: delay, easing: easing };\n}\n/**\n * @param {?} obj\n * @param {?=} destination\n * @return {?}\n */\nexport function copyObj(obj, destination) {\n if (destination === void 0) { destination = {}; }\n Object.keys(obj).forEach(function (prop) { destination[prop] = obj[prop]; });\n return destination;\n}\n/**\n * @param {?} styles\n * @return {?}\n */\nexport function normalizeStyles(styles) {\n var /** @type {?} */ normalizedStyles = {};\n if (Array.isArray(styles)) {\n styles.forEach(function (data) { return copyStyles(data, false, normalizedStyles); });\n }\n else {\n copyStyles(styles, false, normalizedStyles);\
n }\n return normalizedStyles;\n}\n/**\n * @param {?} styles\n * @param {?} readPrototype\n * @param {?=} destination\n * @return {?}\n */\nexport function copyStyles(styles, readPrototype, destination) {\n if (destination === void 0) { destination = {}; }\n if (readPrototype) {\n // we make use of a for-in loop so that the\n // prototypically inherited properties are\n // revealed from the backFill map\n for (var /** @type {?} */ prop in styles) {\n destination[prop] = styles[prop];\n }\n }\n else {\n copyObj(styles, destination);\n }\n return destination;\n}\n/**\n * @param {?} element\n * @param {?} styles\n * @return {?}\n */\nexport function setStyles(element, styles) {\n if (element['style']) {\n Object.keys(styles).forEach(function (prop) {\n var /** @type {?} */ camelProp = dashCaseToCamelCase(prop);\n element.style[camelProp] = styles[prop];\n });\n }\n}\n/
**\n * @param {?} element\n * @param {?} styles\n * @return {?}\n */\nexport function eraseStyles(element, styles) {\n if (element['style']) {\n Object.keys(styles).forEach(function (prop) {\n var /** @type {?} */ camelProp = dashCaseToCamelCase(prop);\n element.style[camelProp] = '';\n });\n }\n}\n/**\n * @param {?} steps\n * @return {?}\n */\nexport function normalizeAnimationEntry(steps) {\n if (Array.isArray(steps)) {\n if (steps.length == 1)\n return steps[0];\n return sequence(steps);\n }\n return /** @type {?} */ (steps);\n}\n/**\n * @param {?} value\n * @param {?} options\n * @param {?} errors\n * @return {?}\n */\nexport function validateStyleParams(value, options, errors) {\n var /** @type {?} */ params = options.params || {};\n var /** @type {?} */ matches = extractStyleParams(value);\n if (matches.length) {\n matches.forEach(function (varName) {\n if (!params.hasOwnProp
erty(varName)) {\n errors.push(\"Unable to resolve the local animation param \" + varName + \" in the given list of values\");\n }\n });\n }\n}\nvar /** @type {?} */ PARAM_REGEX = new RegExp(SUBSTITUTION_EXPR_START + \"\\\\s*(.+?)\\\\s*\" + SUBSTITUTION_EXPR_END, 'g');\n/**\n * @param {?} value\n * @return {?}\n */\nexport function extractStyleParams(value) {\n var /** @type {?} */ params = [];\n if (typeof value === 'string') {\n var /** @type {?} */ val = value.toString();\n var /** @type {?} */ match = void 0;\n while (match = PARAM_REGEX.exec(val)) {\n params.push(/** @type {?} */ (match[1]));\n }\n PARAM_REGEX.lastIndex = 0;\n }\n return params;\n}\n/**\n * @param {?} value\n * @param {?} params\n * @param {?} errors\n * @return {?}\n */\nexport function interpolateParams(value, params, errors) {\n var /** @type {?} */ original = value.toString();\n var /** @type {?} */ str = ori
ginal.replace(PARAM_REGEX, function (_, varName) {\n var /** @type {?} */ localVal = params[varName];\n // this means that the value was never overidden by the data passed in by the user\n if (!params.hasOwnProperty(varName)) {\n errors.push(\"Please provide a value for the animation param \" + varName);\n localVal = '';\n }\n return localVal.toString();\n });\n // we do this to assert that numeric values stay as they are\n return str == original ? value : str;\n}\n/**\n * @param {?} iterator\n * @return {?}\n */\nexport function iteratorToArray(iterator) {\n var /** @type {?} */ arr = [];\n var /** @type {?} */ item = iterator.next();\n while (!item.done) {\n arr.push(item.value);\n item = iterator.next();\n }\n return arr;\n}\n/**\n * @param {?} source\n * @param {?} destination\n * @return {?}\n */\nexport function mergeAnimationOptions(source, destination) {\n if (source.params) {\n
var /** @type {?} */ p0_1 = source.params;\n if (!destination.params) {\n destination.params = {};\n }\n var /** @type {?} */ p1_1 = destination.params;\n Object.keys(p0_1).forEach(function (param) {\n if (!p1_1.hasOwnProperty(param)) {\n p1_1[param] = p0_1[param];\n }\n });\n }\n return destination;\n}\nvar /** @type {?} */ DASH_CASE_REGEXP = /-+([a-z0-9])/g;\n/**\n * @param {?} input\n * @return {?}\n */\nexport function dashCaseToCamelCase(input) {\n return input.replace(DASH_CASE_REGEXP, function () {\n var m = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n m[_i] = arguments[_i];\n }\n return m[1].toUpperCase();\n });\n}\n/**\n * @param {?} duration\n * @param {?} delay\n * @return {?}\n */\nexport function allowPreviousPlayerStylesMerge(duration, delay) {\n return duration === 0 || delay === 0;\n}\n/**\n * @param {?} visitor\n
* @param {?} node\n * @param {?} context\n * @return {?}\n */\nexport function visitDslNode(visitor, node, context) {\n switch (node.type) {\n case 7 /* Trigger */:\n return visitor.visitTrigger(node, context);\n case 0 /* State */:\n return visitor.visitState(node, context);\n case 1 /* Transition */:\n return visitor.visitTransition(node, context);\n case 2 /* Sequence */:\n return visitor.visitSequence(node, context);\n case 3 /* Group */:\n return visitor.visitGroup(node, context);\n case 4 /* Animate */:\n return visitor.visitAnimate(node, context);\n case 5 /* Keyframes */:\n return visitor.visitKeyframes(node, context);\n case 6 /* Style */:\n return visitor.visitStyle(node, context);\n case 8 /* Reference */:\n return visitor.visitReference(node, context);\n case 9 /* AnimateChild */:\n return
visitor.visitAnimateChild(node, context);\n case 10 /* AnimateRef */:\n return visitor.visitAnimateRef(node, context);\n case 11 /* Query */:\n return visitor.visitQuery(node, context);\n case 12 /* Stagger */:\n return visitor.visitStagger(node, context);\n default:\n throw new Error(\"Unable to resolve animation metadata node #\" + node.type);\n }\n}\n//# sourceMappingURL=util.js.map","/**\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 */\nexport var /** @type {?} */ ANY_STATE = '*';\n/**\n * @param {?} transitionValue\n * @param {?} errors\n * @return {?}\n */\nexport function parseTransitionExpr(transitionValue, errors) {\n var /** @type {?} */ expressions = [];\n
if (typeof transitionValue == 'string') {\n (/** @type {?} */ (transitionValue))\n .split(/\\s*,\\s*/)\n .forEach(function (str) { return parseInnerTransitionStr(str, expressions, errors); });\n }\n else {\n expressions.push(/** @type {?} */ (transitionValue));\n }\n return expressions;\n}\n/**\n * @param {?} eventStr\n * @param {?} expressions\n * @param {?} errors\n * @return {?}\n */\nfunction parseInnerTransitionStr(eventStr, expressions, errors) {\n if (eventStr[0] == ':') {\n var /** @type {?} */ result = parseAnimationAlias(eventStr, errors);\n if (typeof result == 'function') {\n expressions.push(result);\n return;\n }\n eventStr = /** @type {?} */ (result);\n }\n var /** @type {?} */ match = eventStr.match(/^(\\*|[-\\w]+)\\s*(<?[=-]>)\\s*(\\*|[-\\w]+)$/);\n if (match == null || match.length < 4) {\n errors.push(\"The provided transition expression \\\"\" +
eventStr + \"\\\" is not supported\");\n return expressions;\n }\n var /** @type {?} */ fromState = match[1];\n var /** @type {?} */ separator = match[2];\n var /** @type {?} */ toState = match[3];\n expressions.push(makeLambdaFromStates(fromState, toState));\n var /** @type {?} */ isFullAnyStateExpr = fromState == ANY_STATE && toState == ANY_STATE;\n if (separator[0] == '<' && !isFullAnyStateExpr) {\n expressions.push(makeLambdaFromStates(toState, fromState));\n }\n}\n/**\n * @param {?} alias\n * @param {?} errors\n * @return {?}\n */\nfunction parseAnimationAlias(alias, errors) {\n switch (alias) {\n case ':enter':\n return 'void => *';\n case ':leave':\n return '* => void';\n case ':increment':\n return function (fromState, toState) { return parseFloat(toState) > parseFloat(fromState); };\n case ':decrement':\n return function (fromState, toState) { return parseFloat(
toState) < parseFloat(fromState); };\n default:\n errors.push(\"The transition alias value \\\"\" + alias + \"\\\" is not supported\");\n return '* => *';\n }\n}\n// DO NOT REFACTOR ... keep the follow set instantiations\n// with the values intact (closure compiler for some reason\n// removes follow-up lines that add the values outside of\n// the constructor...\nvar /** @type {?} */ TRUE_BOOLEAN_VALUES = new Set(['true', '1']);\nvar /** @type {?} */ FALSE_BOOLEAN_VALUES = new Set(['false', '0']);\n/**\n * @param {?} lhs\n * @param {?} rhs\n * @return {?}\n */\nfunction makeLambdaFromStates(lhs, rhs) {\n var /** @type {?} */ LHS_MATCH_BOOLEAN = TRUE_BOOLEAN_VALUES.has(lhs) || FALSE_BOOLEAN_VALUES.has(lhs);\n var /** @type {?} */ RHS_MATCH_BOOLEAN = TRUE_BOOLEAN_VALUES.has(rhs) || FALSE_BOOLEAN_VALUES.has(rhs);\n return function (fromState, toState) {\n var /** @type {?} */ lhsMatch = lhs == ANY_STATE || lhs == fromState;\n var /*
* @type {?} */ rhsMatch = rhs == ANY_STATE || rhs == toState;\n if (!lhsMatch && LHS_MATCH_BOOLEAN && typeof fromState === 'boolean') {\n lhsMatch = fromState ? TRUE_BOOLEAN_VALUES.has(lhs) : FALSE_BOOLEAN_VALUES.has(lhs);\n }\n if (!rhsMatch && RHS_MATCH_BOOLEAN && typeof toState === 'boolean') {\n rhsMatch = toState ? TRUE_BOOLEAN_VALUES.has(rhs) : FALSE_BOOLEAN_VALUES.has(rhs);\n }\n return lhsMatch && rhsMatch;\n };\n}\n//# sourceMappingURL=animation_transition_expr.js.map","/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\nimport { AUTO_STYLE, style } from '@angular/animations';\nimport { getOrSetAsInMap } from '../render/shared';\nimport { NG_ANIMATING_SELECTOR, NG_TRIGGER_SELECTOR, SUBSTITUTION_EXPR_START, copyObj, extractStyleParams, iteratorToArray, normalizeAnimationEntry, resolveTiming, validateStyleParams, visitDslNode } from '../util';\nimport { parseTransitionExpr } from '.
/animation_transition_expr';\nvar /** @type {?} */ SELF_TOKEN = ':self';\nvar /** @type {?} */ SELF_TOKEN_REGEX = new RegExp(\"s*\" + SELF_TOKEN + \"s*,?\", 'g');\n/**\n * @param {?} driver\n * @param {?} metadata\n * @param {?} errors\n * @return {?}\n */\nexport function buildAnimationAst(driver, metadata, errors) {\n return new AnimationAstBuilderVisitor(driver).build(metadata, errors);\n}\nvar /** @type {?} */ ROOT_SELECTOR = '';\nvar AnimationAstBuilderVisitor = /** @class */ (function () {\n function AnimationAstBuilderVisitor(_driver) {\n this._driver = _driver;\n }\n /**\n * @param {?} metadata\n * @param {?} errors\n * @return {?}\n */\n AnimationAstBuilderVisitor.prototype.build = /**\n * @param {?} metadata\n * @param {?} errors\n * @return {?}\n */\n function (metadata, errors) {\n var /** @type {?} */ context = new AnimationAstBuilderContext(errors);\n this._resetContextStyleTimingState(context);\n
return /** @type {?} */ (visitDslNode(this, normalizeAnimationEntry(metadata), context));\n };\n /**\n * @param {?} context\n * @return {?}\n */\n AnimationAstBuilderVisitor.prototype._resetContextStyleTimingState = /**\n * @param {?} context\n * @return {?}\n */\n function (context) {\n context.currentQuerySelector = ROOT_SELECTOR;\n context.collectedStyles = {};\n context.collectedStyles[ROOT_SELECTOR] = {};\n context.currentTime = 0;\n };\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n AnimationAstBuilderVisitor.prototype.visitTrigger = /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n function (metadata, context) {\n var _this = this;\n var /** @type {?} */ queryCount = context.queryCount = 0;\n var /** @type {?} */ depCount = context.depCount = 0;\n var /** @type {?} */ states = [];\n
var /** @type {?} */ transitions = [];\n if (metadata.name.charAt(0) == '@') {\n context.errors.push('animation triggers cannot be prefixed with an `@` sign (e.g. trigger(\\'@foo\\', [...]))');\n }\n metadata.definitions.forEach(function (def) {\n _this._resetContextStyleTimingState(context);\n if (def.type == 0 /* State */) {\n var /** @type {?} */ stateDef_1 = /** @type {?} */ (def);\n var /** @type {?} */ name_1 = stateDef_1.name;\n name_1.split(/\\s*,\\s*/).forEach(function (n) {\n stateDef_1.name = n;\n states.push(_this.visitState(stateDef_1, context));\n });\n stateDef_1.name = name_1;\n }\n else if (def.type == 1 /* Transition */) {\n var /** @type {?} */ transition = _this.visitTransition(/** @type {?} */ (def), context);\n queryCount += transition.query
Count;\n depCount += transition.depCount;\n transitions.push(transition);\n }\n else {\n context.errors.push('only state() and transition() definitions can sit inside of a trigger()');\n }\n });\n return {\n type: 7 /* Trigger */,\n name: metadata.name, states: states, transitions: transitions, queryCount: queryCount, depCount: depCount,\n options: null\n };\n };\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n AnimationAstBuilderVisitor.prototype.visitState = /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n function (metadata, context) {\n var /** @type {?} */ styleAst = this.visitStyle(metadata.styles, context);\n var /** @type {?} */ astParams = (metadata.options && metadata.options.params) || null;\n if (styleAst.containsDynamicStyles
) {\n var /** @type {?} */ missingSubs_1 = new Set();\n var /** @type {?} */ params_1 = astParams || {};\n styleAst.styles.forEach(function (value) {\n if (isObject(value)) {\n var /** @type {?} */ stylesObj_1 = /** @type {?} */ (value);\n Object.keys(stylesObj_1).forEach(function (prop) {\n extractStyleParams(stylesObj_1[prop]).forEach(function (sub) {\n if (!params_1.hasOwnProperty(sub)) {\n missingSubs_1.add(sub);\n }\n });\n });\n }\n });\n if (missingSubs_1.size) {\n var /** @type {?} */ missingSubsArr = iteratorToArray(missingSubs_1.values());\n context.errors.push(\"state(\\\"\" + metadata.name + \"\\\", ...) must define default values for all the following style substitutions:
\" + missingSubsArr.join(', '));\n }\n }\n return {\n type: 0 /* State */,\n name: metadata.name,\n style: styleAst,\n options: astParams ? { params: astParams } : null\n };\n };\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n AnimationAstBuilderVisitor.prototype.visitTransition = /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n function (metadata, context) {\n context.queryCount = 0;\n context.depCount = 0;\n var /** @type {?} */ animation = visitDslNode(this, normalizeAnimationEntry(metadata.animation), context);\n var /** @type {?} */ matchers = parseTransitionExpr(metadata.expr, context.errors);\n return {\n type: 1 /* Transition */,\n matchers: matchers,\n animation: animation,\n queryCount: context.queryCount,\n depCou
nt: context.depCount,\n options: normalizeAnimationOptions(metadata.options)\n };\n };\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n AnimationAstBuilderVisitor.prototype.visitSequence = /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n function (metadata, context) {\n var _this = this;\n return {\n type: 2 /* Sequence */,\n steps: metadata.steps.map(function (s) { return visitDslNode(_this, s, context); }),\n options: normalizeAnimationOptions(metadata.options)\n };\n };\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n AnimationAstBuilderVisitor.prototype.visitGroup = /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n function (metadata, context) {\n var _this = this;\n var /** @type {?} */ currentTime = conte
xt.currentTime;\n var /** @type {?} */ furthestTime = 0;\n var /** @type {?} */ steps = metadata.steps.map(function (step) {\n context.currentTime = currentTime;\n var /** @type {?} */ innerAst = visitDslNode(_this, step, context);\n furthestTime = Math.max(furthestTime, context.currentTime);\n return innerAst;\n });\n context.currentTime = furthestTime;\n return {\n type: 3 /* Group */,\n steps: steps,\n options: normalizeAnimationOptions(metadata.options)\n };\n };\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n AnimationAstBuilderVisitor.prototype.visitAnimate = /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n function (metadata, context) {\n var /** @type {?} */ timingAst = constructTimingAst(metadata.timings, context.errors);\n context.currentAnimateTi
mings = timingAst;\n var /** @type {?} */ styleAst;\n var /** @type {?} */ styleMetadata = metadata.styles ? metadata.styles : style({});\n if (styleMetadata.type == 5 /* Keyframes */) {\n styleAst = this.visitKeyframes(/** @type {?} */ (styleMetadata), context);\n }\n else {\n var /** @type {?} */ styleMetadata_1 = /** @type {?} */ (metadata.styles);\n var /** @type {?} */ isEmpty = false;\n if (!styleMetadata_1) {\n isEmpty = true;\n var /** @type {?} */ newStyleData = {};\n if (timingAst.easing) {\n newStyleData['easing'] = timingAst.easing;\n }\n styleMetadata_1 = style(newStyleData);\n }\n context.currentTime += timingAst.duration + timingAst.delay;\n var /** @type {?} */ _styleAst = this.visitStyle(styleMetadata_1, context);\n _styleAst.isEmptyStep = isEmpty;\n
styleAst = _styleAst;\n }\n context.currentAnimateTimings = null;\n return {\n type: 4 /* Animate */,\n timings: timingAst,\n style: styleAst,\n options: null\n };\n };\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n AnimationAstBuilderVisitor.prototype.visitStyle = /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n function (metadata, context) {\n var /** @type {?} */ ast = this._makeStyleAst(metadata, context);\n this._validateStyleAst(ast, context);\n return ast;\n };\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n AnimationAstBuilderVisitor.prototype._makeStyleAst = /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n function (metadata, context) {\n var /** @type {?} */ styles = [];\n
if (Array.isArray(metadata.styles)) {\n (/** @type {?} */ (metadata.styles)).forEach(function (styleTuple) {\n if (typeof styleTuple == 'string') {\n if (styleTuple == AUTO_STYLE) {\n styles.push(/** @type {?} */ (styleTuple));\n }\n else {\n context.errors.push(\"The provided style string value \" + styleTuple + \" is not allowed.\");\n }\n }\n else {\n styles.push(/** @type {?} */ (styleTuple));\n }\n });\n }\n else {\n styles.push(metadata.styles);\n }\n var /** @type {?} */ containsDynamicStyles = false;\n var /** @type {?} */ collectedEasing = null;\n styles.forEach(function (styleData) {\n if (isObject(styleData)) {\n var /** @type {?} */ styleMap = /** @type {?} */ (styleDa
ta);\n var /** @type {?} */ easing = styleMap['easing'];\n if (easing) {\n collectedEasing = /** @type {?} */ (easing);\n delete styleMap['easing'];\n }\n if (!containsDynamicStyles) {\n for (var /** @type {?} */ prop in styleMap) {\n var /** @type {?} */ value = styleMap[prop];\n if (value.toString().indexOf(SUBSTITUTION_EXPR_START) >= 0) {\n containsDynamicStyles = true;\n break;\n }\n }\n }\n }\n });\n return {\n type: 6 /* Style */,\n styles: styles,\n easing: collectedEasing,\n offset: metadata.offset, containsDynamicStyles: containsDynamicStyles,\n options: null\n };\n };\n /**\n * @param {?} ast\n * @param {
?} context\n * @return {?}\n */\n AnimationAstBuilderVisitor.prototype._validateStyleAst = /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n function (ast, context) {\n var _this = this;\n var /** @type {?} */ timings = context.currentAnimateTimings;\n var /** @type {?} */ endTime = context.currentTime;\n var /** @type {?} */ startTime = context.currentTime;\n if (timings && startTime > 0) {\n startTime -= timings.duration + timings.delay;\n }\n ast.styles.forEach(function (tuple) {\n if (typeof tuple == 'string')\n return;\n Object.keys(tuple).forEach(function (prop) {\n if (!_this._driver.validateStyleProperty(prop)) {\n context.errors.push(\"The provided animation property \\\"\" + prop + \"\\\" is not a supported CSS property for animations\");\n return;\n }\n
var /** @type {?} */ collectedStyles = context.collectedStyles[/** @type {?} */ ((context.currentQuerySelector))];\n var /** @type {?} */ collectedEntry = collectedStyles[prop];\n var /** @type {?} */ updateCollectedStyle = true;\n if (collectedEntry) {\n if (startTime != endTime && startTime >= collectedEntry.startTime &&\n endTime <= collectedEntry.endTime) {\n context.errors.push(\"The CSS property \\\"\" + prop + \"\\\" that exists between the times of \\\"\" + collectedEntry.startTime + \"ms\\\" and \\\"\" + collectedEntry.endTime + \"ms\\\" is also being animated in a parallel animation between the times of \\\"\" + startTime + \"ms\\\" and \\\"\" + endTime + \"ms\\\"\");\n updateCollectedStyle = false;\n }\n // we always choose the smaller start time value since we\n // want to have
a record of the entire animation window where\n // the style property is being animated in between\n startTime = collectedEntry.startTime;\n }\n if (updateCollectedStyle) {\n collectedStyles[prop] = { startTime: startTime, endTime: endTime };\n }\n if (context.options) {\n validateStyleParams(tuple[prop], context.options, context.errors);\n }\n });\n });\n };\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n AnimationAstBuilderVisitor.prototype.visitKeyframes = /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n function (metadata, context) {\n var _this = this;\n var /** @type {?} */ ast = { type: 5 /* Keyframes */, styles: [], options: null };\n if (!context.currentAnimateTimings) {\n context
.errors.push(\"keyframes() must be placed inside of a call to animate()\");\n return ast;\n }\n var /** @type {?} */ MAX_KEYFRAME_OFFSET = 1;\n var /** @type {?} */ totalKeyframesWithOffsets = 0;\n var /** @type {?} */ offsets = [];\n var /** @type {?} */ offsetsOutOfOrder = false;\n var /** @type {?} */ keyframesOutOfRange = false;\n var /** @type {?} */ previousOffset = 0;\n var /** @type {?} */ keyframes = metadata.steps.map(function (styles) {\n var /** @type {?} */ style = _this._makeStyleAst(styles, context);\n var /** @type {?} */ offsetVal = style.offset != null ? style.offset : consumeOffset(style.styles);\n var /** @type {?} */ offset = 0;\n if (offsetVal != null) {\n totalKeyframesWithOffsets++;\n offset = style.offset = offsetVal;\n }\n keyframesOutOfRange = keyframesOutOfRange || offset < 0 || offset > 1;\n
offsetsOutOfOrder = offsetsOutOfOrder || offset < previousOffset;\n previousOffset = offset;\n offsets.push(offset);\n return style;\n });\n if (keyframesOutOfRange) {\n context.errors.push(\"Please ensure that all keyframe offsets are between 0 and 1\");\n }\n if (offsetsOutOfOrder) {\n context.errors.push(\"Please ensure that all keyframe offsets are in order\");\n }\n var /** @type {?} */ length = metadata.steps.length;\n var /** @type {?} */ generatedOffset = 0;\n if (totalKeyframesWithOffsets > 0 && totalKeyframesWithOffsets < length) {\n context.errors.push(\"Not all style() steps within the declared keyframes() contain offsets\");\n }\n else if (totalKeyframesWithOffsets == 0) {\n generatedOffset = MAX_KEYFRAME_OFFSET / (length - 1);\n }\n var /** @type {?} */ limit = length - 1;\n var /** @type {?} */
currentTime = context.currentTime;\n var /** @type {?} */ currentAnimateTimings = /** @type {?} */ ((context.currentAnimateTimings));\n var /** @type {?} */ animateDuration = currentAnimateTimings.duration;\n keyframes.forEach(function (kf, i) {\n var /** @type {?} */ offset = generatedOffset > 0 ? (i == limit ? 1 : (generatedOffset * i)) : offsets[i];\n var /** @type {?} */ durationUpToThisFrame = offset * animateDuration;\n context.currentTime = currentTime + currentAnimateTimings.delay + durationUpToThisFrame;\n currentAnimateTimings.duration = durationUpToThisFrame;\n _this._validateStyleAst(kf, context);\n kf.offset = offset;\n ast.styles.push(kf);\n });\n return ast;\n };\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n AnimationAstBuilderVisitor.prototype.visitReference = /**\n * @param {?} metadata\n * @p
aram {?} context\n * @return {?}\n */\n function (metadata, context) {\n return {\n type: 8 /* Reference */,\n animation: visitDslNode(this, normalizeAnimationEntry(metadata.animation), context),\n options: normalizeAnimationOptions(metadata.options)\n };\n };\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n AnimationAstBuilderVisitor.prototype.visitAnimateChild = /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n function (metadata, context) {\n context.depCount++;\n return {\n type: 9 /* AnimateChild */,\n options: normalizeAnimationOptions(metadata.options)\n };\n };\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n AnimationAstBuilderVisitor.prototype.visitAnimateRef = /**\n * @param {?} metadata\n * @param {?} context\n * @r
eturn {?}\n */\n function (metadata, context) {\n return {\n type: 10 /* AnimateRef */,\n animation: this.visitReference(metadata.animation, context),\n options: normalizeAnimationOptions(metadata.options)\n };\n };\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n AnimationAstBuilderVisitor.prototype.visitQuery = /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n function (metadata, context) {\n var /** @type {?} */ parentSelector = /** @type {?} */ ((context.currentQuerySelector));\n var /** @type {?} */ options = /** @type {?} */ ((metadata.options || {}));\n context.queryCount++;\n context.currentQuery = metadata;\n var _a = normalizeSelector(metadata.selector), selector = _a[0], includeSelf = _a[1];\n context.currentQuerySelector =\n parentSelector.length ? (parentSelector + ' ' +
selector) : selector;\n getOrSetAsInMap(context.collectedStyles, context.currentQuerySelector, {});\n var /** @type {?} */ animation = visitDslNode(this, normalizeAnimationEntry(metadata.animation), context);\n context.currentQuery = null;\n context.currentQuerySelector = parentSelector;\n return {\n type: 11 /* Query */,\n selector: selector,\n limit: options.limit || 0,\n optional: !!options.optional, includeSelf: includeSelf, animation: animation,\n originalSelector: metadata.selector,\n options: normalizeAnimationOptions(metadata.options)\n };\n };\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n AnimationAstBuilderVisitor.prototype.visitStagger = /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n function (metadata, context) {\n if (!context.currentQuery) {\n co
ntext.errors.push(\"stagger() can only be used inside of query()\");\n }\n var /** @type {?} */ timings = metadata.timings === 'full' ?\n { duration: 0, delay: 0, easing: 'full' } :\n resolveTiming(metadata.timings, context.errors, true);\n return {\n type: 12 /* Stagger */,\n animation: visitDslNode(this, normalizeAnimationEntry(metadata.animation), context), timings: timings,\n options: null\n };\n };\n return AnimationAstBuilderVisitor;\n}());\nexport { AnimationAstBuilderVisitor };\nfunction AnimationAstBuilderVisitor_tsickle_Closure_declarations() {\n /** @type {?} */\n AnimationAstBuilderVisitor.prototype._driver;\n}\n/**\n * @param {?} selector\n * @return {?}\n */\nfunction normalizeSelector(selector) {\n var /** @type {?} */ hasAmpersand = selector.split(/\\s*,\\s*/).find(function (token) { return token == SELF_TOKEN; }) ? true : false;\n if (hasAmpersand) {\n selecto
r = selector.replace(SELF_TOKEN_REGEX, '');\n }\n // the :enter and :leave selectors are filled in at runtime during timeline building\n selector = selector.replace(/@\\*/g, NG_TRIGGER_SELECTOR)\n .replace(/@\\w+/g, function (match) { return NG_TRIGGER_SELECTOR + '-' + match.substr(1); })\n .replace(/:animating/g, NG_ANIMATING_SELECTOR);\n return [selector, hasAmpersand];\n}\n/**\n * @param {?} obj\n * @return {?}\n */\nfunction normalizeParams(obj) {\n return obj ? copyObj(obj) : null;\n}\nvar AnimationAstBuilderContext = /** @class */ (function () {\n function AnimationAstBuilderContext(errors) {\n this.errors = errors;\n this.queryCount = 0;\n this.depCount = 0;\n this.currentTransition = null;\n this.currentQuery = null;\n this.currentQuerySelector = null;\n this.currentAnimateTimings = null;\n this.currentTime = 0;\n this.collectedStyles = {};\n this.options = null;\n }\n
return AnimationAstBuilderContext;\n}());\nexport { AnimationAstBuilderContext };\nfunction AnimationAstBuilderContext_tsickle_Closure_declarations() {\n /** @type {?} */\n AnimationAstBuilderContext.prototype.queryCount;\n /** @type {?} */\n AnimationAstBuilderContext.prototype.depCount;\n /** @type {?} */\n AnimationAstBuilderContext.prototype.currentTransition;\n /** @type {?} */\n AnimationAstBuilderContext.prototype.currentQuery;\n /** @type {?} */\n AnimationAstBuilderContext.prototype.currentQuerySelector;\n /** @type {?} */\n AnimationAstBuilderContext.prototype.currentAnimateTimings;\n /** @type {?} */\n AnimationAstBuilderContext.prototype.currentTime;\n /** @type {?} */\n AnimationAstBuilderContext.prototype.collectedStyles;\n /** @type {?} */\n AnimationAstBuilderContext.prototype.options;\n /** @type {?} */\n AnimationAstBuilderContext.prototype.errors;\n}\n/**\n * @param {?} styles\n * @return {?}\n */\nfunct
ion consumeOffset(styles) {\n if (typeof styles == 'string')\n return null;\n var /** @type {?} */ offset = null;\n if (Array.isArray(styles)) {\n styles.forEach(function (styleTuple) {\n if (isObject(styleTuple) && styleTuple.hasOwnProperty('offset')) {\n var /** @type {?} */ obj = /** @type {?} */ (styleTuple);\n offset = parseFloat(/** @type {?} */ (obj['offset']));\n delete obj['offset'];\n }\n });\n }\n else if (isObject(styles) && styles.hasOwnProperty('offset')) {\n var /** @type {?} */ obj = /** @type {?} */ (styles);\n offset = parseFloat(/** @type {?} */ (obj['offset']));\n delete obj['offset'];\n }\n return offset;\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction isObject(value) {\n return !Array.isArray(value) && typeof value == 'object';\n}\n/**\n * @param {?} value\n * @param {?} errors\n * @return {?}\n */\nfunction constructT
imingAst(value, errors) {\n var /** @type {?} */ timings = null;\n if (value.hasOwnProperty('duration')) {\n timings = /** @type {?} */ (value);\n }\n else if (typeof value == 'number') {\n var /** @type {?} */ duration = resolveTiming(/** @type {?} */ (value), errors).duration;\n return makeTimingAst(/** @type {?} */ (duration), 0, '');\n }\n var /** @type {?} */ strValue = /** @type {?} */ (value);\n var /** @type {?} */ isDynamic = strValue.split(/\\s+/).some(function (v) { return v.charAt(0) == '{' && v.charAt(1) == '{'; });\n if (isDynamic) {\n var /** @type {?} */ ast = /** @type {?} */ (makeTimingAst(0, 0, ''));\n ast.dynamic = true;\n ast.strValue = strValue;\n return /** @type {?} */ (ast);\n }\n timings = timings || resolveTiming(strValue, errors);\n return makeTimingAst(timings.duration, timings.delay, timings.easing);\n}\n/**\n * @param {?} options\n * @return {?}\n */\nfunction normalizeAn
imationOptions(options) {\n if (options) {\n options = copyObj(options);\n if (options['params']) {\n options['params'] = /** @type {?} */ ((normalizeParams(options['params'])));\n }\n }\n else {\n options = {};\n }\n return options;\n}\n/**\n * @param {?} duration\n * @param {?} delay\n * @param {?} easing\n * @return {?}\n */\nfunction makeTimingAst(duration, delay, easing) {\n return { duration: duration, delay: delay, easing: easing };\n}\n//# sourceMappingURL=animation_ast_builder.js.map","/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @record\n */\nexport function AnimationTimelineInstruction() { }\nfunction AnimationTimelineInstruction_tsickle_Closure_declarations() {\n /** @type {?} */\n AnimationTimelineInstruction.prototype.element;\n /** @type {?} */\n AnimationTimelineInstruction.prototype.keyframes;\n /** @type {?} */\n AnimationTimelineInstruction.
prototype.preStyleProps;\n /** @type {?} */\n AnimationTimelineInstruction.prototype.postStyleProps;\n /** @type {?} */\n AnimationTimelineInstruction.prototype.duration;\n /** @type {?} */\n AnimationTimelineInstruction.prototype.delay;\n /** @type {?} */\n AnimationTimelineInstruction.prototype.totalTime;\n /** @type {?} */\n AnimationTimelineInstruction.prototype.easing;\n /** @type {?|undefined} */\n AnimationTimelineInstruction.prototype.stretchStartingKeyframe;\n /** @type {?} */\n AnimationTimelineInstruction.prototype.subTimeline;\n}\n/**\n * @param {?} element\n * @param {?} keyframes\n * @param {?} preStyleProps\n * @param {?} postStyleProps\n * @param {?} duration\n * @param {?} delay\n * @param {?=} easing\n * @param {?=} subTimeline\n * @return {?}\n */\nexport function createTimelineInstruction(element, keyframes, preStyleProps, postStyleProps, duration, delay, easing, subTimeline) {\n if (easing === void 0) { easing = null;
}\n if (subTimeline === void 0) { subTimeline = false; }\n return {\n type: 1 /* TimelineAnimation */,\n element: element,\n keyframes: keyframes,\n preStyleProps: preStyleProps,\n postStyleProps: postStyleProps,\n duration: duration,\n delay: delay,\n totalTime: duration + delay, easing: easing, subTimeline: subTimeline\n };\n}\n//# sourceMappingURL=animation_timeline_instruction.js.map","/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\nvar ElementInstructionMap = /** @class */ (function () {\n function ElementInstructionMap() {\n this._map = new Map();\n }\n /**\n * @param {?} element\n * @return {?}\n */\n ElementInstructionMap.prototype.consume = /**\n * @param {?} element\n * @return {?}\n */\n function (element) {\n var /** @type {?} */ instructions = this._map.get(element);\n if (instructions) {\n this._
map.delete(element);\n }\n else {\n instructions = [];\n }\n return instructions;\n };\n /**\n * @param {?} element\n * @param {?} instructions\n * @return {?}\n */\n ElementInstructionMap.prototype.append = /**\n * @param {?} element\n * @param {?} instructions\n * @return {?}\n */\n function (element, instructions) {\n var /** @type {?} */ existingInstructions = this._map.get(element);\n if (!existingInstructions) {\n this._map.set(element, existingInstructions = []);\n }\n existingInstructions.push.apply(existingInstructions, instructions);\n };\n /**\n * @param {?} element\n * @return {?}\n */\n ElementInstructionMap.prototype.has = /**\n * @param {?} element\n * @return {?}\n */\n function (element) { return this._map.has(element); };\n /**\n * @return {?}\n */\n ElementInstructionMap.prototype.clear = /**\n
* @return {?}\n */\n function () { this._map.clear(); };\n return ElementInstructionMap;\n}());\nexport { ElementInstructionMap };\nfunction ElementInstructionMap_tsickle_Closure_declarations() {\n /** @type {?} */\n ElementInstructionMap.prototype._map;\n}\n//# sourceMappingURL=element_instruction_map.js.map","/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\nimport * as tslib_1 from \"tslib\";\nimport { AUTO_STYLE, ɵPRE_STYLE as PRE_STYLE } from '@angular/animations';\nimport { copyObj, copyStyles, interpolateParams, iteratorToArray, resolveTiming, resolveTimingValue, visitDslNode } from '../util';\nimport { createTimelineInstruction } from './animation_timeline_instruction';\nimport { ElementInstructionMap } from './element_instruction_map';\nvar /** @type {?} */ ONE_FRAME_IN_MILLISECONDS = 1;\nvar /** @type {?} */ ENTER_TOKEN = ':enter';\nvar /** @type {?} */ ENTER_TOKEN_REGEX = new RegExp(ENTER_TOKEN, 'g');\nvar /** @typ
e {?} */ LEAVE_TOKEN = ':leave';\nvar /** @type {?} */ LEAVE_TOKEN_REGEX = new RegExp(LEAVE_TOKEN, 'g');\n/**\n * @param {?} driver\n * @param {?} rootElement\n * @param {?} ast\n * @param {?} enterClassName\n * @param {?} leaveClassName\n * @param {?=} startingStyles\n * @param {?=} finalStyles\n * @param {?=} options\n * @param {?=} subInstructions\n * @param {?=} errors\n * @return {?}\n */\nexport function buildAnimationTimelines(driver, rootElement, ast, enterClassName, leaveClassName, startingStyles, finalStyles, options, subInstructions, errors) {\n if (startingStyles === void 0) { startingStyles = {}; }\n if (finalStyles === void 0) { finalStyles = {}; }\n if (errors === void 0) { errors = []; }\n return new AnimationTimelineBuilderVisitor().buildKeyframes(driver, rootElement, ast, enterClassName, leaveClassName, startingStyles, finalStyles, options, subInstructions, errors);\n}\nvar AnimationTimelineBuilderVisitor = /** @class */ (function () {\n function Ani
mationTimelineBuilderVisitor() {\n }\n /**\n * @param {?} driver\n * @param {?} rootElement\n * @param {?} ast\n * @param {?} enterClassName\n * @param {?} leaveClassName\n * @param {?} startingStyles\n * @param {?} finalStyles\n * @param {?} options\n * @param {?=} subInstructions\n * @param {?=} errors\n * @return {?}\n */\n AnimationTimelineBuilderVisitor.prototype.buildKeyframes = /**\n * @param {?} driver\n * @param {?} rootElement\n * @param {?} ast\n * @param {?} enterClassName\n * @param {?} leaveClassName\n * @param {?} startingStyles\n * @param {?} finalStyles\n * @param {?} options\n * @param {?=} subInstructions\n * @param {?=} errors\n * @return {?}\n */\n function (driver, rootElement, ast, enterClassName, leaveClassName, startingStyles, finalStyles, options, subInstructions, errors) {\n if (errors === void 0) { errors = []; }\n subInstructions = su
bInstructions || new ElementInstructionMap();\n var /** @type {?} */ context = new AnimationTimelineContext(driver, rootElement, subInstructions, enterClassName, leaveClassName, errors, []);\n context.options = options;\n context.currentTimeline.setStyles([startingStyles], null, context.errors, options);\n visitDslNode(this, ast, context);\n // this checks to see if an actual animation happened\n var /** @type {?} */ timelines = context.timelines.filter(function (timeline) { return timeline.containsAnimation(); });\n if (timelines.length && Object.keys(finalStyles).length) {\n var /** @type {?} */ tl = timelines[timelines.length - 1];\n if (!tl.allowOnlyTimelineStyles()) {\n tl.setStyles([finalStyles], null, context.errors, options);\n }\n }\n return timelines.length ? timelines.map(function (timeline) { return timeline.buildKeyframes(); }) :\n [createTimelineIns
truction(rootElement, [], [], [], 0, 0, '', false)];\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AnimationTimelineBuilderVisitor.prototype.visitTrigger = /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n function (ast, context) {\n // these values are not visited in this AST\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AnimationTimelineBuilderVisitor.prototype.visitState = /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n function (ast, context) {\n // these values are not visited in this AST\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AnimationTimelineBuilderVisitor.prototype.visitTransition = /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n function (ast, context) {\n // these val
ues are not visited in this AST\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AnimationTimelineBuilderVisitor.prototype.visitAnimateChild = /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n function (ast, context) {\n var /** @type {?} */ elementInstructions = context.subInstructions.consume(context.element);\n if (elementInstructions) {\n var /** @type {?} */ innerContext = context.createSubContext(ast.options);\n var /** @type {?} */ startTime = context.currentTimeline.currentTime;\n var /** @type {?} */ endTime = this._visitSubInstructions(elementInstructions, innerContext, /** @type {?} */ (innerContext.options));\n if (startTime != endTime) {\n // we do this on the upper context because we created a sub context for\n // the sub child animations\n context.transformIntoNewTimeline(endTim
e);\n }\n }\n context.previousNode = ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AnimationTimelineBuilderVisitor.prototype.visitAnimateRef = /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n function (ast, context) {\n var /** @type {?} */ innerContext = context.createSubContext(ast.options);\n innerContext.transformIntoNewTimeline();\n this.visitReference(ast.animation, innerContext);\n context.transformIntoNewTimeline(innerContext.currentTimeline.currentTime);\n context.previousNode = ast;\n };\n /**\n * @param {?} instructions\n * @param {?} context\n * @param {?} options\n * @return {?}\n */\n AnimationTimelineBuilderVisitor.prototype._visitSubInstructions = /**\n * @param {?} instructions\n * @param {?} context\n * @param {?} options\n * @return {?}\n */\n function (ins
tructions, context, options) {\n var /** @type {?} */ startTime = context.currentTimeline.currentTime;\n var /** @type {?} */ furthestTime = startTime;\n // this is a special-case for when a user wants to skip a sub\n // animation from being fired entirely.\n var /** @type {?} */ duration = options.duration != null ? resolveTimingValue(options.duration) : null;\n var /** @type {?} */ delay = options.delay != null ? resolveTimingValue(options.delay) : null;\n if (duration !== 0) {\n instructions.forEach(function (instruction) {\n var /** @type {?} */ instructionTimings = context.appendInstructionToTimeline(instruction, duration, delay);\n furthestTime =\n Math.max(furthestTime, instructionTimings.duration + instructionTimings.delay);\n });\n }\n return furthestTime;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\
n */\n AnimationTimelineBuilderVisitor.prototype.visitReference = /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n function (ast, context) {\n context.updateOptions(ast.options, true);\n visitDslNode(this, ast.animation, context);\n context.previousNode = ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AnimationTimelineBuilderVisitor.prototype.visitSequence = /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n function (ast, context) {\n var _this = this;\n var /** @type {?} */ subContextCount = context.subContextCount;\n var /** @type {?} */ ctx = context;\n var /** @type {?} */ options = ast.options;\n if (options && (options.params || options.delay)) {\n ctx = context.createSubContext(options);\n ctx.transformIntoNewTimeline();\n if (options.delay != null
) {\n if (ctx.previousNode.type == 6 /* Style */) {\n ctx.currentTimeline.snapshotCurrentStyles();\n ctx.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;\n }\n var /** @type {?} */ delay = resolveTimingValue(options.delay);\n ctx.delayNextStep(delay);\n }\n }\n if (ast.steps.length) {\n ast.steps.forEach(function (s) { return visitDslNode(_this, s, ctx); });\n // this is here just incase the inner steps only contain or end with a style() call\n ctx.currentTimeline.applyStylesToKeyframe();\n // this means that some animation function within the sequence\n // ended up creating a sub timeline (which means the current\n // timeline cannot overlap with the contents of the sequence)\n if (ctx.subContextCount > subContextCount) {\n ctx.transformIntoNewTimeline();\n }\n
}\n context.previousNode = ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AnimationTimelineBuilderVisitor.prototype.visitGroup = /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n function (ast, context) {\n var _this = this;\n var /** @type {?} */ innerTimelines = [];\n var /** @type {?} */ furthestTime = context.currentTimeline.currentTime;\n var /** @type {?} */ delay = ast.options && ast.options.delay ? resolveTimingValue(ast.options.delay) : 0;\n ast.steps.forEach(function (s) {\n var /** @type {?} */ innerContext = context.createSubContext(ast.options);\n if (delay) {\n innerContext.delayNextStep(delay);\n }\n visitDslNode(_this, s, innerContext);\n furthestTime = Math.max(furthestTime, innerContext.currentTimeline.currentTime);\n innerTimelines.push(innerCon
text.currentTimeline);\n });\n // this operation is run after the AST loop because otherwise\n // if the parent timeline's collected styles were updated then\n // it would pass in invalid data into the new-to-be forked items\n innerTimelines.forEach(function (timeline) { return context.currentTimeline.mergeTimelineCollectedStyles(timeline); });\n context.transformIntoNewTimeline(furthestTime);\n context.previousNode = ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AnimationTimelineBuilderVisitor.prototype._visitTiming = /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n function (ast, context) {\n if ((/** @type {?} */ (ast)).dynamic) {\n var /** @type {?} */ strValue = (/** @type {?} */ (ast)).strValue;\n var /** @type {?} */ timingValue = context.params ? interpolateParams(strValue, context.params, context.err
ors) : strValue;\n return resolveTiming(timingValue, context.errors);\n }\n else {\n return { duration: ast.duration, delay: ast.delay, easing: ast.easing };\n }\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AnimationTimelineBuilderVisitor.prototype.visitAnimate = /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n function (ast, context) {\n var /** @type {?} */ timings = context.currentAnimateTimings = this._visitTiming(ast.timings, context);\n var /** @type {?} */ timeline = context.currentTimeline;\n if (timings.delay) {\n context.incrementTime(timings.delay);\n timeline.snapshotCurrentStyles();\n }\n var /** @type {?} */ style = ast.style;\n if (style.type == 5 /* Keyframes */) {\n this.visitKeyframes(style, context);\n }\n else {\n context.increme
ntTime(timings.duration);\n this.visitStyle(/** @type {?} */ (style), context);\n timeline.applyStylesToKeyframe();\n }\n context.currentAnimateTimings = null;\n context.previousNode = ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AnimationTimelineBuilderVisitor.prototype.visitStyle = /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n function (ast, context) {\n var /** @type {?} */ timeline = context.currentTimeline;\n var /** @type {?} */ timings = /** @type {?} */ ((context.currentAnimateTimings));\n // this is a special case for when a style() call\n // directly follows an animate() call (but not inside of an animate() call)\n if (!timings && timeline.getCurrentStyleProperties().length) {\n timeline.forwardFrame();\n }\n var /** @type {?} */ easing = (timings && timings.easing) ||
ast.easing;\n if (ast.isEmptyStep) {\n timeline.applyEmptyStep(easing);\n }\n else {\n timeline.setStyles(ast.styles, easing, context.errors, context.options);\n }\n context.previousNode = ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AnimationTimelineBuilderVisitor.prototype.visitKeyframes = /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n function (ast, context) {\n var /** @type {?} */ currentAnimateTimings = /** @type {?} */ ((context.currentAnimateTimings));\n var /** @type {?} */ startTime = (/** @type {?} */ ((context.currentTimeline))).duration;\n var /** @type {?} */ duration = currentAnimateTimings.duration;\n var /** @type {?} */ innerContext = context.createSubContext();\n var /** @type {?} */ innerTimeline = innerContext.currentTimeline;\n innerTimeline.easing = currentAnimat
eTimings.easing;\n ast.styles.forEach(function (step) {\n var /** @type {?} */ offset = step.offset || 0;\n innerTimeline.forwardTime(offset * duration);\n innerTimeline.setStyles(step.styles, step.easing, context.errors, context.options);\n innerTimeline.applyStylesToKeyframe();\n });\n // this will ensure that the parent timeline gets all the styles from\n // the child even if the new timeline below is not used\n context.currentTimeline.mergeTimelineCollectedStyles(innerTimeline);\n // we do this because the window between this timeline and the sub timeline\n // should ensure that the styles within are exactly the same as they were before\n context.transformIntoNewTimeline(startTime + duration);\n context.previousNode = ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AnimationTimelineBuilderVisitor.prototype.visitQuery
= /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n function (ast, context) {\n var _this = this;\n // in the event that the first step before this is a style step we need\n // to ensure the styles are applied before the children are animated\n var /** @type {?} */ startTime = context.currentTimeline.currentTime;\n var /** @type {?} */ options = /** @type {?} */ ((ast.options || {}));\n var /** @type {?} */ delay = options.delay ? resolveTimingValue(options.delay) : 0;\n if (delay && (context.previousNode.type === 6 /* Style */ ||\n (startTime == 0 && context.currentTimeline.getCurrentStyleProperties().length))) {\n context.currentTimeline.snapshotCurrentStyles();\n context.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;\n }\n var /** @type {?} */ furthestTime = startTime;\n var /** @type {?} */ elms = context.invokeQuery(ast.selector, ast.original
Selector, ast.limit, ast.includeSelf, options.optional ? true : false, context.errors);\n context.currentQueryTotal = elms.length;\n var /** @type {?} */ sameElementTimeline = null;\n elms.forEach(function (element, i) {\n context.currentQueryIndex = i;\n var /** @type {?} */ innerContext = context.createSubContext(ast.options, element);\n if (delay) {\n innerContext.delayNextStep(delay);\n }\n if (element === context.element) {\n sameElementTimeline = innerContext.currentTimeline;\n }\n visitDslNode(_this, ast.animation, innerContext);\n // this is here just incase the inner steps only contain or end\n // with a style() call (which is here to signal that this is a preparatory\n // call to style an element before it is animated again)\n innerContext.currentTimeline.applyStylesToKeyframe();\n var /** @ty
pe {?} */ endTime = innerContext.currentTimeline.currentTime;\n furthestTime = Math.max(furthestTime, endTime);\n });\n context.currentQueryIndex = 0;\n context.currentQueryTotal = 0;\n context.transformIntoNewTimeline(furthestTime);\n if (sameElementTimeline) {\n context.currentTimeline.mergeTimelineCollectedStyles(sameElementTimeline);\n context.currentTimeline.snapshotCurrentStyles();\n }\n context.previousNode = ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AnimationTimelineBuilderVisitor.prototype.visitStagger = /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n function (ast, context) {\n var /** @type {?} */ parentContext = /** @type {?} */ ((context.parentContext));\n var /** @type {?} */ tl = context.currentTimeline;\n var /** @type {?} */ timings = ast.timings;\n var /*
* @type {?} */ duration = Math.abs(timings.duration);\n var /** @type {?} */ maxTime = duration * (context.currentQueryTotal - 1);\n var /** @type {?} */ delay = duration * context.currentQueryIndex;\n var /** @type {?} */ staggerTransformer = timings.duration < 0 ? 'reverse' : timings.easing;\n switch (staggerTransformer) {\n case 'reverse':\n delay = maxTime - delay;\n break;\n case 'full':\n delay = parentContext.currentStaggerTime;\n break;\n }\n var /** @type {?} */ timeline = context.currentTimeline;\n if (delay) {\n timeline.delayNextStep(delay);\n }\n var /** @type {?} */ startingTime = timeline.currentTime;\n visitDslNode(this, ast.animation, context);\n context.previousNode = ast;\n // time = duration + delay\n // the reason why this computation is so complex is because\n // the inner
timeline may either have a delay value or a stretched\n // keyframe depending on if a subtimeline is not used or is used.\n parentContext.currentStaggerTime =\n (tl.currentTime - startingTime) + (tl.startTime - parentContext.currentTimeline.startTime);\n };\n return AnimationTimelineBuilderVisitor;\n}());\nexport { AnimationTimelineBuilderVisitor };\nvar /** @type {?} */ DEFAULT_NOOP_PREVIOUS_NODE = /** @type {?} */ ({});\nvar AnimationTimelineContext = /** @class */ (function () {\n function AnimationTimelineContext(_driver, element, subInstructions, _enterClassName, _leaveClassName, errors, timelines, initialTimeline) {\n this._driver = _driver;\n this.element = element;\n this.subInstructions = subInstructions;\n this._enterClassName = _enterClassName;\n this._leaveClassName = _leaveClassName;\n this.errors = errors;\n this.timelines = timelines;\n this.parentContext = null;\n this.cu
rrentAnimateTimings = null;\n this.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;\n this.subContextCount = 0;\n this.options = {};\n this.currentQueryIndex = 0;\n this.currentQueryTotal = 0;\n this.currentStaggerTime = 0;\n this.currentTimeline = initialTimeline || new TimelineBuilder(this._driver, element, 0);\n timelines.push(this.currentTimeline);\n }\n Object.defineProperty(AnimationTimelineContext.prototype, \"params\", {\n get: /**\n * @return {?}\n */\n function () { return this.options.params; },\n enumerable: true,\n configurable: true\n });\n /**\n * @param {?} options\n * @param {?=} skipIfExists\n * @return {?}\n */\n AnimationTimelineContext.prototype.updateOptions = /**\n * @param {?} options\n * @param {?=} skipIfExists\n * @return {?}\n */\n function (options, skipIfExists) {\n var _this = this;\n if (!options
)\n return;\n var /** @type {?} */ newOptions = /** @type {?} */ (options);\n var /** @type {?} */ optionsToUpdate = this.options;\n // NOTE: this will get patched up when other animation methods support duration overrides\n if (newOptions.duration != null) {\n (/** @type {?} */ (optionsToUpdate)).duration = resolveTimingValue(newOptions.duration);\n }\n if (newOptions.delay != null) {\n optionsToUpdate.delay = resolveTimingValue(newOptions.delay);\n }\n var /** @type {?} */ newParams = newOptions.params;\n if (newParams) {\n var /** @type {?} */ paramsToUpdate_1 = /** @type {?} */ ((optionsToUpdate.params));\n if (!paramsToUpdate_1) {\n paramsToUpdate_1 = this.options.params = {};\n }\n Object.keys(newParams).forEach(function (name) {\n if (!skipIfExists || !paramsToUpdate_1.hasOwnProperty(name)) {\n
paramsToUpdate_1[name] = interpolateParams(newParams[name], paramsToUpdate_1, _this.errors);\n }\n });\n }\n };\n /**\n * @return {?}\n */\n AnimationTimelineContext.prototype._copyOptions = /**\n * @return {?}\n */\n function () {\n var /** @type {?} */ options = {};\n if (this.options) {\n var /** @type {?} */ oldParams_1 = this.options.params;\n if (oldParams_1) {\n var /** @type {?} */ params_1 = options['params'] = {};\n Object.keys(oldParams_1).forEach(function (name) { params_1[name] = oldParams_1[name]; });\n }\n }\n return options;\n };\n /**\n * @param {?=} options\n * @param {?=} element\n * @param {?=} newTime\n * @return {?}\n */\n AnimationTimelineContext.prototype.createSubContext = /**\n * @param {?=} options\n * @param {?=} element\n * @param {?=} newTime\n * @return
{?}\n */\n function (options, element, newTime) {\n if (options === void 0) { options = null; }\n var /** @type {?} */ target = element || this.element;\n var /** @type {?} */ context = new AnimationTimelineContext(this._driver, target, this.subInstructions, this._enterClassName, this._leaveClassName, this.errors, this.timelines, this.currentTimeline.fork(target, newTime || 0));\n context.previousNode = this.previousNode;\n context.currentAnimateTimings = this.currentAnimateTimings;\n context.options = this._copyOptions();\n context.updateOptions(options);\n context.currentQueryIndex = this.currentQueryIndex;\n context.currentQueryTotal = this.currentQueryTotal;\n context.parentContext = this;\n this.subContextCount++;\n return context;\n };\n /**\n * @param {?=} newTime\n * @return {?}\n */\n AnimationTimelineContext.prototype.transformIntoNewTimeline = /**\n * @param
{?=} newTime\n * @return {?}\n */\n function (newTime) {\n this.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;\n this.currentTimeline = this.currentTimeline.fork(this.element, newTime);\n this.timelines.push(this.currentTimeline);\n return this.currentTimeline;\n };\n /**\n * @param {?} instruction\n * @param {?} duration\n * @param {?} delay\n * @return {?}\n */\n AnimationTimelineContext.prototype.appendInstructionToTimeline = /**\n * @param {?} instruction\n * @param {?} duration\n * @param {?} delay\n * @return {?}\n */\n function (instruction, duration, delay) {\n var /** @type {?} */ updatedTimings = {\n duration: duration != null ? duration : instruction.duration,\n delay: this.currentTimeline.currentTime + (delay != null ? delay : 0) + instruction.delay,\n easing: ''\n };\n var /** @type {?} */ builder = new SubTimelineBuilder(this._dr
iver, instruction.element, instruction.keyframes, instruction.preStyleProps, instruction.postStyleProps, updatedTimings, instruction.stretchStartingKeyframe);\n this.timelines.push(builder);\n return updatedTimings;\n };\n /**\n * @param {?} time\n * @return {?}\n */\n AnimationTimelineContext.prototype.incrementTime = /**\n * @param {?} time\n * @return {?}\n */\n function (time) {\n this.currentTimeline.forwardTime(this.currentTimeline.duration + time);\n };\n /**\n * @param {?} delay\n * @return {?}\n */\n AnimationTimelineContext.prototype.delayNextStep = /**\n * @param {?} delay\n * @return {?}\n */\n function (delay) {\n // negative delays are not yet supported\n if (delay > 0) {\n this.currentTimeline.delayNextStep(delay);\n }\n };\n /**\n * @param {?} selector\n * @param {?} originalSelector\n * @param {?} limit\n * @param {?} inc
ludeSelf\n * @param {?} optional\n * @param {?} errors\n * @return {?}\n */\n AnimationTimelineContext.prototype.invokeQuery = /**\n * @param {?} selector\n * @param {?} originalSelector\n * @param {?} limit\n * @param {?} includeSelf\n * @param {?} optional\n * @param {?} errors\n * @return {?}\n */\n function (selector, originalSelector, limit, includeSelf, optional, errors) {\n var /** @type {?} */ results = [];\n if (includeSelf) {\n results.push(this.element);\n }\n if (selector.length > 0) {\n // if :self is only used then the selector is empty\n selector = selector.replace(ENTER_TOKEN_REGEX, '.' + this._enterClassName);\n selector = selector.replace(LEAVE_TOKEN_REGEX, '.' + this._leaveClassName);\n var /** @type {?} */ multi = limit != 1;\n var /** @type {?} */ elements = this._driver.query(this.element, selector, multi);\n
if (limit !== 0) {\n elements = limit < 0 ? elements.slice(elements.length + limit, elements.length) :\n elements.slice(0, limit);\n }\n results.push.apply(results, elements);\n }\n if (!optional && results.length == 0) {\n errors.push(\"`query(\\\"\" + originalSelector + \"\\\")` returned zero elements. (Use `query(\\\"\" + originalSelector + \"\\\", { optional: true })` if you wish to allow this.)\");\n }\n return results;\n };\n return AnimationTimelineContext;\n}());\nexport { AnimationTimelineContext };\nfunction AnimationTimelineContext_tsickle_Closure_declarations() {\n /** @type {?} */\n AnimationTimelineContext.prototype.parentContext;\n /** @type {?} */\n AnimationTimelineContext.prototype.currentTimeline;\n /** @type {?} */\n AnimationTimelineContext.prototype.currentAnimateTimings;\n /** @type {?} */\n AnimationTimelineContext.prototype.previo
usNode;\n /** @type {?} */\n AnimationTimelineContext.prototype.subContextCount;\n /** @type {?} */\n AnimationTimelineContext.prototype.options;\n /** @type {?} */\n AnimationTimelineContext.prototype.currentQueryIndex;\n /** @type {?} */\n AnimationTimelineContext.prototype.currentQueryTotal;\n /
<TRUNCATED>