text: /**
   * @license AngularJS v1.2.1
   * (c) 2010-2012 Google, Inc. http://angularjs.org
   * License: MIT
   */
  (function(window, angular, undefined) {'use strict';
  
  /**
   * @ngdoc overview
   * @name ngTouch
   * @description
   *
   * # ngTouch
   *
   * The `ngTouch` module provides touch events and other helpers for touch-enabled devices.
   * The implementation is based on jQuery Mobile touch event handling 
   * ([jquerymobile.com](http://jquerymobile.com/)).
   *
   * {@installModule touch}
   *
   * See {@link ngTouch.$swipe `$swipe`} for usage.
   *
   * <div doc-module-components="ngTouch"></div>
   *
   */
  
  // define ngTouch module
  /* global -ngTouch */
  var ngTouch = angular.module('ngTouch', []);
  
  /* global ngTouch: false */
  
      /**
       * @ngdoc object
       * @name ngTouch.$swipe
       *
       * @description
       * The `$swipe` service is a service that abstracts the messier details of hold-and-drag swipe
       * behavior, to make implementing swipe-related directives more convenient.
       *
       * Requires the {@link ngTouch `ngTouch`} module to be installed.
       *
       * `$swipe` is used by the `ngSwipeLeft` and `ngSwipeRight` directives in `ngTouch`, and by
       * `ngCarousel` in a separate component.
       *
       * # Usage
       * The `$swipe` service is an object with a single method: `bind`. `bind` takes an element
       * which is to be watched for swipes, and an object with four handler functions. See the
       * documentation for `bind` below.
       */
  
  ngTouch.factory('$swipe', [function() {
    // The total distance in any direction before we make the call on swipe vs. scroll.
    var MOVE_BUFFER_RADIUS = 10;
  
    function getCoordinates(event) {
      var touches = event.touches && event.touches.length ? event.touches : [event];
      var e = (event.changedTouches && event.changedTouches[0]) ||
          (event.originalEvent && event.originalEvent.changedTouches &&
              event.originalEvent.changedTouches[0]) ||
          touches[0].originalEvent || touches[0];
  
      return {
        x: e.clientX,
        y: e.clientY
      };
    }
  
    return {
      /**
       * @ngdoc method
       * @name ngTouch.$swipe#bind
       * @methodOf ngTouch.$swipe
       *
       * @description
       * The main method of `$swipe`. It takes an element to be watched for swipe motions, and an
       * object containing event handlers.
       *
       * The four events are `start`, `move`, `end`, and `cancel`. `start`, `move`, and `end`
       * receive as a parameter a coordinates object of the form `{ x: 150, y: 310 }`.
       *
       * `start` is called on either `mousedown` or `touchstart`. After this event, `$swipe` is
       * watching for `touchmove` or `mousemove` events. These events are ignored until the total
       * distance moved in either dimension exceeds a small threshold.
       *
       * Once this threshold is exceeded, either the horizontal or vertical delta is greater.
       * - If the horizontal distance is greater, this is a swipe and `move` and `end` events follow.
       * - If the vertical distance is greater, this is a scroll, and we let the browser take over.
       *   A `cancel` event is sent.
       *
       * `move` is called on `mousemove` and `touchmove` after the above logic has determined that
       * a swipe is in progress.
       *
       * `end` is called when a swipe is successfully completed with a `touchend` or `mouseup`.
       *
       * `cancel` is called either on a `touchcancel` from the browser, or when we begin scrolling
       * as described above.
       *
       */
      bind: function(element, eventHandlers) {
        // Absolute total movement, used to control swipe vs. scroll.
        var totalX, totalY;
        // Coordinates of the start position.
        var startCoords;
        // Last event's position.
        var lastPos;
        // Whether a swipe is active.
        var active = false;
  
        element.on('touchstart mousedown', function(event) {
          startCoords = getCoordinates(event);
          active = true;
          totalX = 0;
          totalY = 0;
          lastPos = startCoords;
          eventHandlers['start'] && eventHandlers['start'](startCoords, event);
        });
  
        element.on('touchcancel', function(event) {
          active = false;
          eventHandlers['cancel'] && eventHandlers['cancel'](event);
        });
  
        element.on('touchmove mousemove', function(event) {
          if (!active) return;
  
          // Android will send a touchcancel if it thinks we're starting to scroll.
          // So when the total distance (+ or - or both) exceeds 10px in either direction,
          // we either:
          // - On totalX > totalY, we send preventDefault() and treat this as a swipe.
          // - On totalY > totalX, we let the browser handle it as a scroll.
  
          if (!startCoords) return;
          var coords = getCoordinates(event);
  
          totalX += Math.abs(coords.x - lastPos.x);
          totalY += Math.abs(coords.y - lastPos.y);
  
          lastPos = coords;
  
          if (totalX < MOVE_BUFFER_RADIUS && totalY < MOVE_BUFFER_RADIUS) {
            return;
          }
  
          // One of totalX or totalY has exceeded the buffer, so decide on swipe vs. scroll.
          if (totalY > totalX) {
            // Allow native scrolling to take over.
            active = false;
            eventHandlers['cancel'] && eventHandlers['cancel'](event);
            return;
          } else {
            // Prevent the browser from scrolling.
            event.preventDefault();
            eventHandlers['move'] && eventHandlers['move'](coords, event);
          }
        });
  
        element.on('touchend mouseup', function(event) {
          if (!active) return;
          active = false;
          eventHandlers['end'] && eventHandlers['end'](getCoordinates(event), event);
        });
      }
    };
  }]);
  
  /* global ngTouch: false */
  
  /**
   * @ngdoc directive
   * @name ngTouch.directive:ngClick
   *
   * @description
   * A more powerful replacement for the default ngClick designed to be used on touchscreen
   * devices. Most mobile browsers wait about 300ms after a tap-and-release before sending
   * the click event. This version handles them immediately, and then prevents the
   * following click event from propagating.
   *
   * Requires the {@link ngTouch `ngTouch`} module to be installed.
   *
   * This directive can fall back to using an ordinary click event, and so works on desktop
   * browsers as well as mobile.
   *
   * This directive also sets the CSS class `ng-click-active` while the element is being held
   * down (by a mouse click or touch) so you can restyle the depressed element if you wish.
   *
   * @element ANY
   * @param {expression} ngClick {@link guide/expression Expression} to evaluate
   * upon tap. (Event object is available as `$event`)
   *
   * @example
      <doc:example>
        <doc:source>
          <button ng-click="count = count + 1" ng-init="count=0">
            Increment
          </button>
          count: {{ count }}
        </doc:source>
      </doc:example>
   */
  
  ngTouch.config(['$provide', function($provide) {
    $provide.decorator('ngClickDirective', ['$delegate', function($delegate) {
      // drop the default ngClick directive
      $delegate.shift();
      return $delegate;
    }]);
  }]);
  
  ngTouch.directive('ngClick', ['$parse', '$timeout', '$rootElement',
      function($parse, $timeout, $rootElement) {
    var TAP_DURATION = 750; // Shorter than 750ms is a tap, longer is a taphold or drag.
    var MOVE_TOLERANCE = 12; // 12px seems to work in most mobile browsers.
    var PREVENT_DURATION = 2500; // 2.5 seconds maximum from preventGhostClick call to click
    var CLICKBUSTER_THRESHOLD = 25; // 25 pixels in any dimension is the limit for busting clicks.
  
    var ACTIVE_CLASS_NAME = 'ng-click-active';
    var lastPreventedTime;
    var touchCoordinates;
  
  
    // TAP EVENTS AND GHOST CLICKS
    //
    // Why tap events?
    // Mobile browsers detect a tap, then wait a moment (usually ~300ms) to see if you're
    // double-tapping, and then fire a click event.
    //
    // This delay sucks and makes mobile apps feel unresponsive.
    // So we detect touchstart, touchmove, touchcancel and touchend ourselves and determine when
    // the user has tapped on something.
    //
    // What happens when the browser then generates a click event?
    // The browser, of course, also detects the tap and fires a click after a delay. This results in
    // tapping/clicking twice. So we do "clickbusting" to prevent it.
    //
    // How does it work?
    // We attach global touchstart and click handlers, that run during the capture (early) phase.
    // So the sequence for a tap is:
    // - global touchstart: Sets an "allowable region" at the point touched.
    // - element's touchstart: Starts a touch
    // (- touchmove or touchcancel ends the touch, no click follows)
    // - element's touchend: Determines if the tap is valid (didn't move too far away, didn't hold
    //   too long) and fires the user's tap handler. The touchend also calls preventGhostClick().
    // - preventGhostClick() removes the allowable region the global touchstart created.
    // - The browser generates a click event.
    // - The global click handler catches the click, and checks whether it was in an allowable region.
    //     - If preventGhostClick was called, the region will have been removed, the click is busted.
    //     - If the region is still there, the click proceeds normally. Therefore clicks on links and
    //       other elements without ngTap on them work normally.
    //
    // This is an ugly, terrible hack!
    // Yeah, tell me about it. The alternatives are using the slow click events, or making our users
    // deal with the ghost clicks, so I consider this the least of evils. Fortunately Angular
    // encapsulates this ugly logic away from the user.
    //
    // Why not just put click handlers on the element?
    // We do that too, just to be sure. The problem is that the tap event might have caused the DOM
    // to change, so that the click fires in the same position but something else is there now. So
    // the handlers are global and care only about coordinates and not elements.
  
    // Checks if the coordinates are close enough to be within the region.
    function hit(x1, y1, x2, y2) {
      return Math.abs(x1 - x2) < CLICKBUSTER_THRESHOLD && Math.abs(y1 - y2) < CLICKBUSTER_THRESHOLD;
    }
  
    // Checks a list of allowable regions against a click location.
    // Returns true if the click should be allowed.
    // Splices out the allowable region from the list after it has been used.
    function checkAllowableRegions(touchCoordinates, x, y) {
      for (var i = 0; i < touchCoordinates.length; i += 2) {
        if (hit(touchCoordinates[i], touchCoordinates[i+1], x, y)) {
          touchCoordinates.splice(i, i + 2);
          return true; // allowable region
        }
      }
      return false; // No allowable region; bust it.
    }
  
    // Global click handler that prevents the click if it's in a bustable zone and preventGhostClick
    // was called recently.
    function onClick(event) {
      if (Date.now() - lastPreventedTime > PREVENT_DURATION) {
        return; // Too old.
      }
  
      var touches = event.touches && event.touches.length ? event.touches : [event];
      var x = touches[0].clientX;
      var y = touches[0].clientY;
      // Work around desktop Webkit quirk where clicking a label will fire two clicks (on the label
      // and on the input element). Depending on the exact browser, this second click we don't want
      // to bust has either (0,0) or negative coordinates.
      if (x < 1 && y < 1) {
        return; // offscreen
      }
  
      // Look for an allowable region containing this click.
      // If we find one, that means it was created by touchstart and not removed by
      // preventGhostClick, so we don't bust it.
      if (checkAllowableRegions(touchCoordinates, x, y)) {
        return;
      }
  
      // If we didn't find an allowable region, bust the click.
      event.stopPropagation();
      event.preventDefault();
  
      // Blur focused form elements
      event.target && event.target.blur();
    }
  
  
    // Global touchstart handler that creates an allowable region for a click event.
    // This allowable region can be removed by preventGhostClick if we want to bust it.
    function onTouchStart(event) {
      var touches = event.touches && event.touches.length ? event.touches : [event];
      var x = touches[0].clientX;
      var y = touches[0].clientY;
      touchCoordinates.push(x, y);
  
      $timeout(function() {
        // Remove the allowable region.
        for (var i = 0; i < touchCoordinates.length; i += 2) {
          if (touchCoordinates[i] == x && touchCoordinates[i+1] == y) {
            touchCoordinates.splice(i, i + 2);
            return;
          }
        }
      }, PREVENT_DURATION, false);
    }
  
    // On the first call, attaches some event handlers. Then whenever it gets called, it creates a
    // zone around the touchstart where clicks will get busted.
    function preventGhostClick(x, y) {
      if (!touchCoordinates) {
        $rootElement[0].addEventListener('click', onClick, true);
        $rootElement[0].addEventListener('touchstart', onTouchStart, true);
        touchCoordinates = [];
      }
  
      lastPreventedTime = Date.now();
  
      checkAllowableRegions(touchCoordinates, x, y);
    }
  
    // Actual linking function.
    return function(scope, element, attr) {
      var clickHandler = $parse(attr.ngClick),
          tapping = false,
          tapElement,  // Used to blur the element after a tap.
          startTime,   // Used to check if the tap was held too long.
          touchStartX,
          touchStartY;
  
      function resetState() {
        tapping = false;
        element.removeClass(ACTIVE_CLASS_NAME);
      }
  
      element.on('touchstart', function(event) {
        tapping = true;
        tapElement = event.target ? event.target : event.srcElement; // IE uses srcElement.
        // Hack for Safari, which can target text nodes instead of containers.
        if(tapElement.nodeType == 3) {
          tapElement = tapElement.parentNode;
        }
  
        element.addClass(ACTIVE_CLASS_NAME);
  
        startTime = Date.now();
  
        var touches = event.touches && event.touches.length ? event.touches : [event];
        var e = touches[0].originalEvent || touches[0];
        touchStartX = e.clientX;
        touchStartY = e.clientY;
      });
  
      element.on('touchmove', function(event) {
        resetState();
      });
  
      element.on('touchcancel', function(event) {
        resetState();
      });
  
      element.on('touchend', function(event) {
        var diff = Date.now() - startTime;
  
        var touches = (event.changedTouches && event.changedTouches.length) ? event.changedTouches :
            ((event.touches && event.touches.length) ? event.touches : [event]);
        var e = touches[0].originalEvent || touches[0];
        var x = e.clientX;
        var y = e.clientY;
        var dist = Math.sqrt( Math.pow(x - touchStartX, 2) + Math.pow(y - touchStartY, 2) );
  
        if (tapping && diff < TAP_DURATION && dist < MOVE_TOLERANCE) {
          // Call preventGhostClick so the clickbuster will catch the corresponding click.
          preventGhostClick(x, y);
  
          // Blur the focused element (the button, probably) before firing the callback.
          // This doesn't work perfectly on Android Chrome, but seems to work elsewhere.
          // I couldn't get anything to work reliably on Android Chrome.
          if (tapElement) {
            tapElement.blur();
          }
  
          if (!angular.isDefined(attr.disabled) || attr.disabled === false) {
            element.triggerHandler('click', [event]);
          }
        }
  
        resetState();
      });
  
      // Hack for iOS Safari's benefit. It goes searching for onclick handlers and is liable to click
      // something else nearby.
      element.onclick = function(event) { };
  
      // Actual click handler.
      // There are three different kinds of clicks, only two of which reach this point.
      // - On desktop browsers without touch events, their clicks will always come here.
      // - On mobile browsers, the simulated "fast" click will call this.
      // - But the browser's follow-up slow click will be "busted" before it reaches this handler.
      // Therefore it's safe to use this directive on both mobile and desktop.
      element.on('click', function(event, touchend) {
        scope.$apply(function() {
          clickHandler(scope, {$event: (touchend || event)});
        });
      });
  
      element.on('mousedown', function(event) {
        element.addClass(ACTIVE_CLASS_NAME);
      });
  
      element.on('mousemove mouseup', function(event) {
        element.removeClass(ACTIVE_CLASS_NAME);
      });
  
    };
  }]);
  
  /* global ngTouch: false */
  
  /**
   * @ngdoc directive
   * @name ngTouch.directive:ngSwipeLeft
   *
   * @description
   * Specify custom behavior when an element is swiped to the left on a touchscreen device.
   * A leftward swipe is a quick, right-to-left slide of the finger.
   * Though ngSwipeLeft is designed for touch-based devices, it will work with a mouse click and drag
   * too.
   *
   * Requires the {@link ngTouch `ngTouch`} module to be installed.
   *
   * @element ANY
   * @param {expression} ngSwipeLeft {@link guide/expression Expression} to evaluate
   * upon left swipe. (Event object is available as `$event`)
   *
   * @example
      <doc:example>
        <doc:source>
          <div ng-show="!showActions" ng-swipe-left="showActions = true">
            Some list content, like an email in the inbox
          </div>
          <div ng-show="showActions" ng-swipe-right="showActions = false">
            <button ng-click="reply()">Reply</button>
            <button ng-click="delete()">Delete</button>
          </div>
        </doc:source>
      </doc:example>
   */
  
  /**
   * @ngdoc directive
   * @name ngTouch.directive:ngSwipeRight
   *
   * @description
   * Specify custom behavior when an element is swiped to the right on a touchscreen device.
   * A rightward swipe is a quick, left-to-right slide of the finger.
   * Though ngSwipeRight is designed for touch-based devices, it will work with a mouse click and drag
   * too.
   *
   * Requires the {@link ngTouch `ngTouch`} module to be installed.
   *
   * @element ANY
   * @param {expression} ngSwipeRight {@link guide/expression Expression} to evaluate
   * upon right swipe. (Event object is available as `$event`)
   *
   * @example
      <doc:example>
        <doc:source>
          <div ng-show="!showActions" ng-swipe-left="showActions = true">
            Some list content, like an email in the inbox
          </div>
          <div ng-show="showActions" ng-swipe-right="showActions = false">
            <button ng-click="reply()">Reply</button>
            <button ng-click="delete()">Delete</button>
          </div>
        </doc:source>
      </doc:example>
   */
  
  function makeSwipeDirective(directiveName, direction, eventName) {
    ngTouch.directive(directiveName, ['$parse', '$swipe', function($parse, $swipe) {
      // The maximum vertical delta for a swipe should be less than 75px.
      var MAX_VERTICAL_DISTANCE = 75;
      // Vertical distance should not be more than a fraction of the horizontal distance.
      var MAX_VERTICAL_RATIO = 0.3;
      // At least a 30px lateral motion is necessary for a swipe.
      var MIN_HORIZONTAL_DISTANCE = 30;
  
      return function(scope, element, attr) {
        var swipeHandler = $parse(attr[directiveName]);
  
        var startCoords, valid;
  
        function validSwipe(coords) {
          // Check that it's within the coordinates.
          // Absolute vertical distance must be within tolerances.
          // Horizontal distance, we take the current X - the starting X.
          // This is negative for leftward swipes and positive for rightward swipes.
          // After multiplying by the direction (-1 for left, +1 for right), legal swipes
          // (ie. same direction as the directive wants) will have a positive delta and
          // illegal ones a negative delta.
          // Therefore this delta must be positive, and larger than the minimum.
          if (!startCoords) return false;
          var deltaY = Math.abs(coords.y - startCoords.y);
          var deltaX = (coords.x - startCoords.x) * direction;
          return valid && // Short circuit for already-invalidated swipes.
              deltaY < MAX_VERTICAL_DISTANCE &&
              deltaX > 0 &&
              deltaX > MIN_HORIZONTAL_DISTANCE &&
              deltaY / deltaX < MAX_VERTICAL_RATIO;
        }
  
        $swipe.bind(element, {
          'start': function(coords, event) {
            startCoords = coords;
            valid = true;
          },
          'cancel': function(event) {
            valid = false;
          },
          'end': function(coords, event) {
            if (validSwipe(coords)) {
              scope.$apply(function() {
                element.triggerHandler(eventName);
                swipeHandler(scope, {$event: event});
              });
            }
          }
        });
      };
    }]);
  }
  
  // Left is negative X-coordinate, right is positive.
  makeSwipeDirective('ngSwipeLeft', -1, 'swipeleft');
  makeSwipeDirective('ngSwipeRight', 1, 'swiperight');
  
  
  
  })(window, window.angular);
  