https://www.mfcf.com/js/angular/angular-animate.js?sv=8.6.3.1

38// Otherwise, just use W3C names, browsers not supporting them at all will just ignore them.
39// Note: Chrome implements `window.onwebkitanimationend` and doesn't implement `window.onanimationend`
40// but at the same time dispatches the `animationend` event and not `webkitAnimationEnd`.
41// Register both events in case `window.onanimationend` is not supported because of that,
42// do the same for `transitionend` as Safari is likely to exhibit similar behavior.
43// Also, the only modern browser that uses vendor prefixes for transitions/keyframes is webkit
44// therefore there is no reason to test anymore for other vendor prefixes:
45// http://caniuse.com/#search=transition
46if (isUndefined(window.ontransitionend) && isDefined(window.onwebkittransitionend)) {
47  CSS_PREFIX = '-webkit-';
48  TRANSITION_PROP = 'WebkitTransition';
49  TRANSITIONEND_EVENT = 'webkitTransitionEnd transitionend';
50} else {
51  TRANSITION_PROP = 'transition';
52  TRANSITIONEND_EVENT = 'transitionend';
53}
54
55if (isUndefined(window.onanimationend) && isDefined(window.onwebkitanimationend)) {
56  CSS_PREFIX = '-webkit-';
57  ANIMATION_PROP = 'WebkitAnimation';
58  ANIMATIONEND_EVENT = 'webkitAnimationEnd animationend';
59} else {
60  ANIMATION_PROP = 'animation';
61  ANIMATIONEND_EVENT = 'animationend';
62}
63
64var DURATION_KEY = 'Duration';
65var PROPERTY_KEY = 'Property';
66var DELAY_KEY = 'Delay';
67var TIMING_KEY = 'TimingFunction';
68var ANIMATION_ITERATION_COUNT_KEY = 'IterationCount';
69var ANIMATION_PLAYSTATE_KEY = 'PlayState';
70var SAFE_FAST_FORWARD_DURATION_VALUE = 9999;
71
72var ANIMATION_DELAY_PROP = ANIMATION_PROP + DELAY_KEY;
73var ANIMATION_DURATION_PROP = ANIMATION_PROP + DURATION_KEY;
74var TRANSITION_DELAY_PROP = TRANSITION_PROP + DELAY_KEY;
75var TRANSITION_DURATION_PROP = TRANSITION_PROP + DURATION_KEY;
76
77var isPromiseLike = function(p) {
78  return p && p.then ? true : false;
79};
80
81var ngMinErr = angular.$$minErr('ng');
82function assertArg(arg, name, reason) {
83  if (!arg) {
84    throw ngMinErr('areq', "Argument '{0}' is {1}", (name || '?'), (reason || "required"));
85  }
86  return arg;
87}
88
89function mergeClasses(a,b) {
90  if (!a && !b) return '';
91  if (!a) return b;
92  if (!b) return a;
93  if (isArray(a)) a = a.join(' ');
94  if (isArray(b)) b = b.join(' ');
95  return a + ' ' + b;
96}
97
98function packageStyles(options) {
99  var styles = {};
100  if (options && (options.to || options.from)) {
101    styles.to = options.to;
102    styles.from = options.from;
103  }
104  return styles;
105}
106
107function pendClasses(classes, fix, isPrefix) {
108  var className = '';
109  classes = isArray(classes)
110      ? classes
111      : classes && isString(classes) && classes.length
112          ? classes.split(/\s+/)
113          : [];
114  forEach(classes, function(klass, i) {
115    if (klass && klass.length > 0) {
116      className += (i > 0) ? ' ' : '';
117      className += isPrefix ? fix + klass
118                            : klass + fix;
119    }
120  });
121  return className;
122}
123
124function removeFromArray(arr, val) {
125  var index = arr.indexOf(val);
126  if (val >= 0) {
127    arr.splice(index, 1);
128  }
129}
130
131function stripCommentsFromElement(element) {
132  if (element instanceof jqLite) {
133    switch (element.length) {
134      case 0:
135        return [];
136        break;
137
138      case 1:
139        // there is no point of stripping anything if the element
140        // is the only element within the jqLite wrapper.
141        // (it's important that we retain the element instance.)
142        if (element[0].nodeType === ELEMENT_NODE) {
143          return element;
144        }
145        break;
146
147      default:
148        return jqLite(extractElementNode(element));
149        break;
150    }
151  }
152
153  if (element.nodeType === ELEMENT_NODE) {
154    return jqLite(element);
155  }
156}
157
158function extractElementNode(element) {
159  if (!element[0]) return element;
160  for (var i = 0; i < element.length; i++) {
161    var elm = element[i];
162    if (elm.nodeType == ELEMENT_NODE) {
163      return elm;
164    }
165  }
166}
167
168function $$addClass($$jqLite, element, className) {
169  forEach(element, function(elm) {
170    $$jqLite.addClass(elm, className);
171  });
172}
173
174function $$removeClass($$jqLite, element, className) {
175  forEach(element, function(elm) {
176    $$jqLite.removeClass(elm, className);
177  });
178}
179
180function applyAnimationClassesFactory($$jqLite) {
181  return function(element, options) {
182    if (options.addClass) {
183      $$addClass($$jqLite, element, options.addClass);
184      options.addClass = null;
185    }
186    if (options.removeClass) {
187      $$removeClass($$jqLite, element, options.removeClass);
188      options.removeClass = null;
189    }
190  }
191}
192
193function prepareAnimationOptions(options) {
194  options = options || {};
195  if (!options.$$prepared) {
196    var domOperation = options.domOperation || noop;
197    options.domOperation = function() {
198      options.$$domOperationFired = true;
199      domOperation();
200      domOperation = noop;
201    };
202    options.$$prepared = true;
203  }
204  return options;
205}
206
207function applyAnimationStyles(element, options) {
208  applyAnimationFromStyles(element, options);
209  applyAnimationToStyles(element, options);
210}
211
212function applyAnimationFromStyles(element, options) {
213  if (options.from) {
214    element.css(options.from);
215    options.from = null;
216  }
217}
218
219function applyAnimationToStyles(element, options) {
220  if (options.to) {
221    element.css(options.to);
222    options.to = null;
223  }
224}
225
226function mergeAnimationOptions(element, target, newOptions) {
227  var toAdd = (target.addClass || '') + ' ' + (newOptions.addClass || '');
228  var toRemove = (target.removeClass || '') + ' ' + (newOptions.removeClass || '');
229  var classes = resolveElementClasses(element.attr('class'), toAdd, toRemove);
230
231  if (newOptions.preparationClasses) {
232    target.preparationClasses = concatWithSpace(newOptions.preparationClasses, target.preparationClasses);
233    delete newOptions.preparationClasses;
234  }
235
236  // noop is basically when there is no callback; otherwise something has been set
237  var realDomOperation = target.domOperation !== noop ? target.domOperation : null;
238
239  extend(target, newOptions);
240
241  // TODO(matsko or sreeramu): proper fix is to maintain all animation callback in array and call at last,but now only leave has the callback so no issue with this.
242  if (realDomOperation) {
243    target.domOperation = realDomOperation;
244  }
245
246  if (classes.addClass) {
247    target.addClass = classes.addClass;
248  } else {
249    target.addClass = null;
250  }
251
252  if (classes.removeClass) {
253    target.removeClass = classes.removeClass;
254  } else {
255    target.removeClass = null;
256  }
257
258  return target;
259}
260
261function resolveElementClasses(existing, toAdd, toRemove) {
262  var ADD_CLASS = 1;
263  var REMOVE_CLASS = -1;
264
265  var flags = {};
266  existing = splitClassesToLookup(existing);
267
268  toAdd = splitClassesToLookup(toAdd);
269  forEach(toAdd, function(value, key) {
270    flags[key] = ADD_CLASS;
271  });
272
273  toRemove = splitClassesToLookup(toRemove);
274  forEach(toRemove, function(value, key) {
275    flags[key] = flags[key] === ADD_CLASS ? null : REMOVE_CLASS;
276  });
277
278  var classes = {
279    addClass: '',
280    removeClass: ''
281  };
282
283  forEach(flags, function(val, klass) {
284    var prop, allow;
285    if (val === ADD_CLASS) {
286      prop = 'addClass';
287      allow = !existing[klass];
288    } else if (val === REMOVE_CLASS) {
289      prop = 'removeClass';
290      allow = existing[klass];
291    }
292    if (allow) {
293      if (classes[prop].length) {
294        classes[prop] += ' ';
295      }
296      classes[prop] += klass;
297    }
298  });
299
300  function splitClassesToLookup(classes) {
301    if (isString(classes)) {
302      classes = classes.split(' ');
303    }
304
305    var obj = {};
306    forEach(classes, function(klass) {
307      // sometimes the split leaves empty string values
308      // incase extra spaces were applied to the options
309      if (klass.length) {
310        obj[klass] = true;
311      }
312    });
313    return obj;
314  }
315
316  return classes;
317}
318
319function getDomNode(element) {
320  return (element instanceof angular.element) ? element[0] : element;
321}
322
323function applyGeneratedPreparationClasses(element, event, options) {
324  var classes = '';
325  if (event) {
326    classes = pendClasses(event, EVENT_CLASS_PREFIX, true);
327  }
328  if (options.addClass) {
329    classes = concatWithSpace(classes, pendClasses(options.addClass, ADD_CLASS_SUFFIX));
330  }
331  if (options.removeClass) {
332    classes = concatWithSpace(classes, pendClasses(options.removeClass, REMOVE_CLASS_SUFFIX));
333  }
334  if (classes.length) {
335    options.preparationClasses = classes;
336    element.addClass(classes);
337  }
338}
339
340function clearGeneratedClasses(element, options) {
341  if (options.preparationClasses) {
342    element.removeClass(options.preparationClasses);
343    options.preparationClasses = null;
344  }
345  if (options.activeClasses) {
346    element.removeClass(options.activeClasses);
347    options.activeClasses = null;
348  }
349}
350
351function blockTransitions(node, duration) {
352  // we use a negative delay value since it performs blocking
353  // yet it doesn't kill any existing transitions running on the
354  // same element which makes this safe for class-based animations
355  var value = duration ? '-' + duration + 's' : '';
356  applyInlineStyle(node, [TRANSITION_DELAY_PROP, value]);
357  return [TRANSITION_DELAY_PROP, value];
358}
359
360function blockKeyframeAnimations(node, applyBlock) {
361  var value = applyBlock ? 'paused' : '';
362  var key = ANIMATION_PROP + ANIMATION_PLAYSTATE_KEY;
363  applyInlineStyle(node, [key, value]);
364  return [key, value];
365}
366
367function applyInlineStyle(node, styleTuple) {
368  var prop = styleTuple[0];
369  var value = styleTuple[1];
370  node.style[prop] = value;
371}
372
373function concatWithSpace(a,b) {
374  if (!a) return b;
375  if (!b) return a;
376  return a + ' ' + b;
377}
378
379var $$rAFSchedulerFactory = ['$$rAF', function($$rAF) {
380  var queue, cancelFn;
381
382  function scheduler(tasks) {
383    // we make a copy since RAFScheduler mutates the state
384    // of the passed in array variable and this would be difficult
385    // to track down on the outside code
386    queue = queue.concat(tasks);
387    nextTick();
388  }
389
390  queue = scheduler.queue = [];
391
392  /* waitUntilQuiet does two things:
393   * 1. It will run the FINAL `fn` value only when an uncanceled RAF has passed through
394   * 2. It will delay the next wave of tasks from running until the quiet `fn` has run.
395   *
396   * The motivation here is that animation code can request more time from the scheduler
397   * before the next wave runs. This allows for certain DOM properties such as classes to
398   * be resolved in time for the next animation to run.
399   */
400  scheduler.waitUntilQuiet = function(fn) {
401    if (cancelFn) cancelFn();
402
403    cancelFn = $$rAF(function() {
404      cancelFn = null;
405      fn();
406      nextTick();
407    });
408  };
409
410  return scheduler;
411
412  function nextTick() {
413    if (!queue.length) return;
414
415    var items = queue.shift();
416    for (var i = 0; i < items.length; i++) {
417      items[i]();
418    }
419
420    if (!cancelFn) {
421      $$rAF(function() {
422        if (!cancelFn) nextTick();
423      });
424    }
425  }
426}];
427
428var $$AnimateChildrenDirective = [function() {
429  return function(scope, element, attrs) {
430    var val = attrs.ngAnimateChildren;
431    if (angular.isString(val) && val.length === 0) { //empty attribute
432      element.data(NG_ANIMATE_CHILDREN_DATA, true);
433    } else {
434      attrs.$observe('ngAnimateChildren', function(value) {
435        value = value === 'on' || value === 'true';
436        element.data(NG_ANIMATE_CHILDREN_DATA, value);
437      });
438    }
439  };
440}];
441
442var ANIMATE_TIMER_KEY = '$$animateCss';
443
444/**
445 * @ngdoc service
446 * @name $animateCss
447 * @kind object
448 *
449 * @description
450 * The `$animateCss` service is a useful utility to trigger customized CSS-based transitions/keyframes
451 * from a JavaScript-based animation or directly from a directive. The purpose of `$animateCss` is NOT
452 * to side-step how `$animate` and ngAnimate work, but the goal is to allow pre-existing animations or
453 * directives to create more complex animations that can be purely driven using CSS code.
454 *
455 * Note that only browsers that support CSS transitions and/or keyframe animations are capable of
456 * rendering animations triggered via `$animateCss` (bad news for IE9 and lower).
457 *
458 * ## Usage
459 * Once again, `$animateCss` is designed to be used inside of a registered JavaScript animation that
460 * is powered by ngAnimate. It is possible to use `$animateCss` directly inside of a directive, however,
461 * any automatic control over cancelling animations and/or preventing animations from being run on
462 * child elements will not be handled by Angular. For this to work as expected, please use `$animate` to
463 * trigger the animation and then setup a JavaScript animation that injects `$animateCss` to trigger
464 * the CSS animation.
465 *

869        }
870        rafWaitQueue.length = 0;
871      });
872    }
873
874    function computeTimings(node, className, cacheKey) {
875      var timings = computeCachedCssStyles(node, className, cacheKey, DETECT_CSS_PROPERTIES);
876      var aD = timings.animationDelay;
877      var tD = timings.transitionDelay;
878      timings.maxDelay = aD && tD
879          ? Math.max(aD, tD)
880          : (aD || tD);
881      timings.maxDuration = Math.max(
882          timings.animationDuration * timings.animationIterationCount,
883          timings.transitionDuration);
884
885      return timings;
886    }
887
888    return function init(element, initialOptions) {
889      // all of the animation functions should create
890      // a copy of the options data, however, if a
891      // parent service has already created a copy then
892      // we should stick to using that
893      var options = initialOptions || {};
894      if (!options.$$prepared) {
895        options = prepareAnimationOptions(copy(options));
896      }
897
898      var restoreStyles = {};
899      var node = getDomNode(element);
900      if (!node
901          || !node.parentNode
902          || !$$animateQueue.enabled()) {
903        return closeAndReturnNoopAnimator();
904      }
905
906      var temporaryStyles = [];
907      var classes = element.attr('class');
908      var styles = packageStyles(options);
909      var animationClosed;
910      var animationPaused;
911      var animationCompleted;
912      var runner;
913      var runnerHost;
914      var maxDelay;
915      var maxDelayTime;
916      var maxDuration;
917      var maxDurationTime;
918      var startTime;
919      var events = [];
920
921      if (options.duration === 0 || (!$sniffer.animations && !$sniffer.transitions)) {
922        return closeAndReturnNoopAnimator();
923      }
924
925      var method = options.event && isArray(options.event)
926            ? options.event.join(' ')
927            : options.event;
928
929      var isStructural = method && options.structural;
930      var structuralClassName = '';
931      var addRemoveClassName = '';
932
933      if (isStructural) {
934        structuralClassName = pendClasses(method, EVENT_CLASS_PREFIX, true);
935      } else if (method) {
936        structuralClassName = method;
937      }
938
939      if (options.addClass) {
940        addRemoveClassName += pendClasses(options.addClass, ADD_CLASS_SUFFIX);
941      }
942
943      if (options.removeClass) {
944        if (addRemoveClassName.length) {
945          addRemoveClassName += ' ';
946        }
947        addRemoveClassName += pendClasses(options.removeClass, REMOVE_CLASS_SUFFIX);
948      }
949
950      // there may be a situation where a structural animation is combined together
951      // with CSS classes that need to resolve before the animation is computed.
952      // However this means that there is no explicit CSS code to block the animation
953      // from happening (by setting 0s none in the class name). If this is the case
954      // we need to apply the classes before the first rAF so we know to continue if
955      // there actually is a detected transition or keyframe animation
956      if (options.applyClassesEarly && addRemoveClassName.length) {
957        applyAnimationClasses(element, options);
958      }
959
960      var preparationClasses = [structuralClassName, addRemoveClassName].join(' ').trim();
961      var fullClassName = classes + ' ' + preparationClasses;
962      var activeClasses = pendClasses(preparationClasses, ACTIVE_CLASS_SUFFIX);
963      var hasToStyles = styles.to && Object.keys(styles.to).length > 0;
964      var containsKeyframeAnimation = (options.keyframeStyle || '').length > 0;
965
966      // there is no way we can trigger an animation if no styles and
967      // no classes are being applied which would then trigger a transition,
968      // unless there a is raw keyframe value that is applied to the element.
969      if (!containsKeyframeAnimation
970           && !hasToStyles
971           && !preparationClasses) {
972        return closeAndReturnNoopAnimator();
973      }
974
975      var cacheKey, stagger;
976      if (options.stagger > 0) {
977        var staggerVal = parseFloat(options.stagger);
978        stagger = {
979          transitionDelay: staggerVal,
980          animationDelay: staggerVal,
981          transitionDuration: 0,
982          animationDuration: 0
983        };
984      } else {
985        cacheKey = gcsHashFn(node, fullClassName);
986        stagger = computeCachedCssStaggerStyles(node, preparationClasses, cacheKey, DETECT_STAGGER_CSS_PROPERTIES);
987      }
988
989      if (!options.$$skipPreparationClasses) {
990        $$jqLite.addClass(element, preparationClasses);
991      }
992
993      var applyOnlyDuration;
994
995      if (options.transitionStyle) {
996        var transitionStyle = [TRANSITION_PROP, options.transitionStyle];
997        applyInlineStyle(node, transitionStyle);
998        temporaryStyles.push(transitionStyle);
999      }
1000
1001      if (options.duration >= 0) {
1002        applyOnlyDuration = node.style[TRANSITION_PROP].length > 0;
1003        var durationStyle = getCssTransitionDurationStyle(options.duration, applyOnlyDuration);
1004
1005        // we set the duration so that it will be picked up by getComputedStyle later
1006        applyInlineStyle(node, durationStyle);
1007        temporaryStyles.push(durationStyle);
1008      }
1009
1010      if (options.keyframeStyle) {
1011        var keyframeStyle = [ANIMATION_PROP, options.keyframeStyle];
1012        applyInlineStyle(node, keyframeStyle);
1013        temporaryStyles.push(keyframeStyle);
1014      }
1015
1016      var itemIndex = stagger
1017          ? options.staggerIndex >= 0
1018              ? options.staggerIndex
1019              : gcsLookup.count(cacheKey)
1020          : 0;
1021
1022      var isFirst = itemIndex === 0;
1023
1024      // this is a pre-emptive way of forcing the setup classes to be added and applied INSTANTLY
1025      // without causing any combination of transitions to kick in. By adding a negative delay value
1026      // it forces the setup class' transition to end immediately. We later then remove the negative
1027      // transition delay to allow for the transition to naturally do it's thing. The beauty here is
1028      // that if there is no transition defined then nothing will happen and this will also allow
1029      // other transitions to be stacked on top of each other without any chopping them out.
1030      if (isFirst && !options.skipBlocking) {
1031        blockTransitions(node, SAFE_FAST_FORWARD_DURATION_VALUE);
1032      }
1033
1034      var timings = computeTimings(node, fullClassName, cacheKey);
1035      var relativeDelay = timings.maxDelay;
1036      maxDelay = Math.max(relativeDelay, 0);
1037      maxDuration = timings.maxDuration;
1038
1039      var flags = {};
1040      flags.hasTransitions          = timings.transitionDuration > 0;
1041      flags.hasAnimations           = timings.animationDuration > 0;
1042      flags.hasTransitionAll        = flags.hasTransitions && timings.transitionProperty == 'all';
1043      flags.applyTransitionDuration = hasToStyles && (
1044                                        (flags.hasTransitions && !flags.hasTransitionAll)
1045                                         || (flags.hasAnimations && !flags.hasTransitions));
1046      flags.applyAnimationDuration  = options.duration && flags.hasAnimations;
1047      flags.applyTransitionDelay    = truthyTimingValue(options.delay) && (flags.applyTransitionDuration || flags.hasTransitions);
1048      flags.applyAnimationDelay     = truthyTimingValue(options.delay) && flags.hasAnimations;
1049      flags.recalculateTimingStyles = addRemoveClassName.length > 0;
1050
1051      if (flags.applyTransitionDuration || flags.applyAnimationDuration) {
1052        maxDuration = options.duration ? parseFloat(options.duration) : maxDuration;
1053
1054        if (flags.applyTransitionDuration) {
1055          flags.hasTransitions = true;
1056          timings.transitionDuration = maxDuration;
1057          applyOnlyDuration = node.style[TRANSITION_PROP + PROPERTY_KEY].length > 0;
1058          temporaryStyles.push(getCssTransitionDurationStyle(maxDuration, applyOnlyDuration));
1059        }
1060
1061        if (flags.applyAnimationDuration) {
1062          flags.hasAnimations = true;
1063          timings.animationDuration = maxDuration;
1064          temporaryStyles.push(getCssKeyframeDurationStyle(maxDuration));
1065        }
1066      }
1067
1068      if (maxDuration === 0 && !flags.recalculateTimingStyles) {
1069        return closeAndReturnNoopAnimator();
1070      }
1071
1072      if (options.delay != null) {
1073        var delayStyle;
1074        if (typeof options.delay !== "boolean") {
1075          delayStyle = parseFloat(options.delay);
1076          // number in options.delay means we have to recalculate the delay for the closing timeout
1077          maxDelay = Math.max(delayStyle, 0);
1078        }
1079
1080        if (flags.applyTransitionDelay) {
1081          temporaryStyles.push(getCssDelayStyle(delayStyle));
1082        }
1083
1084        if (flags.applyAnimationDelay) {
1085          temporaryStyles.push(getCssDelayStyle(delayStyle, true));
1086        }
1087      }
1088
1089      // we need to recalculate the delay value since we used a pre-emptive negative
1090      // delay value and the delay value is required for the final event checking. This
1091      // property will ensure that this will happen after the RAF phase has passed.
1092      if (options.duration == null && timings.transitionDuration > 0) {
1093        flags.recalculateTimingStyles = flags.recalculateTimingStyles || isFirst;
1094      }
1095
1096      maxDelayTime = maxDelay * ONE_SECOND;
1097      maxDurationTime = maxDuration * ONE_SECOND;
1098      if (!options.skipBlocking) {
1099        flags.blockTransition = timings.transitionDuration > 0;
1100        flags.blockKeyframeAnimation = timings.animationDuration > 0 &&
1101                                       stagger.animationDelay > 0 &&
1102                                       stagger.animationDuration === 0;
1103      }
1104
1105      if (options.from) {
1106        if (options.cleanupStyles) {
1107          registerRestorableStyles(restoreStyles, node, Object.keys(options.from));
1108        }
1109        applyAnimationFromStyles(element, options);
1110      }
1111
1112      if (flags.blockTransition || flags.blockKeyframeAnimation) {
1113        applyBlocking(maxDuration);
1114      } else if (!options.skipBlocking) {
1115        blockTransitions(node, false);
1116      }
1117
1118      // TODO(matsko): for 1.5 change this code to have an animator object for better debugging
1119      return {
1120        $$willAnimate: true,
1121        end: endFn,
1122        start: function() {
1123          if (animationClosed) return;
1124
1125          runnerHost = {
1126            end: endFn,
1127            cancel: cancelFn,
1128            resume: null, //this will be set during the start() phase
1129            pause: null
1130          };
1131
1132          runner = new $$AnimateRunner(runnerHost);
1133
1134          waitUntilQuiet(start);
1135
1136          // we don't have access to pause/resume the animation
1137          // since it hasn't run yet. AnimateRunner will therefore
1138          // set noop functions for resume and pause and they will
1139          // later be overridden once the animation is triggered
1140          return runner;
1141        }
1142      };
1143
1144      function endFn() {
1145        close();
1146      }
1147
1148      function cancelFn() {
1149        close(true);
1150      }
1151
1152      function close(rejected) { // jshint ignore:line
1153        // if the promise has been called already then we shouldn't close
1154        // the animation again
1155        if (animationClosed || (animationCompleted && animationPaused)) return;
1156        animationClosed = true;
1157        animationPaused = false;
1158
1159        if (!options.$$skipPreparationClasses) {
1160          $$jqLite.removeClass(element, preparationClasses);
1161        }
1162        $$jqLite.removeClass(element, activeClasses);
1163
1164        blockKeyframeAnimations(node, false);
1165        blockTransitions(node, false);
1166
1167        forEach(temporaryStyles, function(entry) {
1168          // There is only one way to remove inline style properties entirely from elements.
1169          // By using `removeProperty` this works, but we need to convert camel-cased CSS
1170          // styles down to hyphenated values.
1171          node.style[entry[0]] = '';
1172        });
1173
1174        applyAnimationClasses(element, options);
1175        applyAnimationStyles(element, options);
1176
1177        if (Object.keys(restoreStyles).length) {
1178          forEach(restoreStyles, function(value, prop) {
1179            value ? node.style.setProperty(prop, value)
1180                  : node.style.removeProperty(prop);
1181          });
1182        }
1183
1184        // the reason why we have this option is to allow a synchronous closing callback
1185        // that is fired as SOON as the animation ends (when the CSS is removed) or if
1186        // the animation never takes off at all. A good example is a leave animation since
1187        // the element must be removed just after the animation is over or else the element
1188        // will appear on screen for one animation frame causing an overbearing flicker.
1189        if (options.onDone) {
1190          options.onDone();
1191        }
1192
1193        if (events && events.length) {
1194          // Remove the transitionend / animationend listener(s)
1195          element.off(events.join(' '), onAnimationProgress);
1196        }
1197
1198        // if the preparation function fails then the promise is not setup
1199        if (runner) {
1200          runner.complete(!rejected);
1201        }
1202      }
1203
1204      function applyBlocking(duration) {
1205        if (flags.blockTransition) {
1206          blockTransitions(node, duration);
1207        }
1208
1209        if (flags.blockKeyframeAnimation) {
1210          blockKeyframeAnimations(node, !!duration);
1211        }
1212      }
1213
1214      function closeAndReturnNoopAnimator() {
1215        runner = new $$AnimateRunner({
1216          end: endFn,
1217          cancel: cancelFn
1218        });
1219
1220        // should flush the cache animation
1221        waitUntilQuiet(noop);
1222        close();
1223
1224        return {
1225          $$willAnimate: false,
1226          start: function() {
1227            return runner;
1228          },
1229          end: endFn
1230        };
1231      }
1232
1233      function onAnimationProgress(event) {
1234        event.stopPropagation();
1235        var ev = event.originalEvent || event;
1236
1237        // we now always use `Date.now()` due to the recent changes with
1238        // event.timeStamp in Firefox, Webkit and Chrome (see #13494 for more info)
1239        var timeStamp = ev.$manualTimeStamp || Date.now();
1240
1241        /* Firefox (or possibly just Gecko) likes to not round values up
1242         * when a ms measurement is used for the animation */
1243        var elapsedTime = parseFloat(ev.elapsedTime.toFixed(ELAPSED_TIME_MAX_DECIMAL_PLACES));
1244
1245        /* $manualTimeStamp is a mocked timeStamp value which is set
1246         * within browserTrigger(). This is only here so that tests can
1247         * mock animations properly. Real events fallback to event.timeStamp,
1248         * or, if they don't, then a timeStamp is automatically created for them.
1249         * We're checking to see if the timeStamp surpasses the expected delay,
1250         * but we're using elapsedTime instead of the timeStamp on the 2nd
1251         * pre-condition since animationPauseds sometimes close off early */
1252        if (Math.max(timeStamp - startTime, 0) >= maxDelayTime && elapsedTime >= maxDuration) {
1253          // we set this flag to ensure that if the transition is paused then, when resumed,
1254          // the animation will automatically close itself since transitions cannot be paused.
1255          animationCompleted = true;
1256          close();
1257        }
1258      }
1259
1260      function start() {
1261        if (animationClosed) return;
1262        if (!node.parentNode) {
1263          close();
1264          return;
1265        }
1266
1267        // even though we only pause keyframe animations here the pause flag
1268        // will still happen when transitions are used. Only the transition will
1269        // not be paused since that is not possible. If the animation ends when
1270        // paused then it will not complete until unpaused or cancelled.
1271        var playPause = function(playAnimation) {
1272          if (!animationCompleted) {
1273            animationPaused = !playAnimation;
1274            if (timings.animationDuration) {
1275              var value = blockKeyframeAnimations(node, animationPaused);
1276              animationPaused
1277                  ? temporaryStyles.push(value)
1278                  : removeFromArray(temporaryStyles, value);
1279            }
1280          } else if (animationPaused && playAnimation) {
1281            animationPaused = false;
1282            close();
1283          }
1284        };
1285
1286        // checking the stagger duration prevents an accidentally cascade of the CSS delay style
1287        // being inherited from the parent. If the transition duration is zero then we can safely
1288        // rely that the delay value is an intentional stagger delay style.
1289        var maxStagger = itemIndex > 0
1290                         && ((timings.transitionDuration && stagger.transitionDuration === 0) ||
1291                            (timings.animationDuration && stagger.animationDuration === 0))
1292                         && Math.max(stagger.animationDelay, stagger.transitionDelay);
1293        if (maxStagger) {
1294          $timeout(triggerAnimationStart,
1295                   Math.floor(maxStagger * itemIndex * ONE_SECOND),
1296                   false);
1297        } else {
1298          triggerAnimationStart();
1299        }
1300
1301        // this will decorate the existing promise runner with pause/resume methods
1302        runnerHost.resume = function() {
1303          playPause(true);
1304        };
1305
1306        runnerHost.pause = function() {
1307          playPause(false);
1308        };
1309
1310        function triggerAnimationStart() {
1311          // just incase a stagger animation kicks in when the animation
1312          // itself was cancelled entirely
1313          if (animationClosed) return;
1314
1315          applyBlocking(false);
1316
1317          forEach(temporaryStyles, function(entry) {
1318            var key = entry[0];
1319            var value = entry[1];
1320            node.style[key] = value;
1321          });
1322
1323          applyAnimationClasses(element, options);
1324          $$jqLite.addClass(element, activeClasses);
1325
1326          if (flags.recalculateTimingStyles) {
1327            fullClassName = node.className + ' ' + preparationClasses;
1328            cacheKey = gcsHashFn(node, fullClassName);
1329
1330            timings = computeTimings(node, fullClassName, cacheKey);
1331            relativeDelay = timings.maxDelay;
1332            maxDelay = Math.max(relativeDelay, 0);
1333            maxDuration = timings.maxDuration;
1334
1335            if (maxDuration === 0) {
1336              close();
1337              return;
1338            }
1339
1340            flags.hasTransitions = timings.transitionDuration > 0;
1341            flags.hasAnimations = timings.animationDuration > 0;
1342          }
1343
1344          if (flags.applyAnimationDelay) {
1345            relativeDelay = typeof options.delay !== "boolean" && truthyTimingValue(options.delay)
1346                  ? parseFloat(options.delay)
1347                  : relativeDelay;
1348
1349            maxDelay = Math.max(relativeDelay, 0);
1350            timings.animationDelay = relativeDelay;
1351            delayStyle = getCssDelayStyle(relativeDelay, true);
1352            temporaryStyles.push(delayStyle);
1353            node.style[delayStyle[0]] = delayStyle[1];
1354          }
1355
1356          maxDelayTime = maxDelay * ONE_SECOND;
1357          maxDurationTime = maxDuration * ONE_SECOND;
1358
1359          if (options.easing) {
1360            var easeProp, easeVal = options.easing;
1361            if (flags.hasTransitions) {
1362              easeProp = TRANSITION_PROP + TIMING_KEY;
1363              temporaryStyles.push([easeProp, easeVal]);
1364              node.style[easeProp] = easeVal;
1365            }
1366            if (flags.hasAnimations) {
1367              easeProp = ANIMATION_PROP + TIMING_KEY;
1368              temporaryStyles.push([easeProp, easeVal]);
1369              node.style[easeProp] = easeVal;
1370            }
1371          }
1372
1373          if (timings.transitionDuration) {
1374            events.push(TRANSITIONEND_EVENT);
1375          }
1376
1377          if (timings.animationDuration) {
1378            events.push(ANIMATIONEND_EVENT);
1379          }
1380
1381          startTime = Date.now();
1382          var timerTime = maxDelayTime + CLOSING_TIME_BUFFER * maxDurationTime;
1383          var endTime = startTime + timerTime;
1384
1385          var animationsData = element.data(ANIMATE_TIMER_KEY) || [];
1386          var setupFallbackTimer = true;
1387          if (animationsData.length) {
1388            var currentTimerData = animationsData[0];
1389            setupFallbackTimer = endTime > currentTimerData.expectedEndTime;
1390            if (setupFallbackTimer) {
1391              $timeout.cancel(currentTimerData.timer);
1392            } else {
1393              animationsData.push(close);
1394            }
1395          }
1396
1397          if (setupFallbackTimer) {
1398            var timer = $timeout(onAnimationExpired, timerTime, false);
1399            animationsData[0] = {
1400              timer: timer,
1401              expectedEndTime: endTime
1402            };
1403            animationsData.push(close);
1404            element.data(ANIMATE_TIMER_KEY, animationsData);
1405          }
1406
1407          if (events.length) {
1408            element.on(events.join(' '), onAnimationProgress);
1409          }
1410
1411          if (options.to) {
1412            if (options.cleanupStyles) {
1413              registerRestorableStyles(restoreStyles, node, Object.keys(options.to));
1414            }
1415            applyAnimationToStyles(element, options);
1416          }
1417        }
1418
1419        function onAnimationExpired() {
1420          var animationsData = element.data(ANIMATE_TIMER_KEY);
1421
1422          // this will be false in the event that the element was
1423          // removed from the DOM (via a leave animation or something
1424          // similar)
1425          if (animationsData) {
1426            for (var i = 1; i < animationsData.length; i++) {
1427              animationsData[i]();
1428            }
1429            element.removeData(ANIMATE_TIMER_KEY);
1430          }
1431        }
1432      }
1433    };
1434  }];
1435}];
1436
1437var $$AnimateCssDriverProvider = ['$$animationProvider', function($$animationProvider) {
1438  $$animationProvider.drivers.push('$$animateCssDriver');
1439
1440  var NG_ANIMATE_SHIM_CLASS_NAME = 'ng-animate-shim';
1441  var NG_ANIMATE_ANCHOR_CLASS_NAME = 'ng-anchor';
1442
1443  var NG_OUT_ANCHOR_CLASS_NAME = 'ng-anchor-out';
1444  var NG_IN_ANCHOR_CLASS_NAME = 'ng-anchor-in';
1445
1446  function isDocumentFragment(node) {
1447    return node.parentNode && node.parentNode.nodeType === 11;
1448  }
1449
1450  this.$get = ['$animateCss', '$rootScope', '$$AnimateRunner', '$rootElement', '$sniffer', '$$jqLite', '$document',
1451       function($animateCss,   $rootScope,   $$AnimateRunner,   $rootElement,   $sniffer,   $$jqLite,   $document) {
1452
1453    // only browsers that support these properties can render animations
1454    if (!$sniffer.animations && !$sniffer.transitions) return noop;
1455
1456    var bodyNode = $document[0].body;
1457    var rootNode = getDomNode($rootElement);
1458
1459    var rootBodyElement = jqLite(
1460      // this is to avoid using something that exists outside of the body
1461      // we also special case the doc fragment case because our unit test code
1462      // appends the $rootElement to the body after the app has been bootstrapped
1463      isDocumentFragment(rootNode) || bodyNode.contains(rootNode) ? rootNode : bodyNode
1464    );
1465
1466    var applyAnimationClasses = applyAnimationClassesFactory($$jqLite);
1467
1468    return function initDriverFn(animationDetails) {
1469      return animationDetails.from && animationDetails.to
1470          ? prepareFromToAnchorAnimation(animationDetails.from,
1471                                         animationDetails.to,
1472                                         animationDetails.classes,
1473                                         animationDetails.anchors)
1474          : prepareRegularAnimation(animationDetails);
1475    };
1476
1477    function filterCssClasses(classes) {
1478      //remove all the `ng-` stuff
1479      return classes.replace(/\bng-\S+\b/g, '');
1480    }
1481
1482    function getUniqueValues(a, b) {
1483      if (isString(a)) a = a.split(' ');
1484      if (isString(b)) b = b.split(' ');
1485      return a.filter(function(val) {
1486        return b.indexOf(val) === -1;
1487      }).join(' ');
1488    }
1489
1490    function prepareAnchoredAnimation(classes, outAnchor, inAnchor) {
1491      var clone = jqLite(getDomNode(outAnchor).cloneNode(true));
1492      var startingClasses = filterCssClasses(getClassVal(clone));
1493
1494      outAnchor.addClass(NG_ANIMATE_SHIM_CLASS_NAME);
1495      inAnchor.addClass(NG_ANIMATE_SHIM_CLASS_NAME);
1496
1497      clone.addClass(NG_ANIMATE_ANCHOR_CLASS_NAME);
1498
1499      rootBodyElement.append(clone);
1500
1501      var animatorIn, animatorOut = prepareOutAnimation();
1502
1503      // the user may not end up using the `out` animation and
1504      // only making use of the `in` animation or vice-versa.
1505      // In either case we should allow this and not assume the
1506      // animation is over unless both animations are not used.
1507      if (!animatorOut) {
1508        animatorIn = prepareInAnimation();
1509        if (!animatorIn) {
1510          return end();
1511        }
1512      }
1513
1514      var startingAnimator = animatorOut || animatorIn;
1515
1516      return {
1517        start: function() {
1518          var runner;
1519
1520          var currentAnimation = startingAnimator.start();
1521          currentAnimation.done(function() {
1522            currentAnimation = null;
1523            if (!animatorIn) {
1524              animatorIn = prepareInAnimation();
1525              if (animatorIn) {
1526                currentAnimation = animatorIn.start();
1527                currentAnimation.done(function() {
1528                  currentAnimation = null;
1529                  end();
1530                  runner.complete();
1531                });
1532                return currentAnimation;
1533              }
1534            }
1535            // in the event that there is no `in` animation
1536            end();
1537            runner.complete();
1538          });
1539
1540          runner = new $$AnimateRunner({
1541            end: endFn,
1542            cancel: endFn
1543          });
1544
1545          return runner;
1546
1547          function endFn() {
1548            if (currentAnimation) {
1549              currentAnimation.end();
1550            }
1551          }
1552        }
1553      };
1554
1555      function calculateAnchorStyles(anchor) {
1556        var styles = {};
1557
1558        var coords = getDomNode(anchor).getBoundingClientRect();
1559
1560        // we iterate directly since safari messes up and doesn't return
1561        // all the keys for the coords object when iterated
1562        forEach(['width','height','top','left'], function(key) {
1563          var value = coords[key];
1564          switch (key) {
1565            case 'top':
1566              value += bodyNode.scrollTop;
1567              break;
1568            case 'left':
1569              value += bodyNode.scrollLeft;
1570              break;
1571          }
1572          styles[key] = Math.floor(value) + 'px';
1573        });
1574        return styles;
1575      }
1576
1577      function prepareOutAnimation() {
1578        var animator = $animateCss(clone, {
1579          addClass: NG_OUT_ANCHOR_CLASS_NAME,
1580          delay: true,
1581          from: calculateAnchorStyles(outAnchor)
1582        });
1583
1584        // read the comment within `prepareRegularAnimation` to understand
1585        // why this check is necessary
1586        return animator.$$willAnimate ? animator : null;
1587      }
1588
1589      function getClassVal(element) {
1590        return element.attr('class') || '';
1591      }
1592
1593      function prepareInAnimation() {
1594        var endingClasses = filterCssClasses(getClassVal(inAnchor));
1595        var toAdd = getUniqueValues(endingClasses, startingClasses);
1596        var toRemove = getUniqueValues(startingClasses, endingClasses);
1597
1598        var animator = $animateCss(clone, {
1599          to: calculateAnchorStyles(inAnchor),
1600          addClass: NG_IN_ANCHOR_CLASS_NAME + ' ' + toAdd,
1601          removeClass: NG_OUT_ANCHOR_CLASS_NAME + ' ' + toRemove,
1602          delay: true
1603        });
1604
1605        // read the comment within `prepareRegularAnimation` to understand
1606        // why this check is necessary
1607        return animator.$$willAnimate ? animator : null;
1608      }
1609
1610      function end() {
1611        clone.remove();
1612        outAnchor.removeClass(NG_ANIMATE_SHIM_CLASS_NAME);
1613        inAnchor.removeClass(NG_ANIMATE_SHIM_CLASS_NAME);
1614      }
1615    }
1616
1617    function prepareFromToAnchorAnimation(from, to, classes, anchors) {
1618      var fromAnimation = prepareRegularAnimation(from, noop);
1619      var toAnimation = prepareRegularAnimation(to, noop);
1620
1621      var anchorAnimations = [];
1622      forEach(anchors, function(anchor) {
1623        var outElement = anchor['out'];
1624        var inElement = anchor['in'];
1625        var animator = prepareAnchoredAnimation(classes, outElement, inElement);
1626        if (animator) {
1627          anchorAnimations.push(animator);
1628        }
1629      });
1630
1631      // no point in doing anything when there are no elements to animate
1632      if (!fromAnimation && !toAnimation && anchorAnimations.length === 0) return;
1633
1634      return {
1635        start: function() {
1636          var animationRunners = [];
1637
1638          if (fromAnimation) {
1639            animationRunners.push(fromAnimation.start());
1640          }
1641
1642          if (toAnimation) {
1643            animationRunners.push(toAnimation.start());
1644          }
1645
1646          forEach(anchorAnimations, function(animation) {
1647            animationRunners.push(animation.start());
1648          });
1649
1650          var runner = new $$AnimateRunner({
1651            end: endFn,
1652            cancel: endFn // CSS-driven animations cannot be cancelled, only ended
1653          });
1654
1655          $$AnimateRunner.all(animationRunners, function(status) {
1656            runner.complete(status);
1657          });
1658
1659          return runner;
1660
1661          function endFn() {
1662            forEach(animationRunners, function(runner) {
1663              runner.end();
1664            });
1665          }
1666        }
1667      };
1668    }
1669
1670    function prepareRegularAnimation(animationDetails) {
1671      var element = animationDetails.element;
1672      var options = animationDetails.options || {};
1673
1674      if (animationDetails.structural) {
1675        options.event = animationDetails.event;
1676        options.structural = true;
1677        options.applyClassesEarly = true;
1678
1679        // we special case the leave animation since we want to ensure that
1680        // the element is removed as soon as the animation is over. Otherwise
1681        // a flicker might appear or the element may not be removed at all
1682        if (animationDetails.event === 'leave') {
1683          options.onDone = options.domOperation;
1684        }
1685      }
1686
1687      // We assign the preparationClasses as the actual animation event since
1688      // the internals of $animateCss will just suffix the event token values
1689      // with `-active` to trigger the animation.
1690      if (options.preparationClasses) {
1691        options.event = concatWithSpace(options.event, options.preparationClasses);
1692      }
1693
1694      var animator = $animateCss(element, options);
1695
1696      // the driver lookup code inside of $$animation attempts to spawn a
1697      // driver one by one until a driver returns a.$$willAnimate animator object.
1698      // $animateCss will always return an object, however, it will pass in
1699      // a flag as a hint as to whether an animation was detected or not
1700      return animator.$$willAnimate ? animator : null;
1701    }
1702  }];
1703}];
1704
1705// TODO(matsko): use caching here to speed things up for detection
1706// TODO(matsko): add documentation
1707//  by the time...
1708
1709var $$AnimateJsProvider = ['$animateProvider', function($animateProvider) {
1710  this.$get = ['$injector', '$$AnimateRunner', '$$jqLite',
1711       function($injector,   $$AnimateRunner,   $$jqLite) {
1712
1713    var applyAnimationClasses = applyAnimationClassesFactory($$jqLite);
1714         // $animateJs(element, 'enter');
1715    return function(element, event, classes, options) {
1716      var animationClosed = false;
1717
1718      // the `classes` argument is optional and if it is not used
1719      // then the classes will be resolved from the element's className
1720      // property as well as options.addClass/options.removeClass.
1721      if (arguments.length === 3 && isObject(classes)) {
1722        options = classes;
1723        classes = null;
1724      }
1725
1726      options = prepareAnimationOptions(options);
1727      if (!classes) {
1728        classes = element.attr('class') || '';
1729        if (options.addClass) {
1730          classes += ' ' + options.addClass;
1731        }
1732        if (options.removeClass) {
1733          classes += ' ' + options.removeClass;
1734        }
1735      }
1736
1737      var classesToAdd = options.addClass;
1738      var classesToRemove = options.removeClass;
1739
1740      // the lookupAnimations function returns a series of animation objects that are
1741      // matched up with one or more of the CSS classes. These animation objects are
1742      // defined via the module.animation factory function. If nothing is detected then
1743      // we don't return anything which then makes $animation query the next driver.
1744      var animations = lookupAnimations(classes);
1745      var before, after;
1746      if (animations.length) {
1747        var afterFn, beforeFn;
1748        if (event == 'leave') {
1749          beforeFn = 'leave';
1750          afterFn = 'afterLeave'; // TODO(matsko): get rid of this
1751        } else {
1752          beforeFn = 'before' + event.charAt(0).toUpperCase() + event.substr(1);
1753          afterFn = event;
1754        }
1755
1756        if (event !== 'enter' && event !== 'move') {
1757          before = packageAnimations(element, event, options, animations, beforeFn);
1758        }
1759        after  = packageAnimations(element, event, options, animations, afterFn);
1760      }
1761
1762      // no matching animations
1763      if (!before && !after) return;
1764
1765      function applyOptions() {
1766        options.domOperation();
1767        applyAnimationClasses(element, options);
1768      }
1769
1770      function close() {
1771        animationClosed = true;
1772        applyOptions();
1773        applyAnimationStyles(element, options);
1774      }
1775
1776      var runner;
1777
1778      return {
1779        $$willAnimate: true,
1780        end: function() {
1781          if (runner) {
1782            runner.end();
1783          } else {
1784            close();
1785            runner = new $$AnimateRunner();
1786            runner.complete(true);
1787          }
1788          return runner;
1789        },
1790        start: function() {
1791          if (runner) {
1792            return runner;
1793          }
1794
1795          runner = new $$AnimateRunner();
1796          var closeActiveAnimations;
1797          var chain = [];
1798
1799          if (before) {
1800            chain.push(function(fn) {
1801              closeActiveAnimations = before(fn);
1802            });
1803          }
1804
1805          if (chain.length) {
1806            chain.push(function(fn) {
1807              applyOptions();
1808              fn(true);
1809            });
1810          } else {
1811            applyOptions();
1812          }
1813
1814          if (after) {
1815            chain.push(function(fn) {
1816              closeActiveAnimations = after(fn);
1817            });
1818          }
1819
1820          runner.setHost({
1821            end: function() {
1822              endAnimations();
1823            },
1824            cancel: function() {
1825              endAnimations(true);
1826            }
1827          });
1828
1829          $$AnimateRunner.chain(chain, onComplete);
1830          return runner;
1831
1832          function onComplete(success) {
1833            close(success);
1834            runner.complete(success);
1835          }
1836
1837          function endAnimations(cancelled) {
1838            if (!animationClosed) {
1839              (closeActiveAnimations || noop)(cancelled);
1840              onComplete(cancelled);
1841            }
1842          }
1843        }
1844      };
1845
1846      function executeAnimationFn(fn, element, event, options, onDone) {
1847        var args;
1848        switch (event) {
1849          case 'animate':
1850            args = [element, options.from, options.to, onDone];
1851            break;
1852
1853          case 'setClass':
1854            args = [element, classesToAdd, classesToRemove, onDone];
1855            break;
1856
1857          case 'addClass':
1858            args = [element, classesToAdd, onDone];
1859            break;
1860
1861          case 'removeClass':
1862            args = [element, classesToRemove, onDone];
1863            break;
1864
1865          default:
1866            args = [element, onDone];
1867            break;
1868        }
1869
1870        args.push(options);
1871
1872        var value = fn.apply(fn, args);
1873        if (value) {
1874          if (isFunction(value.start)) {
1875            value = value.start();
1876          }
1877
1878          if (value instanceof $$AnimateRunner) {
1879            value.done(onDone);
1880          } else if (isFunction(value)) {
1881            // optional onEnd / onCancel callback
1882            return value;
1883          }
1884        }
1885
1886        return noop;
1887      }
1888
1889      function groupEventedAnimations(element, event, options, animations, fnName) {
1890        var operations = [];
1891        forEach(animations, function(ani) {
1892          var animation = ani[fnName];
1893          if (!animation) return;
1894
1895          // note that all of these animations will run in parallel
1896          operations.push(function() {
1897            var runner;
1898            var endProgressCb;
1899
1900            var resolved = false;
1901            var onAnimationComplete = function(rejected) {
1902              if (!resolved) {
1903                resolved = true;
1904                (endProgressCb || noop)(rejected);
1905                runner.complete(!rejected);
1906              }
1907            };
1908
1909            runner = new $$AnimateRunner({
1910              end: function() {
1911                onAnimationComplete();
1912              },
1913              cancel: function() {
1914                onAnimationComplete(true);
1915              }
1916            });
1917
1918            endProgressCb = executeAnimationFn(animation, element, event, options, function(result) {
1919              var cancelled = result === false;
1920              onAnimationComplete(cancelled);
1921            });
1922
1923            return runner;
1924          });
1925        });
1926
1927        return operations;
1928      }
1929
1930      function packageAnimations(element, event, options, animations, fnName) {
1931        var operations = groupEventedAnimations(element, event, options, animations, fnName);
1932        if (operations.length === 0) {
1933          var a,b;
1934          if (fnName === 'beforeSetClass') {
1935            a = groupEventedAnimations(element, 'removeClass', options, animations, 'beforeRemoveClass');
1936            b = groupEventedAnimations(element, 'addClass', options, animations, 'beforeAddClass');
1937          } else if (fnName === 'setClass') {
1938            a = groupEventedAnimations(element, 'removeClass', options, animations, 'removeClass');
1939            b = groupEventedAnimations(element, 'addClass', options, animations, 'addClass');
1940          }
1941
1942          if (a) {
1943            operations = operations.concat(a);
1944          }
1945          if (b) {
1946            operations = operations.concat(b);
1947          }
1948        }
1949
1950        if (operations.length === 0) return;
1951
1952        // TODO(matsko): add documentation
1953        return function startAnimation(callback) {
1954          var runners = [];
1955          if (operations.length) {
1956            forEach(operations, function(animateFn) {
1957              runners.push(animateFn());
1958            });
1959          }
1960
1961          runners.length ? $$AnimateRunner.all(runners, callback) : callback();
1962
1963          return function endFn(reject) {
1964            forEach(runners, function(runner) {
1965              reject ? runner.cancel() : runner.end();
1966            });
1967          };
1968        };
1969      }
1970    };
1971
1972    function lookupAnimations(classes) {
1973      classes = isArray(classes) ? classes : classes.split(' ');
1974      var matches = [], flagMap = {};
1975      for (var i=0; i < classes.length; i++) {
1976        var klass = classes[i],
1977            animationFactory = $animateProvider.$$registeredAnimations[klass];
1978        if (animationFactory && !flagMap[klass]) {
1979          matches.push($injector.get(animationFactory));
1980          flagMap[klass] = true;
1981        }
1982      }
1983      return matches;
1984    }
1985  }];
1986}];
1987
1988var $$AnimateJsDriverProvider = ['$$animationProvider', function($$animationProvider) {
1989  $$animationProvider.drivers.push('$$animateJsDriver');
1990  this.$get = ['$$animateJs', '$$AnimateRunner', function($$animateJs, $$AnimateRunner) {
1991    return function initDriverFn(animationDetails) {
1992      if (animationDetails.from && animationDetails.to) {
1993        var fromAnimation = prepareAnimation(animationDetails.from);
1994        var toAnimation = prepareAnimation(animationDetails.to);
1995        if (!fromAnimation && !toAnimation) return;
1996
1997        return {
1998          start: function() {
1999            var animationRunners = [];
2000
2001            if (fromAnimation) {
2002              animationRunners.push(fromAnimation.start());
2003            }
2004
2005            if (toAnimation) {
2006              animationRunners.push(toAnimation.start());
2007            }
2008
2009            $$AnimateRunner.all(animationRunners, done);
2010
2011            var runner = new $$AnimateRunner({
2012              end: endFnFactory(),
2013              cancel: endFnFactory()
2014            });
2015
2016            return runner;
2017
2018            function endFnFactory() {
2019              return function() {
2020                forEach(animationRunners, function(runner) {
2021                  // at this point we cannot cancel animations for groups just yet. 1.5+
2022                  runner.end();
2023                });
2024              };
2025            }
2026
2027            function done(status) {
2028              runner.complete(status);
2029            }
2030          }
2031        };
2032      } else {
2033        return prepareAnimation(animationDetails);
2034      }
2035    };
2036
2037    function prepareAnimation(animationDetails) {
2038      // TODO(matsko): make sure to check for grouped animations and delegate down to normal animations
2039      var element = animationDetails.element;
2040      var event = animationDetails.event;
2041      var options = animationDetails.options;
2042      var classes = animationDetails.classes;
2043      return $$animateJs(element, event, classes, options);
2044    }
2045  }];
2046}];
2047
2048var NG_ANIMATE_ATTR_NAME = 'data-ng-animate';
2049var NG_ANIMATE_PIN_DATA = '$ngAnimatePin';
2050var $$AnimateQueueProvider = ['$animateProvider', function($animateProvider) {
2051  var PRE_DIGEST_STATE = 1;
2052  var RUNNING_STATE = 2;
2053  var ONE_SPACE = ' ';
2054
2055  var rules = this.rules = {
2056    skip: [],
2057    cancel: [],
2058    join: []
2059  };
2060
2061  function makeTruthyCssClassMap(classString) {
2062    if (!classString) {
2063      return null;
2064    }
2065
2066    var keys = classString.split(ONE_SPACE);
2067    var map = Object.create(null);
2068
2069    forEach(keys, function(key) {
2070      map[key] = true;
2071    });
2072    return map;
2073  }
2074
2075  function hasMatchingClasses(newClassString, currentClassString) {
2076    if (newClassString && currentClassString) {
2077      var currentClassMap = makeTruthyCssClassMap(currentClassString);
2078      return newClassString.split(ONE_SPACE).some(function(className) {
2079        return currentClassMap[className];
2080      });
2081    }
2082  }
2083
2084  function isAllowed(ruleType, element, currentAnimation, previousAnimation) {
2085    return rules[ruleType].some(function(fn) {
2086      return fn(element, currentAnimation, previousAnimation);
2087    });
2088  }
2089
2090  function hasAnimationClasses(options, and) {
2091    options = options || {};
2092    var a = (options.addClass || '').length > 0;
2093    var b = (options.removeClass || '').length > 0;
2094    return and ? a && b : a || b;
2095  }
2096
2097  rules.join.push(function(element, newAnimation, currentAnimation) {
2098    // if the new animation is class-based then we can just tack that on
2099    return !newAnimation.structural && hasAnimationClasses(newAnimation.options);
2100  });
2101
2102  rules.skip.push(function(element, newAnimation, currentAnimation) {
2103    // there is no need to animate anything if no classes are being added and
2104    // there is no structural animation that will be triggered
2105    return !newAnimation.structural && !hasAnimationClasses(newAnimation.options);
2106  });
2107
2108  rules.skip.push(function(element, newAnimation, currentAnimation) {
2109    // why should we trigger a new structural animation if the element will
2110    // be removed from the DOM anyway?
2111    return currentAnimation.event == 'leave' && newAnimation.structural;
2112  });
2113
2114  rules.skip.push(function(element, newAnimation, currentAnimation) {
2115    // if there is an ongoing current animation then don't even bother running the class-based animation
2116    return currentAnimation.structural && currentAnimation.state === RUNNING_STATE && !newAnimation.structural;
2117  });
2118
2119  rules.cancel.push(function(element, newAnimation, currentAnimation) {
2120    // there can never be two structural animations running at the same time
2121    return currentAnimation.structural && newAnimation.structural;
2122  });
2123
2124  rules.cancel.push(function(element, newAnimation, currentAnimation) {
2125    // if the previous animation is already running, but the new animation will
2126    // be triggered, but the new animation is structural
2127    return currentAnimation.state === RUNNING_STATE && newAnimation.structural;
2128  });
2129
2130  rules.cancel.push(function(element, newAnimation, currentAnimation) {
2131
2132
2133    var nA = newAnimation.options.addClass;
2134    var nR = newAnimation.options.removeClass;
2135    var cA = currentAnimation.options.addClass;
2136    var cR = currentAnimation.options.removeClass;
2137
2138    // early detection to save the global CPU shortage :)
2139    if ((isUndefined(nA) && isUndefined(nR)) || (isUndefined(cA) && isUndefined(cR))) {
2140      return false;
2141    }
2142
2143    return (hasMatchingClasses(nA, cR)) || (hasMatchingClasses(nR, cA));
2144  });
2145
2146  this.$get = ['$$rAF', '$rootScope', '$rootElement', '$document', '$$HashMap',
2147               '$$animation', '$$AnimateRunner', '$templateRequest', '$$jqLite', '$$forceReflow',
2148       function($$rAF,   $rootScope,   $rootElement,   $document,   $$HashMap,
2149                $$animation,   $$AnimateRunner,   $templateRequest,   $$jqLite,   $$forceReflow) {
2150
2151    var activeAnimationsLookup = new $$HashMap();
2152    var disabledElementsLookup = new $$HashMap();
2153    var animationsEnabled = null;
2154
2155    function postDigestTaskFactory() {
2156      var postDigestCalled = false;
2157      return function(fn) {
2158        // we only issue a call to postDigest before
2159        // it has first passed. This prevents any callbacks
2160        // from not firing once the animation has completed
2161        // since it will be out of the digest cycle.
2162        if (postDigestCalled) {
2163          fn();
2164        } else {
2165          $rootScope.$$postDigest(function() {
2166            postDigestCalled = true;
2167            fn();
2168          });
2169        }
2170      };
2171    }
2172
2173    // Wait until all directive and route-related templates are downloaded and
2174    // compiled. The $templateRequest.totalPendingRequests variable keeps track of
2175    // all of the remote templates being currently downloaded. If there are no
2176    // templates currently downloading then the watcher will still fire anyway.
2177    var deregisterWatch = $rootScope.$watch(
2178      function() { return $templateRequest.totalPendingRequests === 0; },
2179      function(isEmpty) {
2180        if (!isEmpty) return;
2181        deregisterWatch();
2182
2183        // Now that all templates have been downloaded, $animate will wait until
2184        // the post digest queue is empty before enabling animations. By having two
2185        // calls to $postDigest calls we can ensure that the flag is enabled at the
2186        // very end of the post digest queue. Since all of the animations in $animate
2187        // use $postDigest, it's important that the code below executes at the end.
2188        // This basically means that the page is fully downloaded and compiled before
2189        // any animations are triggered.
2190        $rootScope.$$postDigest(function() {
2191          $rootScope.$$postDigest(function() {
2192            // we check for null directly in the event that the application already called
2193            // .enabled() with whatever arguments that it provided it with
2194            if (animationsEnabled === null) {
2195              animationsEnabled = true;
2196            }
2197          });
2198        });
2199      }
2200    );
2201
2202    var callbackRegistry = {};
2203
2204    // remember that the classNameFilter is set during the provider/config
2205    // stage therefore we can optimize here and setup a helper function
2206    var classNameFilter = $animateProvider.classNameFilter();
2207    var isAnimatableClassName = !classNameFilter
2208              ? function() { return true; }
2209              : function(className) {
2210                return classNameFilter.test(className);
2211              };
2212
2213    var applyAnimationClasses = applyAnimationClassesFactory($$jqLite);
2214
2215    function normalizeAnimationOptions(element, options) {
2216      return mergeAnimationOptions(element, options, {});
2217    }
2218
2219    // IE9-11 has no method "contains" in SVG element and in Node.prototype. Bug #10259.
2220    var contains = Node.prototype.contains || function(arg) {
2221      // jshint bitwise: false
2222      return this === arg || !!(this.compareDocumentPosition(arg) & 16);
2223      // jshint bitwise: true
2224    };
2225
2226    function findCallbacks(parent, element, event) {
2227      var targetNode = getDomNode(element);
2228      var targetParentNode = getDomNode(parent);
2229
2230      var matches = [];
2231      var entries = callbackRegistry[event];
2232      if (entries) {
2233        forEach(entries, function(entry) {
2234          if (contains.call(entry.node, targetNode)) {
2235            matches.push(entry.callback);
2236          } else if (event === 'leave' && contains.call(entry.node, targetParentNode)) {
2237            matches.push(entry.callback);
2238          }
2239        });
2240      }
2241
2242      return matches;
2243    }
2244
2245    return {
2246      on: function(event, container, callback) {
2247        var node = extractElementNode(container);
2248        callbackRegistry[event] = callbackRegistry[event] || [];
2249        callbackRegistry[event].push({
2250          node: node,
2251          callback: callback
2252        });
2253      },
2254
2255      off: function(event, container, callback) {
2256        var entries = callbackRegistry[event];
2257        if (!entries) return;
2258
2259        callbackRegistry[event] = arguments.length === 1
2260            ? null
2261            : filterFromRegistry(entries, container, callback);
2262
2263        function filterFromRegistry(list, matchContainer, matchCallback) {
2264          var containerNode = extractElementNode(matchContainer);
2265          return list.filter(function(entry) {
2266            var isMatch = entry.node === containerNode &&
2267                            (!matchCallback || entry.callback === matchCallback);
2268            return !isMatch;
2269          });
2270        }
2271      },
2272
2273      pin: function(element, parentElement) {
2274        assertArg(isElement(element), 'element', 'not an element');
2275        assertArg(isElement(parentElement), 'parentElement', 'not an element');
2276        element.data(NG_ANIMATE_PIN_DATA, parentElement);
2277      },
2278
2279      push: function(element, event, options, domOperation) {
2280        options = options || {};
2281        options.domOperation = domOperation;
2282        return queueAnimation(element, event, options);
2283      },
2284
2285      // this method has four signatures:
2286      //  () - global getter
2287      //  (bool) - global setter
2288      //  (element) - element getter
2289      //  (element, bool) - element setter<F37>
2290      enabled: function(element, bool) {
2291        var argCount = arguments.length;
2292
2293        if (argCount === 0) {
2294          // () - Global getter
2295          bool = !!animationsEnabled;
2296        } else {
2297          var hasElement = isElement(element);
2298
2299          if (!hasElement) {
2300            // (bool) - Global setter
2301            bool = animationsEnabled = !!element;
2302          } else {
2303            var node = getDomNode(element);
2304            var recordExists = disabledElementsLookup.get(node);
2305
2306            if (argCount === 1) {
2307              // (element) - Element getter
2308              bool = !recordExists;
2309            } else {
2310              // (element, bool) - Element setter
2311              disabledElementsLookup.put(node, !bool);
2312            }
2313          }
2314        }
2315
2316        return bool;
2317      }
2318    };
2319
2320    function queueAnimation(element, event, initialOptions) {
2321      // we always make a copy of the options since
2322      // there should never be any side effects on
2323      // the input data when running `$animateCss`.
2324      var options = copy(initialOptions);
2325
2326      var node, parent;
2327      element = stripCommentsFromElement(element);
2328      if (element) {
2329        node = getDomNode(element);
2330        parent = element.parent();
2331      }
2332
2333      options = prepareAnimationOptions(options);
2334
2335      // we create a fake runner with a working promise.
2336      // These methods will become available after the digest has passed
2337      var runner = new $$AnimateRunner();
2338
2339      // this is used to trigger callbacks in postDigest mode
2340      var runInNextPostDigestOrNow = postDigestTaskFactory();
2341
2342      if (isArray(options.addClass)) {
2343        options.addClass = options.addClass.join(' ');
2344      }
2345
2346      if (options.addClass && !isString(options.addClass)) {
2347        options.addClass = null;
2348      }
2349
2350      if (isArray(options.removeClass)) {
2351        options.removeClass = options.removeClass.join(' ');
2352      }
2353
2354      if (options.removeClass && !isString(options.removeClass)) {
2355        options.removeClass = null;
2356      }
2357
2358      if (options.from && !isObject(options.from)) {
2359        options.from = null;
2360      }
2361
2362      if (options.to && !isObject(options.to)) {
2363        options.to = null;
2364      }
2365
2366      // there are situations where a directive issues an animation for