FM / js

/home/desid573/public_html/magicride.ng/wp-includes/js/

/home/desid573/public_html/magicride.ng/wp-includes/js

Name	Size	Mode	Actions
codemirror/	-	0755	rm
crop/	-	0755	rm
dist/	-	0755	rm
imgareaselect/	-	0755	rm
jcrop/	-	0755	rm
jquery/	-	0755	rm
mediaelement/	-	0755	rm
plupload/	-	0755	rm
swfupload/	-	0755	rm
thickbox/	-	0755	rm
tinymce/	-	0755	rm
admin-bar.js	15589	0644	edit dl rm
admin-bar.min.js	7169	0644	edit dl rm
api-request.js	2659	0644	edit dl rm
api-request.min.js	768	0644	edit dl rm
autosave.js	21338	0644	edit dl rm
autosave.min.js	5404	0644	edit dl rm
backbone.js	72236	0644	edit dl rm
backbone.min.js	22234	0644	edit dl rm
clipboard.js	29276	0644	edit dl rm
clipboard.min.js	10489	0644	edit dl rm
colorpicker.js	29083	0644	edit dl rm
colorpicker.min.js	16527	0644	edit dl rm
comment-reply.js	10076	0644	edit dl rm
comment-reply.min.js	2160	0644	edit dl rm
customize-base.js	25686	0644	edit dl rm
customize-base.min.js	7821	0644	edit dl rm
customize-loader.js	7900	0644	edit dl rm
customize-loader.min.js	3518	0644	edit dl rm
customize-models.js	6816	0644	edit dl rm
customize-models.min.js	3658	0644	edit dl rm
customize-preview-nav-menus.js	15026	0644	edit dl rm
customize-preview-nav-menus.min.js	5003	0644	edit dl rm
customize-preview-widgets.js	23149	0644	edit dl rm
customize-preview-widgets.min.js	7789	0644	edit dl rm
customize-preview.js	27969	0644	edit dl rm
customize-preview.min.js	10723	0644	edit dl rm
customize-selective-refresh.js	33326	0644	edit dl rm
customize-selective-refresh.min.js	10658	0644	edit dl rm
customize-views.js	5065	0644	edit dl rm
customize-views.min.js	2416	0644	edit dl rm
heartbeat.js	23163	0644	edit dl rm
heartbeat.min.js	5848	0644	edit dl rm
hoverIntent.js	4950	0644	edit dl rm
hoverIntent.min.js	1087	0644	edit dl rm
imagesloaded.min.js	8113	0644	edit dl rm
json2.js	18422	0644	edit dl rm
json2.min.js	3118	0644	edit dl rm
masonry.min.js	28953	0644	edit dl rm
mce-view.js	25768	0644	edit dl rm
mce-view.min.js	9676	0644	edit dl rm
media-audiovideo.js	27548	0644	edit dl rm
media-audiovideo.min.js	12877	0644	edit dl rm
media-editor.js	28933	0644	edit dl rm
media-editor.min.js	10821	0644	edit dl rm
media-grid.js	29183	0644	edit dl rm
media-grid.min.js	14173	0644	edit dl rm
media-models.js	45427	0644	edit dl rm
media-models.min.js	13886	0644	edit dl rm
media-views.js	252243	0644	edit dl rm
media-views.min.js	101980	0644	edit dl rm
quicktags.js	22582	0644	edit dl rm
quicktags.min.js	11114	0644	edit dl rm
shortcode.js	10569	0644	edit dl rm
shortcode.min.js	2578	0644	edit dl rm
swfobject.js	10231	0644	edit dl rm
tw-sack.js	4969	0644	edit dl rm
tw-sack.min.js	3264	0644	edit dl rm
twemoji.js	27617	0644	edit dl rm
twemoji.min.js	10877	0644	edit dl rm
underscore.js	52919	0644	edit dl rm
underscore.min.js	16010	0644	edit dl rm
utils.js	4657	0644	edit dl rm
utils.min.js	1829	0644	edit dl rm
wp-a11y.js	2652	0644	edit dl rm
wp-a11y.min.js	640	0644	edit dl rm
wp-ajax-response.js	3201	0644	edit dl rm
wp-ajax-response.min.js	2057	0644	edit dl rm
wp-api.js	46749	0644	edit dl rm
wp-api.min.js	14535	0644	edit dl rm
wp-auth-check.js	4373	0644	edit dl rm
wp-auth-check.min.js	1776	0644	edit dl rm
wp-backbone.js	15242	0644	edit dl rm
wp-backbone.min.js	3002	0644	edit dl rm
wp-custom-header.js	10447	0644	edit dl rm
wp-custom-header.min.js	4407	0644	edit dl rm
wp-embed-template.js	6245	0644	edit dl rm
wp-embed-template.min.js	3059	0644	edit dl rm
wp-embed.js	3414	0644	edit dl rm
wp-embed.min.js	1443	0644	edit dl rm
wp-emoji-loader.js	6110	0644	edit dl rm
wp-emoji-loader.min.js	1832	0644	edit dl rm
wp-emoji-release.min.js	13757	0644	edit dl rm
wp-emoji.js	8914	0644	edit dl rm
wp-emoji.min.js	2796	0644	edit dl rm
wp-list-revisions.js	970	0644	edit dl rm
wp-list-revisions.min.js	562	0644	edit dl rm
wp-lists.js	25282	0644	edit dl rm
wp-lists.min.js	7371	0644	edit dl rm
wp-pointer.js	10309	0644	edit dl rm
wp-pointer.min.js	3617	0644	edit dl rm
wp-sanitize.js	1350	0644	edit dl rm
wp-sanitize.min.js	423	0644	edit dl rm
wp-util.js	3968	0644	edit dl rm
wp-util.min.js	1042	0644	edit dl rm
wpdialog.js	560	0644	edit dl rm
wpdialog.min.js	237	0644	edit dl rm
wplink.js	20960	0644	edit dl rm
wplink.min.js	11142	0644	edit dl rm
zxcvbn-async.js	821	0644	edit dl rm
zxcvbn-async.min.js	316	0644	edit dl rm
zxcvbn.min.js	822202	0644	edit dl rm

