Otaku-Projects / AngularJS-CRUD-PHP

(function(window, angular, undefined) {'use strict';

/* jshint ignore:start */

var noop        = angular.noop;

var copy        = angular.copy;

var extend      = angular.extend;

var jqLite      = angular.element;

var forEach     = angular.forEach;

var isArray     = angular.isArray;

var isString    = angular.isString;

var isObject    = angular.isObject;

var isUndefined = angular.isUndefined;

var isDefined   = angular.isDefined;

var isFunction  = angular.isFunction;

var isElement   = angular.isElement;

var ELEMENT_NODE = 1;

var ADD_CLASS_SUFFIX = '-add';

var REMOVE_CLASS_SUFFIX = '-remove';

var EVENT_CLASS_PREFIX = 'ng-';

var ACTIVE_CLASS_SUFFIX = '-active';

var PREPARE_CLASS_SUFFIX = '-prepare';

var NG_ANIMATE_CLASSNAME = 'ng-animate';

var NG_ANIMATE_CHILDREN_DATA = '$$ngAnimateChildren';

// Detect proper transitionend/animationend event names.

var CSS_PREFIX = '', TRANSITION_PROP, TRANSITIONEND_EVENT, ANIMATION_PROP, ANIMATIONEND_EVENT;

// If unprefixed events are not supported but webkit-prefixed are, use the latter.

// Otherwise, just use W3C names, browsers not supporting them at all will just ignore them.

// Note: Chrome implements `window.onwebkitanimationend` and doesn't implement `window.onanimationend`

// but at the same time dispatches the `animationend` event and not `webkitAnimationEnd`.

// Register both events in case `window.onanimationend` is not supported because of that,

// do the same for `transitionend` as Safari is likely to exhibit similar behavior.

// Also, the only modern browser that uses vendor prefixes for transitions/keyframes is webkit

// therefore there is no reason to test anymore for other vendor prefixes:

// http://caniuse.com/#search=transition

if (isUndefined(window.ontransitionend) && isDefined(window.onwebkittransitionend)) {

  TRANSITION_PROP = 'WebkitTransition';

  TRANSITIONEND_EVENT = 'webkitTransitionEnd transitionend';

} else {

  TRANSITION_PROP = 'transition';

  TRANSITIONEND_EVENT = 'transitionend';

}

if (isUndefined(window.onanimationend) && isDefined(window.onwebkitanimationend)) {

  CSS_PREFIX = '-webkit-';

  ANIMATION_PROP = 'WebkitAnimation';

  ANIMATIONEND_EVENT = 'webkitAnimationEnd animationend';

} else {

  ANIMATION_PROP = 'animation';

  ANIMATIONEND_EVENT = 'animationend';

}

var DURATION_KEY = 'Duration';

var PROPERTY_KEY = 'Property';

var DELAY_KEY = 'Delay';

var TIMING_KEY = 'TimingFunction';

var ANIMATION_ITERATION_COUNT_KEY = 'IterationCount';

var ANIMATION_PLAYSTATE_KEY = 'PlayState';

var SAFE_FAST_FORWARD_DURATION_VALUE = 9999;

var ANIMATION_DELAY_PROP = ANIMATION_PROP + DELAY_KEY;

var ANIMATION_DURATION_PROP = ANIMATION_PROP + DURATION_KEY;

var TRANSITION_DELAY_PROP = TRANSITION_PROP + DELAY_KEY;

var TRANSITION_DURATION_PROP = TRANSITION_PROP + DURATION_KEY;

  return p && p.then ? true : false;

};

var ngMinErr = angular.$$minErr('ng');

function assertArg(arg, name, reason) {

  if (!arg) {

    throw ngMinErr('areq', "Argument '{0}' is {1}", (name || '?'), (reason || "required"));

  }

  return arg;

}

function mergeClasses(a,b) {

  if (!a && !b) return '';

  if (!a) return b;

  if (!b) return a;

  if (isArray(a)) a = a.join(' ');

  if (isArray(b)) b = b.join(' ');

  return a + ' ' + b;

}

function packageStyles(options) {

  var styles = {};

  if (options && (options.to || options.from)) {

    styles.to = options.to;

    styles.from = options.from;

  }

  return styles;

}

function pendClasses(classes, fix, isPrefix) {

  var className = '';

  classes = isArray(classes)

      ? classes

      : classes && isString(classes) && classes.length

          ? classes.split(/\s+/)

          : [];

  forEach(classes, function(klass, i) {

    if (klass && klass.length > 0) {

      className += (i > 0) ? ' ' : '';

      className += isPrefix ? fix + klass

                            : klass + fix;

    }

  });

  return className;

}

function removeFromArray(arr, val) {

  var index = arr.indexOf(val);

  if (val >= 0) {

    arr.splice(index, 1);

  }

}

function stripCommentsFromElement(element) {

  if (element instanceof jqLite) {

    switch (element.length) {

      case 0:

        return [];

      case 1:

        // there is no point of stripping anything if the element

        // is the only element within the jqLite wrapper.

        // (it's important that we retain the element instance.)

        if (element[0].nodeType === ELEMENT_NODE) {

          return element;

        }

        break;

      default:

        return jqLite(extractElementNode(element));

    }

  }

  if (element.nodeType === ELEMENT_NODE) {

    return jqLite(element);

  }

}

function extractElementNode(element) {

  if (!element[0]) return element;

  for (var i = 0; i < element.length; i++) {

    var elm = element[i];

    if (elm.nodeType == ELEMENT_NODE) {

      return elm;

    }

  }

}

function $$addClass($$jqLite, element, className) {

  forEach(element, function(elm) {

    $$jqLite.addClass(elm, className);

  });

}

function $$removeClass($$jqLite, element, className) {

  forEach(element, function(elm) {

    $$jqLite.removeClass(elm, className);

  });

}

function applyAnimationClassesFactory($$jqLite) {

  return function(element, options) {

    if (options.addClass) {

      $$addClass($$jqLite, element, options.addClass);

      options.addClass = null;

    }

    if (options.removeClass) {

      $$removeClass($$jqLite, element, options.removeClass);

      options.removeClass = null;

    }

  }

}

function prepareAnimationOptions(options) {

  options = options || {};

  if (!options.$$prepared) {

    var domOperation = options.domOperation || noop;

    options.domOperation = function() {

      options.$$domOperationFired = true;

      domOperation();

      domOperation = noop;

    };

    options.$$prepared = true;

  }

  return options;

}

function applyAnimationStyles(element, options) {

  applyAnimationFromStyles(element, options);

  applyAnimationToStyles(element, options);

}

function applyAnimationFromStyles(element, options) {

  if (options.from) {

    element.css(options.from);

    options.from = null;

  }

}

function applyAnimationToStyles(element, options) {

  if (options.to) {

    element.css(options.to);

    options.to = null;

  }

}

function mergeAnimationDetails(element, oldAnimation, newAnimation) {

  var target = oldAnimation.options || {};

  var newOptions = newAnimation.options || {};

  var toAdd = (target.addClass || '') + ' ' + (newOptions.addClass || '');

  var toRemove = (target.removeClass || '') + ' ' + (newOptions.removeClass || '');

  var classes = resolveElementClasses(element.attr('class'), toAdd, toRemove);

  if (newOptions.preparationClasses) {

    target.preparationClasses = concatWithSpace(newOptions.preparationClasses, target.preparationClasses);

    delete newOptions.preparationClasses;

  }

  // noop is basically when there is no callback; otherwise something has been set

  var realDomOperation = target.domOperation !== noop ? target.domOperation : null;

  extend(target, newOptions);

  // 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.

  if (realDomOperation) {

    target.domOperation = realDomOperation;

  }

  if (classes.addClass) {

    target.addClass = classes.addClass;

  } else {

    target.addClass = null;

  }

  if (classes.removeClass) {

    target.removeClass = classes.removeClass;

  } else {

    target.removeClass = null;

  }

  oldAnimation.addClass = target.addClass;

  oldAnimation.removeClass = target.removeClass;

  return target;

}

function resolveElementClasses(existing, toAdd, toRemove) {

  var ADD_CLASS = 1;

  var REMOVE_CLASS = -1;

  var flags = {};

  existing = splitClassesToLookup(existing);

  toAdd = splitClassesToLookup(toAdd);

  forEach(toAdd, function(value, key) {

    flags[key] = ADD_CLASS;

  });

  toRemove = splitClassesToLookup(toRemove);

  forEach(toRemove, function(value, key) {

    flags[key] = flags[key] === ADD_CLASS ? null : REMOVE_CLASS;

  });

  var classes = {

    addClass: '',

    removeClass: ''

  };

  forEach(flags, function(val, klass) {

    var prop, allow;

    if (val === ADD_CLASS) {

      prop = 'addClass';

      allow = !existing[klass];

    } else if (val === REMOVE_CLASS) {

      prop = 'removeClass';

      allow = existing[klass];

    }

    if (allow) {

      if (classes[prop].length) {

        classes[prop] += ' ';

      }

      classes[prop] += klass;

    }

  });

  function splitClassesToLookup(classes) {

    if (isString(classes)) {

      classes = classes.split(' ');

    }

    var obj = {};

    forEach(classes, function(klass) {

      // sometimes the split leaves empty string values

      // incase extra spaces were applied to the options

      if (klass.length) {

        obj[klass] = true;

      }

    });

    return obj;

  }

  return classes;

}

function getDomNode(element) {

  return (element instanceof angular.element) ? element[0] : element;

}

function applyGeneratedPreparationClasses(element, event, options) {

  var classes = '';

  if (event) {

    classes = pendClasses(event, EVENT_CLASS_PREFIX, true);

  }

  if (options.addClass) {

    classes = concatWithSpace(classes, pendClasses(options.addClass, ADD_CLASS_SUFFIX));

  }

  if (options.removeClass) {

    classes = concatWithSpace(classes, pendClasses(options.removeClass, REMOVE_CLASS_SUFFIX));

  }

  if (classes.length) {

    options.preparationClasses = classes;

    element.addClass(classes);

  }

}

function clearGeneratedClasses(element, options) {

  if (options.preparationClasses) {

    element.removeClass(options.preparationClasses);

    options.preparationClasses = null;

  }

  if (options.activeClasses) {

    element.removeClass(options.activeClasses);

    options.activeClasses = null;

  }

}

function blockTransitions(node, duration) {

  // we use a negative delay value since it performs blocking

  // yet it doesn't kill any existing transitions running on the

  // same element which makes this safe for class-based animations

  var value = duration ? '-' + duration + 's' : '';

  applyInlineStyle(node, [TRANSITION_DELAY_PROP, value]);

  return [TRANSITION_DELAY_PROP, value];

}

function blockKeyframeAnimations(node, applyBlock) {

  var value = applyBlock ? 'paused' : '';

  var key = ANIMATION_PROP + ANIMATION_PLAYSTATE_KEY;

  applyInlineStyle(node, [key, value]);

  return [key, value];

}

function applyInlineStyle(node, styleTuple) {

  var prop = styleTuple[0];

  var value = styleTuple[1];

  node.style[prop] = value;

}

function concatWithSpace(a,b) {

  if (!a) return b;

  if (!b) return a;

  return a + ' ' + b;

}

var $$rAFSchedulerFactory = ['$$rAF', function($$rAF) {

  var queue, cancelFn;

  function scheduler(tasks) {

    // we make a copy since RAFScheduler mutates the state

    // of the passed in array variable and this would be difficult

    // to track down on the outside code

    queue = queue.concat(tasks);

    nextTick();

  }

  queue = scheduler.queue = [];

  /* waitUntilQuiet does two things:

   * 1. It will run the FINAL `fn` value only when an uncanceled RAF has passed through

   * 2. It will delay the next wave of tasks from running until the quiet `fn` has run.

   *

   * The motivation here is that animation code can request more time from the scheduler

   * before the next wave runs. This allows for certain DOM properties such as classes to

   * be resolved in time for the next animation to run.

   */

  scheduler.waitUntilQuiet = function(fn) {

    if (cancelFn) cancelFn();

    cancelFn = $$rAF(function() {

      cancelFn = null;

      fn();

      nextTick();

    });

  };

  return scheduler;

  function nextTick() {

    if (!queue.length) return;

    var items = queue.shift();

    for (var i = 0; i < items.length; i++) {

      items[i]();

    }

    if (!cancelFn) {

      $$rAF(function() {

        if (!cancelFn) nextTick();

      });

    }

  }

}];

/**

 * @ngdoc directive

 * @name ngAnimateChildren

 * @restrict AE

 * @element ANY

 *

 * @description

 *

 * ngAnimateChildren allows you to specify that children of this element should animate even if any

 * of the children's parents are currently animating. By default, when an element has an active `enter`, `leave`, or `move`

 * (structural) animation, child elements that also have an active structural animation are not animated.

 *

 * Note that even if `ngAnimteChildren` is set, no child animations will run when the parent element is removed from the DOM (`leave` animation).

 *

 *

 * @param {string} ngAnimateChildren If the value is empty, `true` or `on`,

 *     then child animations are allowed. If the value is `false`, child animations are not allowed.

 *

 * @example

 * <example module="ngAnimateChildren" name="ngAnimateChildren" deps="angular-animate.js" animations="true">

     <file name="index.html">

       <div ng-controller="mainController as main">

         <label>Show container? <input type="checkbox" ng-model="main.enterElement" /></label>

         <label>Animate children? <input type="checkbox" ng-model="main.animateChildren" /></label>

         <hr>

         <div ng-animate-children="{{main.animateChildren}}">

           <div ng-if="main.enterElement" class="container">

             List of items:

             <div ng-repeat="item in [0, 1, 2, 3]" class="item">Item {{item}}</div>

           </div>

         </div>

       </div>

     </file>

     <file name="animations.css">

      .container.ng-enter,

      .container.ng-leave {

        transition: all ease 1.5s;

      }

      .container.ng-enter,

      .container.ng-leave-active {

        opacity: 0;

      }

      .container.ng-leave,

      .container.ng-enter-active {

        opacity: 1;

      }

      .item {

        background: firebrick;

        color: #FFF;

        margin-bottom: 10px;

      }

      .item.ng-enter,

      .item.ng-leave {

        transition: transform 1.5s ease;

      }

      .item.ng-enter {

        transform: translateX(50px);

      }

      .item.ng-enter-active {

        transform: translateX(0);

      }

    </file>

    <file name="script.js">

      angular.module('ngAnimateChildren', ['ngAnimate'])

        .controller('mainController', function() {

          this.animateChildren = false;

          this.enterElement = false;

        });

    </file>

  </example>

 */

var $$AnimateChildrenDirective = ['$interpolate', function($interpolate) {

  return {

    link: function(scope, element, attrs) {

      var val = attrs.ngAnimateChildren;

      if (angular.isString(val) && val.length === 0) { //empty attribute

        element.data(NG_ANIMATE_CHILDREN_DATA, true);

      } else {

        // Interpolate and set the value, so that it is available to

        // animations that run right after compilation

        setData($interpolate(val)(scope));

        attrs.$observe('ngAnimateChildren', setData);

      }

      function setData(value) {

        value = value === 'on' || value === 'true';

        element.data(NG_ANIMATE_CHILDREN_DATA, value);

      }

    }

  };

}];

var ANIMATE_TIMER_KEY = '$$animateCss';

/**

 * @ngdoc service

 * @name $animateCss

 * @kind object

 *

 * @description

 * The `$animateCss` service is a useful utility to trigger customized CSS-based transitions/keyframes

 * from a JavaScript-based animation or directly from a directive. The purpose of `$animateCss` is NOT

 * to side-step how `$animate` and ngAnimate work, but the goal is to allow pre-existing animations or

 * directives to create more complex animations that can be purely driven using CSS code.

 *

 * Note that only browsers that support CSS transitions and/or keyframe animations are capable of

 * rendering animations triggered via `$animateCss` (bad news for IE9 and lower).

 *

 * ## Usage

 * Once again, `$animateCss` is designed to be used inside of a registered JavaScript animation that

 * is powered by ngAnimate. It is possible to use `$animateCss` directly inside of a directive, however,

 * any automatic control over cancelling animations and/or preventing animations from being run on

 * child elements will not be handled by Angular. For this to work as expected, please use `$animate` to

 * trigger the animation and then setup a JavaScript animation that injects `$animateCss` to trigger

 * the CSS animation.

 *

 * The example below shows how we can create a folding animation on an element using `ng-if`:

 *

 * ```html

 * <!-- notice the `fold-animation` CSS class -->

 * <div ng-if="onOff" class="fold-animation">

 *   This element will go BOOM

 * </div>

 * <button ng-click="onOff=true">Fold In</button>

 * ```

 *

 * Now we create the **JavaScript animation** that will trigger the CSS transition:

 *

 * ```js

 * ngModule.animation('.fold-animation', ['$animateCss', function($animateCss) {

 *   return {

 *     enter: function(element, doneFn) {

 *       var height = element[0].offsetHeight;

 *       return $animateCss(element, {

 *         from: { height:'0px' },

 *         to: { height:height + 'px' },

 *         duration: 1 // one second

 *       });

 *     }

 *   }

 * }]);

 * ```

 *

 * ## More Advanced Uses

 *

 * `$animateCss` is the underlying code that ngAnimate uses to power **CSS-based animations** behind the scenes. Therefore CSS hooks

 * like `.ng-EVENT`, `.ng-EVENT-active`, `.ng-EVENT-stagger` are all features that can be triggered using `$animateCss` via JavaScript code.

 *

 * This also means that just about any combination of adding classes, removing classes, setting styles, dynamically setting a keyframe animation,

 * applying a hardcoded duration or delay value, changing the animation easing or applying a stagger animation are all options that work with

 * `$animateCss`. The service itself is smart enough to figure out the combination of options and examine the element styling properties in order

 * to provide a working animation that will run in CSS.

 *

 * The example below showcases a more advanced version of the `.fold-animation` from the example above:

 *

 * ```js

 * ngModule.animation('.fold-animation', ['$animateCss', function($animateCss) {

 *   return {

 *     enter: function(element, doneFn) {

 *       var height = element[0].offsetHeight;

 *       return $animateCss(element, {

 *         addClass: 'red large-text pulse-twice',

 *         easing: 'ease-out',

 *         from: { height:'0px' },

 *         to: { height:height + 'px' },

 *         duration: 1 // one second

 *       });

 *     }

 *   }

 * }]);

 * ```

 *

 * Since we're adding/removing CSS classes then the CSS transition will also pick those up:

 *

 * ```css

 * /* since a hardcoded duration value of 1 was provided in the JavaScript animation code,

 * the CSS classes below will be transitioned despite them being defined as regular CSS classes */

 * .red { background:red; }

 * .large-text { font-size:20px; }

 *

 * /* we can also use a keyframe animation and $animateCss will make it work alongside the transition */

 * .pulse-twice {

 *   animation: 0.5s pulse linear 2;

 *   -webkit-animation: 0.5s pulse linear 2;

 * }

 *

 * @keyframes pulse {

 *   from { transform: scale(0.5); }

 *   to { transform: scale(1.5); }

 * }

 *

 * @-webkit-keyframes pulse {

 *   from { -webkit-transform: scale(0.5); }

 *   to { -webkit-transform: scale(1.5); }

 * }

 * ```

 *

 * Given this complex combination of CSS classes, styles and options, `$animateCss` will figure everything out and make the animation happen.

 *

 * ## How the Options are handled

 *

 * `$animateCss` is very versatile and intelligent when it comes to figuring out what configurations to apply to the element to ensure the animation

 * works with the options provided. Say for example we were adding a class that contained a keyframe value and we wanted to also animate some inline

 * styles using the `from` and `to` properties.

 *

 * ```js

 * var animator = $animateCss(element, {

 *   from: { background:'red' },

 *   to: { background:'blue' }

 * });

 * animator.start();

 * ```

 *

 * ```css

 * .rotating-animation {

 *   animation:0.5s rotate linear;

 *   -webkit-animation:0.5s rotate linear;

 * }

 *

 * @keyframes rotate {

 *   from { transform: rotate(0deg); }

 *   to { transform: rotate(360deg); }

 * }

 *

 * @-webkit-keyframes rotate {

 *   from { -webkit-transform: rotate(0deg); }

 *   to { -webkit-transform: rotate(360deg); }

 * }

 * ```

 *

 * The missing pieces here are that we do not have a transition set (within the CSS code nor within the `$animateCss` options) and the duration of the animation is

 * going to be detected from what the keyframe styles on the CSS class are. In this event, `$animateCss` will automatically create an inline transition

 * style matching the duration detected from the keyframe style (which is present in the CSS class that is being added) and then prepare both the transition

 * and keyframe animations to run in parallel on the element. Then when the animation is underway the provided `from` and `to` CSS styles will be applied

 * and spread across the transition and keyframe animation.

 *

 * ## What is returned

 *

 * `$animateCss` works in two stages: a preparation phase and an animation phase. Therefore when `$animateCss` is first called it will NOT actually

 * start the animation. All that is going on here is that the element is being prepared for the animation (which means that the generated CSS classes are

 * added and removed on the element). Once `$animateCss` is called it will return an object with the following properties:

 *

 * ```js

 * var animator = $animateCss(element, { ... });

 * ```

 *

 * Now what do the contents of our `animator` variable look like:

 *

 * ```js

 * {

 *   // starts the animation

 *   start: Function,

 *

 *   // ends (aborts) the animation

 *   end: Function

 * }

 * ```

 *

 * To actually start the animation we need to run `animation.start()` which will then return a promise that we can hook into to detect when the animation ends.

 * If we choose not to run the animation then we MUST run `animation.end()` to perform a cleanup on the element (since some CSS classes and styles may have been

 * applied to the element during the preparation phase). Note that all other properties such as duration, delay, transitions and keyframes are just properties

 * and that changing them will not reconfigure the parameters of the animation.

 *

 * ### runner.done() vs runner.then()

 * It is documented that `animation.start()` will return a promise object and this is true, however, there is also an additional method available on the

 * runner called `.done(callbackFn)`. The done method works the same as `.finally(callbackFn)`, however, it does **not trigger a digest to occur**.

 * Therefore, for performance reasons, it's always best to use `runner.done(callback)` instead of `runner.then()`, `runner.catch()` or `runner.finally()`

 * unless you really need a digest to kick off afterwards.

 *

 * Keep in mind that, to make this easier, ngAnimate has tweaked the JS animations API to recognize when a runner instance is returned from $animateCss

 * (so there is no need to call `runner.done(doneFn)` inside of your JavaScript animation code).

 * Check the {@link ngAnimate.$animateCss#usage animation code above} to see how this works.

 *

 * @param {DOMElement} element the element that will be animated

 * @param {object} options the animation-related options that will be applied during the animation

 *

 * * `event` - The DOM event (e.g. enter, leave, move). When used, a generated CSS class of `ng-EVENT` and `ng-EVENT-active` will be applied

 * to the element during the animation. Multiple events can be provided when spaces are used as a separator. (Note that this will not perform any DOM operation.)

 * * `structural` - Indicates that the `ng-` prefix will be added to the event class. Setting to `false` or omitting will turn `ng-EVENT` and

 * `ng-EVENT-active` in `EVENT` and `EVENT-active`. Unused if `event` is omitted.

 * * `easing` - The CSS easing value that will be applied to the transition or keyframe animation (or both).

 * * `transitionStyle` - The raw CSS transition style that will be used (e.g. `1s linear all`).

 * * `keyframeStyle` - The raw CSS keyframe animation style that will be used (e.g. `1s my_animation linear`).

 * * `from` - The starting CSS styles (a key/value object) that will be applied at the start of the animation.

 * * `to` - The ending CSS styles (a key/value object) that will be applied across the animation via a CSS transition.

 * * `addClass` - A space separated list of CSS classes that will be added to the element and spread across the animation.

 * * `removeClass` - A space separated list of CSS classes that will be removed from the element and spread across the animation.

 * * `duration` - A number value representing the total duration of the transition and/or keyframe (note that a value of 1 is 1000ms). If a value of `0`

 * is provided then the animation will be skipped entirely.

 * * `delay` - A number value representing the total delay of the transition and/or keyframe (note that a value of 1 is 1000ms). If a value of `true` is

 * used then whatever delay value is detected from the CSS classes will be mirrored on the elements styles (e.g. by setting delay true then the style value

 * of the element will be `transition-delay: DETECTED_VALUE`). Using `true` is useful when you want the CSS classes and inline styles to all share the same

 * CSS delay value.

 * * `stagger` - A numeric time value representing the delay between successively animated elements

 * ({@link ngAnimate#css-staggering-animations Click here to learn how CSS-based staggering works in ngAnimate.})

 * * `staggerIndex` - The numeric index representing the stagger item (e.g. a value of 5 is equal to the sixth item in the stagger; therefore when a

 *   `stagger` option value of `0.1` is used then there will be a stagger delay of `600ms`)

 * * `applyClassesEarly` - Whether or not the classes being added or removed will be used when detecting the animation. This is set by `$animate` when enter/leave/move animations are fired to ensure that the CSS classes are resolved in time. (Note that this will prevent any transitions from occurring on the classes being added and removed.)

 * * `cleanupStyles` - Whether or not the provided `from` and `to` styles will be removed once

 *    the animation is closed. This is useful for when the styles are used purely for the sake of

 *    the animation and do not have a lasting visual effect on the element (e.g. a collapse and open animation).

 *    By default this value is set to `false`.

 *

 * @return {object} an object with start and end methods and details about the animation.

 *

 * * `start` - The method to start the animation. This will return a `Promise` when called.

 * * `end` - This method will cancel the animation and remove all applied CSS classes and styles.

 */

var ONE_SECOND = 1000;

var ELAPSED_TIME_MAX_DECIMAL_PLACES = 3;

var CLOSING_TIME_BUFFER = 1.5;

var DETECT_CSS_PROPERTIES = {

  transitionDuration:      TRANSITION_DURATION_PROP,

  transitionDelay:         TRANSITION_DELAY_PROP,

  transitionProperty:      TRANSITION_PROP + PROPERTY_KEY,

  animationDuration:       ANIMATION_DURATION_PROP,

  animationDelay:          ANIMATION_DELAY_PROP,

  animationIterationCount: ANIMATION_PROP + ANIMATION_ITERATION_COUNT_KEY

};

var DETECT_STAGGER_CSS_PROPERTIES = {

  transitionDuration:      TRANSITION_DURATION_PROP,

  transitionDelay:         TRANSITION_DELAY_PROP,

  animationDuration:       ANIMATION_DURATION_PROP,

  animationDelay:          ANIMATION_DELAY_PROP

};

function getCssKeyframeDurationStyle(duration) {

  return [ANIMATION_DURATION_PROP, duration + 's'];

}

function getCssDelayStyle(delay, isKeyframeAnimation) {

  var prop = isKeyframeAnimation ? ANIMATION_DELAY_PROP : TRANSITION_DELAY_PROP;

  return [prop, delay + 's'];

}

function computeCssStyles($window, element, properties) {

  var styles = Object.create(null);

  var detectedStyles = $window.getComputedStyle(element) || {};

  forEach(properties, function(formalStyleName, actualStyleName) {

    var val = detectedStyles[formalStyleName];

    if (val) {

      var c = val.charAt(0);

      // only numerical-based values have a negative sign or digit as the first value

      if (c === '-' || c === '+' || c >= 0) {

        val = parseMaxTime(val);

      }

      // by setting this to null in the event that the delay is not set or is set directly as 0

      // then we can still allow for negative values to be used later on and not mistake this

      // value for being greater than any other negative value.

      if (val === 0) {

        val = null;

      }

      styles[actualStyleName] = val;

    }

  });

  return styles;

}

function parseMaxTime(str) {

  var maxValue = 0;

  var values = str.split(/\s*,\s*/);

  forEach(values, function(value) {

    // it's always safe to consider only second values and omit `ms` values since

    // getComputedStyle will always handle the conversion for us

    if (value.charAt(value.length - 1) == 's') {

      value = value.substring(0, value.length - 1);

    }

    value = parseFloat(value) || 0;

    maxValue = maxValue ? Math.max(value, maxValue) : value;

  });

  return maxValue;

}

function truthyTimingValue(val) {

  return val === 0 || val != null;

}

function getCssTransitionDurationStyle(duration, applyOnlyDuration) {

  var style = TRANSITION_PROP;

  var value = duration + 's';

  if (applyOnlyDuration) {

    style += DURATION_KEY;

  } else {

    value += ' linear all';

  }

  return [style, value];

}

function createLocalCacheLookup() {

  var cache = Object.create(null);

  return {

    flush: function() {

      cache = Object.create(null);

    },

    count: function(key) {

      var entry = cache[key];

      return entry ? entry.total : 0;

    },

    get: function(key) {

      var entry = cache[key];

      return entry && entry.value;

    },

    put: function(key, value) {

      if (!cache[key]) {

        cache[key] = { total: 1, value: value };

      } else {

        cache[key].total++;

      }

    }

  };

}

// we do not reassign an already present style value since

// if we detect the style property value again we may be

// detecting styles that were added via the `from` styles.

// We make use of `isDefined` here since an empty string

// or null value (which is what getPropertyValue will return

// for a non-existing style) will still be marked as a valid

// value for the style (a falsy value implies that the style

// is to be removed at the end of the animation). If we had a simple

// "OR" statement then it would not be enough to catch that.

function registerRestorableStyles(backup, node, properties) {

  forEach(properties, function(prop) {

    backup[prop] = isDefined(backup[prop])

        ? backup[prop]

        : node.style.getPropertyValue(prop);

  });

}

var $AnimateCssProvider = ['$animateProvider', function($animateProvider) {

  var gcsLookup = createLocalCacheLookup();

  var gcsStaggerLookup = createLocalCacheLookup();

  this.$get = ['$window', '$$jqLite', '$$AnimateRunner', '$timeout',

               '$$forceReflow', '$sniffer', '$$rAFScheduler', '$$animateQueue',

       function($window,   $$jqLite,   $$AnimateRunner,   $timeout,

                $$forceReflow,   $sniffer,   $$rAFScheduler, $$animateQueue) {

    var applyAnimationClasses = applyAnimationClassesFactory($$jqLite);

    var parentCounter = 0;

    function gcsHashFn(node, extraClasses) {

      var KEY = "$$ngAnimateParentKey";

      var parentNode = node.parentNode;

      var parentID = parentNode[KEY] || (parentNode[KEY] = ++parentCounter);

      return parentID + '-' + node.getAttribute('class') + '-' + extraClasses;

    }

    function computeCachedCssStyles(node, className, cacheKey, properties) {

      var timings = gcsLookup.get(cacheKey);

      if (!timings) {

        timings = computeCssStyles($window, node, properties);

        if (timings.animationIterationCount === 'infinite') {

          timings.animationIterationCount = 1;

        }

      }

      // we keep putting this in multiple times even though the value and the cacheKey are the same

      // because we're keeping an internal tally of how many duplicate animations are detected.

      gcsLookup.put(cacheKey, timings);

      return timings;

    }

    function computeCachedCssStaggerStyles(node, className, cacheKey, properties) {

      var stagger;

      // if we have one or more existing matches of matching elements

      // containing the same parent + CSS styles (which is how cacheKey works)

      // then staggering is possible

      if (gcsLookup.count(cacheKey) > 0) {

        stagger = gcsStaggerLookup.get(cacheKey);

        if (!stagger) {

          var staggerClassName = pendClasses(className, '-stagger');

          $$jqLite.addClass(node, staggerClassName);

          stagger = computeCssStyles($window, node, properties);

          // force the conversion of a null value to zero incase not set

          stagger.animationDuration = Math.max(stagger.animationDuration, 0);

          stagger.transitionDuration = Math.max(stagger.transitionDuration, 0);

          $$jqLite.removeClass(node, staggerClassName);

          gcsStaggerLookup.put(cacheKey, stagger);

        }

      }

      return stagger || {};

    }

    var rafWaitQueue = [];

    function waitUntilQuiet(callback) {

      rafWaitQueue.push(callback);

      $$rAFScheduler.waitUntilQuiet(function() {

        gcsLookup.flush();

        gcsStaggerLookup.flush();

        // DO NOT REMOVE THIS LINE OR REFACTOR OUT THE `pageWidth` variable.

        // PLEASE EXAMINE THE `$$forceReflow` service to understand why.

        var pageWidth = $$forceReflow();

        // we use a for loop to ensure that if the queue is changed

        // during this looping then it will consider new requests

        for (var i = 0; i < rafWaitQueue.length; i++) {

          rafWaitQueue[i](pageWidth);

        }

        rafWaitQueue.length = 0;

      });

    }

    function computeTimings(node, className, cacheKey) {

      var timings = computeCachedCssStyles(node, className, cacheKey, DETECT_CSS_PROPERTIES);

      var aD = timings.animationDelay;

      var tD = timings.transitionDelay;

      timings.maxDelay = aD && tD

          ? Math.max(aD, tD)

          : (aD || tD);

      timings.maxDuration = Math.max(

          timings.animationDuration * timings.animationIterationCount,

          timings.transitionDuration);

      return timings;