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