Edit: /home/desid573/public_html/magicride.ng/wp-includes/js/clipboard.js (29276B)

/*!
 * clipboard.js v2.0.4
 * https://zenorocha.github.io/clipboard.js
 * 
 * Licensed MIT © Zeno Rocha
 */
(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define([], factory);
	else if(typeof exports === 'object')
		exports["ClipboardJS"] = factory();
	else
		root["ClipboardJS"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _clipboardAction = __webpack_require__(1);

var _clipboardAction2 = _interopRequireDefault(_clipboardAction);

var _tinyEmitter = __webpack_require__(3);

var _tinyEmitter2 = _interopRequireDefault(_tinyEmitter);

var _goodListener = __webpack_require__(4);

var _goodListener2 = _interopRequireDefault(_goodListener);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

/**
 * Base class which takes one or more elements, adds event listeners to them,
 * and instantiates a new `ClipboardAction` on each click.
 */
var Clipboard = function (_Emitter) {
    _inherits(Clipboard, _Emitter);

/**
     * @param {String|HTMLElement|HTMLCollection|NodeList} trigger
     * @param {Object} options
     */
    function Clipboard(trigger, options) {
        _classCallCheck(this, Clipboard);

var _this = _possibleConstructorReturn(this, (Clipboard.__proto__ || Object.getPrototypeOf(Clipboard)).call(this));

_this.resolveOptions(options);
        _this.listenClick(trigger);
        return _this;
    }

/**
     * Defines if attributes would be resolved using internal setter functions
     * or custom functions that were passed in the constructor.
     * @param {Object} options
     */

_createClass(Clipboard, [{
        key: 'resolveOptions',
        value: function resolveOptions() {
            var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

this.action = typeof options.action === 'function' ? options.action : this.defaultAction;
            this.target = typeof options.target === 'function' ? options.target : this.defaultTarget;
            this.text = typeof options.text === 'function' ? options.text : this.defaultText;
            this.container = _typeof(options.container) === 'object' ? options.container : document.body;
        }

/**
         * Adds a click event listener to the passed trigger.
         * @param {String|HTMLElement|HTMLCollection|NodeList} trigger
         */

}, {
        key: 'listenClick',
        value: function listenClick(trigger) {
            var _this2 = this;

this.listener = (0, _goodListener2.default)(trigger, 'click', function (e) {
                return _this2.onClick(e);
            });
        }

/**
         * Defines a new `ClipboardAction` on each click event.
         * @param {Event} e
         */

}, {
        key: 'onClick',
        value: function onClick(e) {
            var trigger = e.delegateTarget || e.currentTarget;

if (this.clipboardAction) {
                this.clipboardAction = null;
            }

this.clipboardAction = new _clipboardAction2.default({
                action: this.action(trigger),
                target: this.target(trigger),
                text: this.text(trigger),
                container: this.container,
                trigger: trigger,
                emitter: this
            });
        }

/**
         * Default `action` lookup function.
         * @param {Element} trigger
         */

}, {
        key: 'defaultAction',
        value: function defaultAction(trigger) {
            return getAttributeValue('action', trigger);
        }

/**
         * Default `target` lookup function.
         * @param {Element} trigger
         */

}, {
        key: 'defaultTarget',
        value: function defaultTarget(trigger) {
            var selector = getAttributeValue('target', trigger);

if (selector) {
                return document.querySelector(selector);
            }
        }

/**
         * Returns the support of the given action, or all actions if no action is
         * given.
         * @param {String} [action]
         */

}, {
        key: 'defaultText',

/**
         * Default `text` lookup function.
         * @param {Element} trigger
         */
        value: function defaultText(trigger) {
            return getAttributeValue('text', trigger);
        }

/**
         * Destroy lifecycle.
         */

}, {
        key: 'destroy',
        value: function destroy() {
            this.listener.destroy();

if (this.clipboardAction) {
                this.clipboardAction.destroy();
                this.clipboardAction = null;
            }
        }
    }], [{
        key: 'isSupported',
        value: function isSupported() {
            var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['copy', 'cut'];

var actions = typeof action === 'string' ? [action] : action;
            var support = !!document.queryCommandSupported;

actions.forEach(function (action) {
                support = support && !!document.queryCommandSupported(action);
            });

return support;
        }
    }]);

return Clipboard;
}(_tinyEmitter2.default);

/**
 * Helper function to retrieve attribute value.
 * @param {String} suffix
 * @param {Element} element
 */

function getAttributeValue(suffix, element) {
    var attribute = 'data-clipboard-' + suffix;

if (!element.hasAttribute(attribute)) {
        return;
    }

return element.getAttribute(attribute);
}

module.exports = Clipboard;

/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var _select = __webpack_require__(2);

var _select2 = _interopRequireDefault(_select);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Inner class which performs selection from either `text` or `target`
 * properties and then executes copy or cut operations.
 */
var ClipboardAction = function () {
    /**
     * @param {Object} options
     */
    function ClipboardAction(options) {
        _classCallCheck(this, ClipboardAction);

this.resolveOptions(options);
        this.initSelection();
    }

/**
     * Defines base properties passed from constructor.
     * @param {Object} options
     */

_createClass(ClipboardAction, [{
        key: 'resolveOptions',
        value: function resolveOptions() {
            var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

this.action = options.action;
            this.container = options.container;
            this.emitter = options.emitter;
            this.target = options.target;
            this.text = options.text;
            this.trigger = options.trigger;

this.selectedText = '';
        }

/**
         * Decides which selection strategy is going to be applied based
         * on the existence of `text` and `target` properties.
         */

}, {
        key: 'initSelection',
        value: function initSelection() {
            if (this.text) {
                this.selectFake();
            } else if (this.target) {
                this.selectTarget();
            }
        }

/**
         * Creates a fake textarea element, sets its value from `text` property,
         * and makes a selection on it.
         */

}, {
        key: 'selectFake',
        value: function selectFake() {
            var _this = this;

var isRTL = document.documentElement.getAttribute('dir') == 'rtl';

this.removeFake();

this.fakeHandlerCallback = function () {
                return _this.removeFake();
            };
            this.fakeHandler = this.container.addEventListener('click', this.fakeHandlerCallback) || true;

this.fakeElem = document.createElement('textarea');
            // Prevent zooming on iOS
            this.fakeElem.style.fontSize = '12pt';
            // Reset box model
            this.fakeElem.style.border = '0';
            this.fakeElem.style.padding = '0';
            this.fakeElem.style.margin = '0';
            // Move element out of screen horizontally
            this.fakeElem.style.position = 'absolute';
            this.fakeElem.style[isRTL ? 'right' : 'left'] = '-9999px';
            // Move element to the same position vertically
            var yPosition = window.pageYOffset || document.documentElement.scrollTop;
            this.fakeElem.style.top = yPosition + 'px';

this.fakeElem.setAttribute('readonly', '');
            this.fakeElem.value = this.text;

this.container.appendChild(this.fakeElem);

this.selectedText = (0, _select2.default)(this.fakeElem);
            this.copyText();
        }

/**
         * Only removes the fake element after another click event, that way
         * a user can hit `Ctrl+C` to copy because selection still exists.
         */

}, {
        key: 'removeFake',
        value: function removeFake() {
            if (this.fakeHandler) {
                this.container.removeEventListener('click', this.fakeHandlerCallback);
                this.fakeHandler = null;
                this.fakeHandlerCallback = null;
            }

if (this.fakeElem) {
                this.container.removeChild(this.fakeElem);
                this.fakeElem = null;
            }
        }

/**
         * Selects the content from element passed on `target` property.
         */

}, {
        key: 'selectTarget',
        value: function selectTarget() {
            this.selectedText = (0, _select2.default)(this.target);
            this.copyText();
        }

/**
         * Executes the copy operation based on the current selection.
         */

}, {
        key: 'copyText',
        value: function copyText() {
            var succeeded = void 0;

try {
                succeeded = document.execCommand(this.action);
            } catch (err) {
                succeeded = false;
            }

this.handleResult(succeeded);
        }

/**
         * Fires an event based on the copy operation result.
         * @param {Boolean} succeeded
         */

}, {
        key: 'handleResult',
        value: function handleResult(succeeded) {
            this.emitter.emit(succeeded ? 'success' : 'error', {
                action: this.action,
                text: this.selectedText,
                trigger: this.trigger,
                clearSelection: this.clearSelection.bind(this)
            });
        }

/**
         * Moves focus away from `target` and back to the trigger, removes current selection.
         */

}, {
        key: 'clearSelection',
        value: function clearSelection() {
            if (this.trigger) {
                this.trigger.focus();
            }

window.getSelection().removeAllRanges();
        }

/**
         * Sets the `action` to be performed which can be either 'copy' or 'cut'.
         * @param {String} action
         */

}, {
        key: 'destroy',

/**
         * Destroy lifecycle.
         */
        value: function destroy() {
            this.removeFake();
        }
    }, {
        key: 'action',
        set: function set() {
            var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'copy';

this._action = action;

if (this._action !== 'copy' && this._action !== 'cut') {
                throw new Error('Invalid "action" value, use either "copy" or "cut"');
            }
        }

/**
         * Gets the `action` property.
         * @return {String}
         */
        ,
        get: function get() {
            return this._action;
        }

/**
         * Sets the `target` property using an element
         * that will be have its content copied.
         * @param {Element} target
         */

}, {
        key: 'target',
        set: function set(target) {
            if (target !== undefined) {
                if (target && (typeof target === 'undefined' ? 'undefined' : _typeof(target)) === 'object' && target.nodeType === 1) {
                    if (this.action === 'copy' && target.hasAttribute('disabled')) {
                        throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');
                    }

if (this.action === 'cut' && (target.hasAttribute('readonly') || target.hasAttribute('disabled'))) {
                        throw new Error('Invalid "target" attribute. You can\'t cut text from elements with "readonly" or "disabled" attributes');
                    }

this._target = target;
                } else {
                    throw new Error('Invalid "target" value, use a valid Element');
                }
            }
        }

/**
         * Gets the `target` property.
         * @return {String|HTMLElement}
         */
        ,
        get: function get() {
            return this._target;
        }
    }]);

return ClipboardAction;
}();

module.exports = ClipboardAction;

/***/ }),
/* 2 */
/***/ (function(module, exports) {

function select(element) {
    var selectedText;

if (element.nodeName === 'SELECT') {
        element.focus();

selectedText = element.value;
    }
    else if (element.nodeName === 'INPUT' || element.nodeName === 'TEXTAREA') {
        var isReadOnly = element.hasAttribute('readonly');

if (!isReadOnly) {
            element.setAttribute('readonly', '');
        }

element.select();
        element.setSelectionRange(0, element.value.length);

if (!isReadOnly) {
            element.removeAttribute('readonly');
        }

selectedText = element.value;
    }
    else {
        if (element.hasAttribute('contenteditable')) {
            element.focus();
        }

var selection = window.getSelection();
        var range = document.createRange();

range.selectNodeContents(element);
        selection.removeAllRanges();
        selection.addRange(range);

selectedText = selection.toString();
    }

return selectedText;
}

module.exports = select;

/***/ }),
/* 3 */
/***/ (function(module, exports) {

function E () {
  // Keep this empty so it's easier to inherit from
  // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
}

E.prototype = {
  on: function (name, callback, ctx) {
    var e = this.e || (this.e = {});

(e[name] || (e[name] = [])).push({
      fn: callback,
      ctx: ctx
    });

return this;
  },

once: function (name, callback, ctx) {
    var self = this;
    function listener () {
      self.off(name, listener);
      callback.apply(ctx, arguments);
    };

listener._ = callback
    return this.on(name, listener, ctx);
  },

emit: function (name) {
    var data = [].slice.call(arguments, 1);
    var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
    var i = 0;
    var len = evtArr.length;

for (i; i < len; i++) {
      evtArr[i].fn.apply(evtArr[i].ctx, data);
    }

return this;
  },

off: function (name, callback) {
    var e = this.e || (this.e = {});
    var evts = e[name];
    var liveEvents = [];

if (evts && callback) {
      for (var i = 0, len = evts.length; i < len; i++) {
        if (evts[i].fn !== callback && evts[i].fn._ !== callback)
          liveEvents.push(evts[i]);
      }
    }

// Remove event from queue to prevent memory leak
    // Suggested by https://github.com/lazd
    // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910

(liveEvents.length)
      ? e[name] = liveEvents
      : delete e[name];

return this;
  }
};

module.exports = E;

/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

var is = __webpack_require__(5);
var delegate = __webpack_require__(6);

/**
 * Validates all params and calls the right
 * listener function based on its target type.
 *
 * @param {String|HTMLElement|HTMLCollection|NodeList} target
 * @param {String} type
 * @param {Function} callback
 * @return {Object}
 */
function listen(target, type, callback) {
    if (!target && !type && !callback) {
        throw new Error('Missing required arguments');
    }

if (!is.string(type)) {
        throw new TypeError('Second argument must be a String');
    }

if (!is.fn(callback)) {
        throw new TypeError('Third argument must be a Function');
    }

if (is.node(target)) {
        return listenNode(target, type, callback);
    }
    else if (is.nodeList(target)) {
        return listenNodeList(target, type, callback);
    }
    else if (is.string(target)) {
        return listenSelector(target, type, callback);
    }
    else {
        throw new TypeError('First argument must be a String, HTMLElement, HTMLCollection, or NodeList');
    }
}

/**
 * Adds an event listener to a HTML element
 * and returns a remove listener function.
 *
 * @param {HTMLElement} node
 * @param {String} type
 * @param {Function} callback
 * @return {Object}
 */
function listenNode(node, type, callback) {
    node.addEventListener(type, callback);

return {
        destroy: function() {
            node.removeEventListener(type, callback);
        }
    }
}

/**
 * Add an event listener to a list of HTML elements
 * and returns a remove listener function.
 *
 * @param {NodeList|HTMLCollection} nodeList
 * @param {String} type
 * @param {Function} callback
 * @return {Object}
 */
function listenNodeList(nodeList, type, callback) {
    Array.prototype.forEach.call(nodeList, function(node) {
        node.addEventListener(type, callback);
    });

return {
        destroy: function() {
            Array.prototype.forEach.call(nodeList, function(node) {
                node.removeEventListener(type, callback);
            });
        }
    }
}

/**
 * Add an event listener to a selector
 * and returns a remove listener function.
 *
 * @param {String} selector
 * @param {String} type
 * @param {Function} callback
 * @return {Object}
 */
function listenSelector(selector, type, callback) {
    return delegate(document.body, selector, type, callback);
}

module.exports = listen;

/***/ }),
/* 5 */
/***/ (function(module, exports) {

/**
 * Check if argument is a HTML element.
 *
 * @param {Object} value
 * @return {Boolean}
 */
exports.node = function(value) {
    return value !== undefined
        && value instanceof HTMLElement
        && value.nodeType === 1;
};

/**
 * Check if argument is a list of HTML elements.
 *
 * @param {Object} value
 * @return {Boolean}
 */
exports.nodeList = function(value) {
    var type = Object.prototype.toString.call(value);

return value !== undefined
        && (type === '[object NodeList]' || type === '[object HTMLCollection]')
        && ('length' in value)
        && (value.length === 0 || exports.node(value[0]));
};

/**
 * Check if argument is a string.
 *
 * @param {Object} value
 * @return {Boolean}
 */
exports.string = function(value) {
    return typeof value === 'string'
        || value instanceof String;
};

/**
 * Check if argument is a function.
 *
 * @param {Object} value
 * @return {Boolean}
 */
exports.fn = function(value) {
    var type = Object.prototype.toString.call(value);

return type === '[object Function]';
};

/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {

var closest = __webpack_require__(7);

/**
 * Delegates event to a selector.
 *
 * @param {Element} element
 * @param {String} selector
 * @param {String} type
 * @param {Function} callback
 * @param {Boolean} useCapture
 * @return {Object}
 */
function _delegate(element, selector, type, callback, useCapture) {
    var listenerFn = listener.apply(this, arguments);

element.addEventListener(type, listenerFn, useCapture);

return {
        destroy: function() {
            element.removeEventListener(type, listenerFn, useCapture);
        }
    }
}

/**
 * Delegates event to a selector.
 *
 * @param {Element|String|Array} [elements]
 * @param {String} selector
 * @param {String} type
 * @param {Function} callback
 * @param {Boolean} useCapture
 * @return {Object}
 */
function delegate(elements, selector, type, callback, useCapture) {
    // Handle the regular Element usage
    if (typeof elements.addEventListener === 'function') {
        return _delegate.apply(null, arguments);
    }

// Handle Element-less usage, it defaults to global delegation
    if (typeof type === 'function') {
        // Use `document` as the first parameter, then apply arguments
        // This is a short way to .unshift `arguments` without running into deoptimizations
        return _delegate.bind(null, document).apply(null, arguments);
    }

// Handle Selector-based usage
    if (typeof elements === 'string') {
        elements = document.querySelectorAll(elements);
    }

// Handle Array-like based usage
    return Array.prototype.map.call(elements, function (element) {
        return _delegate(element, selector, type, callback, useCapture);
    });
}

/**
 * Finds closest match and invokes callback.
 *
 * @param {Element} element
 * @param {String} selector
 * @param {String} type
 * @param {Function} callback
 * @return {Function}
 */
function listener(element, selector, type, callback) {
    return function(e) {
        e.delegateTarget = closest(e.target, selector);

if (e.delegateTarget) {
            callback.call(element, e);
        }
    }
}

module.exports = delegate;

/***/ }),
/* 7 */
/***/ (function(module, exports) {

var DOCUMENT_NODE_TYPE = 9;

/**
 * A polyfill for Element.matches()
 */
if (typeof Element !== 'undefined' && !Element.prototype.matches) {
    var proto = Element.prototype;

proto.matches = proto.matchesSelector ||
                    proto.mozMatchesSelector ||
                    proto.msMatchesSelector ||
                    proto.oMatchesSelector ||
                    proto.webkitMatchesSelector;
}

/**
 * Finds the closest parent that matches a selector.
 *
 * @param {Element} element
 * @param {String} selector
 * @return {Function}
 */
function closest (element, selector) {
    while (element && element.nodeType !== DOCUMENT_NODE_TYPE) {
        if (typeof element.matches === 'function' &&
            element.matches(selector)) {
          return element;
        }
        element = element.parentNode;
    }
}

module.exports = closest;

/***/ })
/******/ ]);
});

cmd: