text: /**
   * ion-events.js
   *
   * Author: Max Lynch <max@drifty.com>
   *
   * Framework events handles various mobile browser events, and
   * detects special events like tap/swipe/etc. and emits them
   * as custom events that can be used in an app.
   *
   * Portions lovingly adapted from github.com/maker/ratchet and github.com/alexgibson/tap.js - thanks guys!
   */
  
  (function(ionic) {
  
    // Custom event polyfill
    ionic.CustomEvent = (function() {
      if( typeof window.CustomEvent === 'function' ) return CustomEvent;
  
      var customEvent = function(event, params) {
        var evt;
        params = params || {
          bubbles: false,
          cancelable: false,
          detail: undefined
        };
        try {
          evt = document.createEvent("CustomEvent");
          evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
        } catch (error) {
          // fallback for browsers that don't support createEvent('CustomEvent')
          evt = document.createEvent("Event");
          for (var param in params) {
            evt[param] = params[param];
          }
          evt.initEvent(event, params.bubbles, params.cancelable);
        }
        return evt;
      };
      customEvent.prototype = window.Event.prototype;
      return customEvent;
    })();
  
  
    /**
     * @ngdoc utility
     * @name ionic.EventController
     * @module ionic
     */
    ionic.EventController = {
      VIRTUALIZED_EVENTS: ['tap', 'swipe', 'swiperight', 'swipeleft', 'drag', 'hold', 'release'],
  
      /**
       * @ngdoc method
       * @name ionic.EventController#trigger
       * @alias ionic.trigger
       * @param {string} eventType The event to trigger.
       * @param {object} data The data for the event. Hint: pass in
       * `{target: targetElement}`
       * @param {boolean=} bubbles Whether the event should bubble up the DOM.
       * @param {boolean=} cancelable Whether the event should be cancelable.
       */
      // Trigger a new event
      trigger: function(eventType, data, bubbles, cancelable) {
        var event = new ionic.CustomEvent(eventType, {
          detail: data,
          bubbles: !!bubbles,
          cancelable: !!cancelable
        });
  
        // Make sure to trigger the event on the given target, or dispatch it from
        // the window if we don't have an event target
        data && data.target && data.target.dispatchEvent && data.target.dispatchEvent(event) || window.dispatchEvent(event);
      },
  
      /**
       * @ngdoc method
       * @name ionic.EventController#on
       * @alias ionic.on
       * @description Listen to an event on an element.
       * @param {string} type The event to listen for.
       * @param {function} callback The listener to be called.
       * @param {DOMElement} element The element to listen for the event on.
       */
      on: function(type, callback, element) {
        var e = element || window;
  
        // Bind a gesture if it's a virtual event
        for(var i = 0, j = this.VIRTUALIZED_EVENTS.length; i < j; i++) {
          if(type == this.VIRTUALIZED_EVENTS[i]) {
            var gesture = new ionic.Gesture(element);
            gesture.on(type, callback);
            return gesture;
          }
        }
  
        // Otherwise bind a normal event
        e.addEventListener(type, callback);
      },
  
      /**
       * @ngdoc method
       * @name ionic.EventController#off
       * @alias ionic.off
       * @description Remove an event listener.
       * @param {string} type
       * @param {function} callback
       * @param {DOMElement} element
       */
      off: function(type, callback, element) {
        element.removeEventListener(type, callback);
      },
  
      /**
       * @ngdoc method
       * @name ionic.EventController#onGesture
       * @alias ionic.onGesture
       * @description Add an event listener for a gesture on an element.
       *
       * Available eventTypes (from [hammer.js](http://eightmedia.github.io/hammer.js/)):
       *
       * `hold`, `tap`, `doubletap`, `drag`, `dragstart`, `dragend`, `dragup`, `dragdown`, <br/>
       * `dragleft`, `dragright`, `swipe`, `swipeup`, `swipedown`, `swipeleft`, `swiperight`, <br/>
       * `transform`, `transformstart`, `transformend`, `rotate`, `pinch`, `pinchin`, `pinchout`, </br>
       * `touch`, `release`
       *
       * @param {string} eventType The gesture event to listen for.
       * @param {function(e)} callback The function to call when the gesture
       * happens.
       * @param {DOMElement} element The angular element to listen for the event on.
       */
      onGesture: function(type, callback, element) {
        var gesture = new ionic.Gesture(element);
        gesture.on(type, callback);
        return gesture;
      },
  
      /**
       * @ngdoc method
       * @name ionic.EventController#offGesture
       * @alias ionic.offGesture
       * @description Remove an event listener for a gesture on an element.
       * @param {string} eventType The gesture event.
       * @param {function(e)} callback The listener that was added earlier.
       * @param {DOMElement} element The element the listener was added on.
       */
      offGesture: function(gesture, type, callback) {
        gesture.off(type, callback);
      },
  
      handlePopState: function(event) {}
    };
  
  
    // Map some convenient top-level functions for event handling
    ionic.on = function() { ionic.EventController.on.apply(ionic.EventController, arguments); };
    ionic.off = function() { ionic.EventController.off.apply(ionic.EventController, arguments); };
    ionic.trigger = ionic.EventController.trigger;//function() { ionic.EventController.trigger.apply(ionic.EventController.trigger, arguments); };
    ionic.onGesture = function() { return ionic.EventController.onGesture.apply(ionic.EventController.onGesture, arguments); };
    ionic.offGesture = function() { return ionic.EventController.offGesture.apply(ionic.EventController.offGesture, arguments); };
  
  })(window.ionic);
  