Merge branch 'mtanda-clipboard_js'

bower.json

@@ -20,6 +20,7 @@
     "angular-mocks": "1.5.8",
     "angular-sanitize": "1.5.8",
     "angular-native-dragdrop": "1.2.2",
-    "angular-bindonce": "0.3.3"
+    "angular-bindonce": "0.3.3",
+    "clipboard": "^1.5.16"
   }
 }

public/app/core/components/grafana_app.ts

@@ -73,6 +73,9 @@ export function grafanaAppDirective(playlistSrv, contextSrv) {
       var ignoreSideMenuHide;
       var body = $('body');
 
+      // see https://github.com/zenorocha/clipboard.js/issues/155
+      $.fn.modal.Constructor.prototype.enforceFocus = function() {};
+
       // handle sidemenu open state
       scope.$watch('contextSrv.sidemenu', newVal => {
         if (newVal !== undefined) {

public/app/features/dashboard/shareModalCtrl.js

 define(['angular',
   'lodash',
+  'jquery',
   'require',
   'app/core/config',
 ],
-function (angular, _, require, config) {
+function (angular, _, $, require, config) {
   'use strict';
 
   var module = angular.module('grafana.controllers');
@@ -88,11 +89,14 @@ function (angular, _, require, config) {
 
   module.directive('clipboardButton',function() {
     return function(scope, elem) {
-      require(['vendor/zero_clipboard'], function(ZeroClipboard) {
-        ZeroClipboard.config({
-          swfPath: config.appSubUrl + '/public/vendor/zero_clipboard.swf'
-        });
-        new ZeroClipboard(elem[0]);
+      require(['vendor/clipboard/dist/clipboard'], function(Clipboard) {
+        scope.clipboard = new Clipboard(elem[0]);
+      });
+
+      scope.$on('$destroy', function() {
+        if (scope.clipboard) {
+          scope.clipboard.destroy();
+        }
       });
     };
   });

public/vendor/clipboard/.bower.json

+{
+  "name": "clipboard",
+  "version": "1.5.16",
+  "description": "Modern copy to clipboard. No Flash. Just 2kb",
+  "license": "MIT",
+  "main": "dist/clipboard.js",
+  "ignore": [
+    "/.*/",
+    "/demo/",
+    "/test/",
+    "/.*",
+    "/bower.json",
+    "/karma.conf.js",
+    "/src",
+    "/lib"
+  ],
+  "keywords": [
+    "clipboard",
+    "copy",
+    "cut"
+  ],
+  "homepage": "https://github.com/zenorocha/clipboard.js",
+  "_release": "1.5.16",
+  "_resolution": {
+    "type": "version",
+    "tag": "v1.5.16",
+    "commit": "402c9ee17bed6f273bcbc7efa81874fd9a50b84c"
+  },
+  "_source": "https://github.com/zenorocha/clipboard.js.git",
+  "_target": "^1.5.16",
+  "_originalSource": "clipboard",
+  "_direct": true
+}
\ No newline at end of file

public/vendor/clipboard/bower.json

+{
+  "name": "clipboard",
+  "version": "1.5.16",
+  "description": "Modern copy to clipboard. No Flash. Just 2kb",
+  "license": "MIT",
+  "main": "dist/clipboard.js",
+  "ignore": [
+    "/.*/",
+    "/demo/",
+    "/test/",
+    "/.*",
+    "/bower.json",
+    "/karma.conf.js",
+    "/src",
+    "/lib"
+  ],
+  "keywords": [
+    "clipboard",
+    "copy",
+    "cut"
+  ]
+}

public/vendor/clipboard/contributing.md

+# Contributing guide
+
+Want to contribute to Clipboard.js? Awesome!
+There are many ways you can contribute, see below.
+
+## Opening issues
+
+Open an issue to report bugs or to propose new features.
+
+- Reporting bugs: describe the bug as clearly as you can, including steps to reproduce, what happened and what you were expecting to happen. Also include browser version, OS and other related software's (npm, Node.js, etc) versions when applicable.
+
+- Proposing features: explain the proposed feature, what it should do, why it is useful, how users should use it. Give us as much info as possible so it will be easier to discuss, access and implement the proposed feature. When you're unsure about a certain aspect of the feature, feel free to leave it open for others to discuss and find an appropriate solution.
+
+## Proposing pull requests
+
+Pull requests are very welcome. Note that if you are going to propose drastic changes, be sure to open an issue for discussion first, to make sure that your PR will be accepted before you spend effort coding it.
+
+Fork the Clipboard.js repository, clone it locally and create a branch for your proposed bug fix or new feature. Avoid working directly on the master branch.
+
+Implement your bug fix or feature, write tests to cover it and make sure all tests are passing (run a final `npm test` to make sure everything is correct). Then commit your changes, push your bug fix/feature branch to the origin (your forked repo) and open a pull request to the upstream (the repository you originally forked)'s master branch.
+
+## Documentation
+
+Documentation is extremely important and takes a fair deal of time and effort to write and keep updated. Please submit any and all improvements you can make to the repository's docs.
+
+## Known issues
+If you're using npm@3 you'll probably face some issues related to peerDependencies.
+https://github.com/npm/npm/issues/9204

public/vendor/clipboard/dist/clipboard.js

+/*!
+ * clipboard.js v1.5.16
+ * https://zenorocha.github.io/clipboard.js
+ *
+ * Licensed MIT © Zeno Rocha
+ */
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Clipboard = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+var DOCUMENT_NODE_TYPE = 9;
+
+/**
+ * A polyfill for Element.matches()
+ */
+if (Element && !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 (element.matches(selector)) return element;
+        element = element.parentNode;
+    }
+}
+
+module.exports = closest;
+
+},{}],2:[function(require,module,exports){
+var closest = require('./closest');
+
+/**
+ * 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);
+        }
+    }
+}
+
+/**
+ * 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;
+
+},{"./closest":1}],3:[function(require,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]';
+};
+
+},{}],4:[function(require,module,exports){
+var is = require('./is');
+var delegate = require('delegate');
+
+/**
+ * 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;
+
+},{"./is":3,"delegate":2}],5:[function(require,module,exports){
+function select(element) {
+    var selectedText;
+
+    if (element.nodeName === 'SELECT') {
+        element.focus();
+
+        selectedText = element.value;
+    }
+    else if (element.nodeName === 'INPUT' || element.nodeName === 'TEXTAREA') {
+        element.focus();
+        element.setSelectionRange(0, element.value.length);
+
+        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;
+
+},{}],6:[function(require,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;
+
+},{}],7:[function(require,module,exports){
+(function (global, factory) {
+    if (typeof define === "function" && define.amd) {
+        define(['module', 'select'], factory);
+    } else if (typeof exports !== "undefined") {
+        factory(module, require('select'));
+    } else {
+        var mod = {
+            exports: {}
+        };
+        factory(mod, global.select);
+        global.clipboardAction = mod.exports;
+    }
+})(this, function (module, _select) {
+    'use strict';
+
+    var _select2 = _interopRequireDefault(_select);
+
+    function _interopRequireDefault(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }
+
+    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;
+    };
+
+    function _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) {
+            throw new TypeError("Cannot call a class as a function");
+        }
+    }
+
+    var _createClass = function () {
+        function defineProperties(target, props) {
+            for (var i = 0; i < props.length; i++) {
+                var descriptor = props[i];
+                descriptor.enumerable = descriptor.enumerable || false;
+                descriptor.configurable = true;
+                if ("value" in descriptor) descriptor.writable = true;
+                Object.defineProperty(target, descriptor.key, descriptor);
+            }
+        }
+
+        return function (Constructor, protoProps, staticProps) {
+            if (protoProps) defineProperties(Constructor.prototype, protoProps);
+            if (staticProps) defineProperties(Constructor, staticProps);
+            return Constructor;
+        };
+    }();
+
+    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.emitter = options.emitter;
+                this.target = options.target;
+                this.text = options.text;
+                this.trigger = options.trigger;
+
+                this.selectedText = '';
+            }
+        }, {
+            key: 'initSelection',
+            value: function initSelection() {
+                if (this.text) {
+                    this.selectFake();
+                } else if (this.target) {
+                    this.selectTarget();
+                }
+            }
+        }, {
+            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 = document.body.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.addEventListener('focus', window.scrollTo(0, yPosition));
+                this.fakeElem.style.top = yPosition + 'px';
+
+                this.fakeElem.setAttribute('readonly', '');
+                this.fakeElem.value = this.text;
+
+                document.body.appendChild(this.fakeElem);
+
+                this.selectedText = (0, _select2.default)(this.fakeElem);
+                this.copyText();
+            }
+        }, {
+            key: 'removeFake',
+            value: function removeFake() {
+                if (this.fakeHandler) {
+                    document.body.removeEventListener('click', this.fakeHandlerCallback);
+                    this.fakeHandler = null;
+                    this.fakeHandlerCallback = null;
+                }
+
+                if (this.fakeElem) {
+                    document.body.removeChild(this.fakeElem);
+                    this.fakeElem = null;
+                }
+            }
+        }, {
+            key: 'selectTarget',
+            value: function selectTarget() {
+                this.selectedText = (0, _select2.default)(this.target);
+                this.copyText();
+            }
+        }, {
+            key: 'copyText',
+            value: function copyText() {
+                var succeeded = void 0;
+
+                try {
+                    succeeded = document.execCommand(this.action);
+                } catch (err) {
+                    succeeded = false;
+                }
+
+                this.handleResult(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)
+                });
+            }
+        }, {
+            key: 'clearSelection',
+            value: function clearSelection() {
+                if (this.target) {
+                    this.target.blur();
+                }
+
+                window.getSelection().removeAllRanges();
+            }
+        }, {
+            key: 'destroy',
+            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"');
+                }
+            },
+            get: function get() {
+                return this._action;
+            }
+        }, {
+            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');
+                    }
+                }
+            },
+            get: function get() {
+                return this._target;
+            }
+        }]);
+
+        return ClipboardAction;
+    }();
+
+    module.exports = ClipboardAction;
+});
+
+},{"select":5}],8:[function(require,module,exports){
+(function (global, factory) {
+    if (typeof define === "function" && define.amd) {
+        define(['module', './clipboard-action', 'tiny-emitter', 'good-listener'], factory);
+    } else if (typeof exports !== "undefined") {
+        factory(module, require('./clipboard-action'), require('tiny-emitter'), require('good-listener'));
+    } else {
+        var mod = {
+            exports: {}
+        };
+        factory(mod, global.clipboardAction, global.tinyEmitter, global.goodListener);
+        global.clipboard = mod.exports;
+    }
+})(this, function (module, _clipboardAction, _tinyEmitter, _goodListener) {
+    'use strict';
+
+    var _clipboardAction2 = _interopRequireDefault(_clipboardAction);
+
+    var _tinyEmitter2 = _interopRequireDefault(_tinyEmitter);
+
+    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");
+        }
+    }
+
+    var _createClass = function () {
+        function defineProperties(target, props) {
+            for (var i = 0; i < props.length; i++) {
+                var descriptor = props[i];
+                descriptor.enumerable = descriptor.enumerable || false;
+                descriptor.configurable = true;
+                if ("value" in descriptor) descriptor.writable = true;
+                Object.defineProperty(target, descriptor.key, descriptor);
+            }
+        }
+
+        return function (Constructor, protoProps, staticProps) {
+            if (protoProps) defineProperties(Constructor.prototype, protoProps);
+            if (staticProps) defineProperties(Constructor, staticProps);
+            return Constructor;
+        };
+    }();
+
+    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;
+    }
+
+    function _inherits(subClass, superClass) {
+        if (typeof superClass !== "function" && superClass !== null) {
+            throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+        }
+
+        subClass.prototype = Object.create(superClass && superClass.prototype, {
+            constructor: {
+                value: subClass,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+    }
+
+    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;
+            }
+        }, {
+            key: 'listenClick',
+            value: function listenClick(trigger) {
+                var _this2 = this;
+
+                this.listener = (0, _goodListener2.default)(trigger, 'click', function (e) {
+                    return _this2.onClick(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),
+                    trigger: trigger,
+                    emitter: this
+                });
+            }
+        }, {
+            key: 'defaultAction',
+            value: function defaultAction(trigger) {
+                return getAttributeValue('action', trigger);
+            }
+        }, {
+            key: 'defaultTarget',
+            value: function defaultTarget(trigger) {
+                var selector = getAttributeValue('target', trigger);
+
+                if (selector) {
+                    return document.querySelector(selector);
+                }
+            }
+        }, {
+            key: 'defaultText',
+            value: function defaultText(trigger) {
+                return getAttributeValue('text', trigger);
+            }
+        }, {
+            key: 'destroy',
+            value: function destroy() {
+                this.listener.destroy();
+
+                if (this.clipboardAction) {
+                    this.clipboardAction.destroy();
+                    this.clipboardAction = null;
+                }
+            }
+        }]);
+
+        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;
+});
+
+},{"./clipboard-action":7,"good-listener":4,"tiny-emitter":6}]},{},[8])(8)
+});
\ No newline at end of file

public/vendor/clipboard/dist/clipboard.min.js

+/*!
+ * clipboard.js v1.5.16
+ * https://zenorocha.github.io/clipboard.js
+ *
+ * Licensed MIT © Zeno Rocha
+ */
+!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var t;t="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,t.Clipboard=e()}}(function(){var e,t,n;return function e(t,n,i){function o(a,c){if(!n[a]){if(!t[a]){var l="function"==typeof require&&require;if(!c&&l)return l(a,!0);if(r)return r(a,!0);var s=new Error("Cannot find module '"+a+"'");throw s.code="MODULE_NOT_FOUND",s}var u=n[a]={exports:{}};t[a][0].call(u.exports,function(e){var n=t[a][1][e];return o(n?n:e)},u,u.exports,e,t,n,i)}return n[a].exports}for(var r="function"==typeof require&&require,a=0;a<i.length;a++)o(i[a]);return o}({1:[function(e,t,n){function i(e,t){for(;e&&e.nodeType!==o;){if(e.matches(t))return e;e=e.parentNode}}var o=9;if(Element&&!Element.prototype.matches){var r=Element.prototype;r.matches=r.matchesSelector||r.mozMatchesSelector||r.msMatchesSelector||r.oMatchesSelector||r.webkitMatchesSelector}t.exports=i},{}],2:[function(e,t,n){function i(e,t,n,i,r){var a=o.apply(this,arguments);return e.addEventListener(n,a,r),{destroy:function(){e.removeEventListener(n,a,r)}}}function o(e,t,n,i){return function(n){n.delegateTarget=r(n.target,t),n.delegateTarget&&i.call(e,n)}}var r=e("./closest");t.exports=i},{"./closest":1}],3:[function(e,t,n){n.node=function(e){return void 0!==e&&e instanceof HTMLElement&&1===e.nodeType},n.nodeList=function(e){var t=Object.prototype.toString.call(e);return void 0!==e&&("[object NodeList]"===t||"[object HTMLCollection]"===t)&&"length"in e&&(0===e.length||n.node(e[0]))},n.string=function(e){return"string"==typeof e||e instanceof String},n.fn=function(e){var t=Object.prototype.toString.call(e);return"[object Function]"===t}},{}],4:[function(e,t,n){function i(e,t,n){if(!e&&!t&&!n)throw new Error("Missing required arguments");if(!c.string(t))throw new TypeError("Second argument must be a String");if(!c.fn(n))throw new TypeError("Third argument must be a Function");if(c.node(e))return o(e,t,n);if(c.nodeList(e))return r(e,t,n);if(c.string(e))return a(e,t,n);throw new TypeError("First argument must be a String, HTMLElement, HTMLCollection, or NodeList")}function o(e,t,n){return e.addEventListener(t,n),{destroy:function(){e.removeEventListener(t,n)}}}function r(e,t,n){return Array.prototype.forEach.call(e,function(e){e.addEventListener(t,n)}),{destroy:function(){Array.prototype.forEach.call(e,function(e){e.removeEventListener(t,n)})}}}function a(e,t,n){return l(document.body,e,t,n)}var c=e("./is"),l=e("delegate");t.exports=i},{"./is":3,delegate:2}],5:[function(e,t,n){function i(e){var t;if("SELECT"===e.nodeName)e.focus(),t=e.value;else if("INPUT"===e.nodeName||"TEXTAREA"===e.nodeName)e.focus(),e.setSelectionRange(0,e.value.length),t=e.value;else{e.hasAttribute("contenteditable")&&e.focus();var n=window.getSelection(),i=document.createRange();i.selectNodeContents(e),n.removeAllRanges(),n.addRange(i),t=n.toString()}return t}t.exports=i},{}],6:[function(e,t,n){function i(){}i.prototype={on:function(e,t,n){var i=this.e||(this.e={});return(i[e]||(i[e]=[])).push({fn:t,ctx:n}),this},once:function(e,t,n){function i(){o.off(e,i),t.apply(n,arguments)}var o=this;return i._=t,this.on(e,i,n)},emit:function(e){var t=[].slice.call(arguments,1),n=((this.e||(this.e={}))[e]||[]).slice(),i=0,o=n.length;for(i;i<o;i++)n[i].fn.apply(n[i].ctx,t);return this},off:function(e,t){var n=this.e||(this.e={}),i=n[e],o=[];if(i&&t)for(var r=0,a=i.length;r<a;r++)i[r].fn!==t&&i[r].fn._!==t&&o.push(i[r]);return o.length?n[e]=o:delete n[e],this}},t.exports=i},{}],7:[function(t,n,i){!function(o,r){if("function"==typeof e&&e.amd)e(["module","select"],r);else if("undefined"!=typeof i)r(n,t("select"));else{var a={exports:{}};r(a,o.select),o.clipboardAction=a.exports}}(this,function(e,t){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function i(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}var o=n(t),r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},a=function(){function e(e,t){for(var n=0;n<t.length;n++){var i=t[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(e,i.key,i)}}return function(t,n,i){return n&&e(t.prototype,n),i&&e(t,i),t}}(),c=function(){function e(t){i(this,e),this.resolveOptions(t),this.initSelection()}return a(e,[{key:"resolveOptions",value:function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};this.action=t.action,this.emitter=t.emitter,this.target=t.target,this.text=t.text,this.trigger=t.trigger,this.selectedText=""}},{key:"initSelection",value:function e(){this.text?this.selectFake():this.target&&this.selectTarget()}},{key:"selectFake",value:function e(){var t=this,n="rtl"==document.documentElement.getAttribute("dir");this.removeFake(),this.fakeHandlerCallback=function(){return t.removeFake()},this.fakeHandler=document.body.addEventListener("click",this.fakeHandlerCallback)||!0,this.fakeElem=document.createElement("textarea"),this.fakeElem.style.fontSize="12pt",this.fakeElem.style.border="0",this.fakeElem.style.padding="0",this.fakeElem.style.margin="0",this.fakeElem.style.position="absolute",this.fakeElem.style[n?"right":"left"]="-9999px";var i=window.pageYOffset||document.documentElement.scrollTop;this.fakeElem.addEventListener("focus",window.scrollTo(0,i)),this.fakeElem.style.top=i+"px",this.fakeElem.setAttribute("readonly",""),this.fakeElem.value=this.text,document.body.appendChild(this.fakeElem),this.selectedText=(0,o.default)(this.fakeElem),this.copyText()}},{key:"removeFake",value:function e(){this.fakeHandler&&(document.body.removeEventListener("click",this.fakeHandlerCallback),this.fakeHandler=null,this.fakeHandlerCallback=null),this.fakeElem&&(document.body.removeChild(this.fakeElem),this.fakeElem=null)}},{key:"selectTarget",value:function e(){this.selectedText=(0,o.default)(this.target),this.copyText()}},{key:"copyText",value:function e(){var t=void 0;try{t=document.execCommand(this.action)}catch(e){t=!1}this.handleResult(t)}},{key:"handleResult",value:function e(t){this.emitter.emit(t?"success":"error",{action:this.action,text:this.selectedText,trigger:this.trigger,clearSelection:this.clearSelection.bind(this)})}},{key:"clearSelection",value:function e(){this.target&&this.target.blur(),window.getSelection().removeAllRanges()}},{key:"destroy",value:function e(){this.removeFake()}},{key:"action",set:function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:"copy";if(this._action=t,"copy"!==this._action&&"cut"!==this._action)throw new Error('Invalid "action" value, use either "copy" or "cut"')},get:function e(){return this._action}},{key:"target",set:function e(t){if(void 0!==t){if(!t||"object"!==("undefined"==typeof t?"undefined":r(t))||1!==t.nodeType)throw new Error('Invalid "target" value, use a valid Element');if("copy"===this.action&&t.hasAttribute("disabled"))throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');if("cut"===this.action&&(t.hasAttribute("readonly")||t.hasAttribute("disabled")))throw new Error('Invalid "target" attribute. You can\'t cut text from elements with "readonly" or "disabled" attributes');this._target=t}},get:function e(){return this._target}}]),e}();e.exports=c})},{select:5}],8:[function(t,n,i){!function(o,r){if("function"==typeof e&&e.amd)e(["module","./clipboard-action","tiny-emitter","good-listener"],r);else if("undefined"!=typeof i)r(n,t("./clipboard-action"),t("tiny-emitter"),t("good-listener"));else{var a={exports:{}};r(a,o.clipboardAction,o.tinyEmitter,o.goodListener),o.clipboard=a.exports}}(this,function(e,t,n,i){"use strict";function o(e){return e&&e.__esModule?e:{default:e}}function r(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function a(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function c(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}function l(e,t){var n="data-clipboard-"+e;if(t.hasAttribute(n))return t.getAttribute(n)}var s=o(t),u=o(n),f=o(i),d=function(){function e(e,t){for(var n=0;n<t.length;n++){var i=t[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(e,i.key,i)}}return function(t,n,i){return n&&e(t.prototype,n),i&&e(t,i),t}}(),h=function(e){function t(e,n){r(this,t);var i=a(this,(t.__proto__||Object.getPrototypeOf(t)).call(this));return i.resolveOptions(n),i.listenClick(e),i}return c(t,e),d(t,[{key:"resolveOptions",value:function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};this.action="function"==typeof t.action?t.action:this.defaultAction,this.target="function"==typeof t.target?t.target:this.defaultTarget,this.text="function"==typeof t.text?t.text:this.defaultText}},{key:"listenClick",value:function e(t){var n=this;this.listener=(0,f.default)(t,"click",function(e){return n.onClick(e)})}},{key:"onClick",value:function e(t){var n=t.delegateTarget||t.currentTarget;this.clipboardAction&&(this.clipboardAction=null),this.clipboardAction=new s.default({action:this.action(n),target:this.target(n),text:this.text(n),trigger:n,emitter:this})}},{key:"defaultAction",value:function e(t){return l("action",t)}},{key:"defaultTarget",value:function e(t){var n=l("target",t);if(n)return document.querySelector(n)}},{key:"defaultText",value:function e(t){return l("text",t)}},{key:"destroy",value:function e(){this.listener.destroy(),this.clipboardAction&&(this.clipboardAction.destroy(),this.clipboardAction=null)}}]),t}(u.default);e.exports=h})},{"./clipboard-action":7,"good-listener":4,"tiny-emitter":6}]},{},[8])(8)});
\ No newline at end of file

public/vendor/clipboard/package.js

+// Package metadata for Meteor.js.
+
+Package.describe({
+  name: "zenorocha:clipboard",
+  summary: "Modern copy to clipboard. No Flash. Just 2kb.",
+  version: "1.5.16",
+  git: "https://github.com/zenorocha/clipboard.js"
+});
+
+Package.onUse(function(api) {
+  api.addFiles("dist/clipboard.js", "client");
+});

public/vendor/clipboard/package.json

+{
+  "name": "clipboard",
+  "version": "1.5.16",
+  "description": "Modern copy to clipboard. No Flash. Just 2kb",
+  "repository": "zenorocha/clipboard.js",
+  "license": "MIT",
+  "main": "lib/clipboard.js",
+  "keywords": [
+    "clipboard",
+    "copy",
+    "cut"
+  ],
+  "dependencies": {
+    "good-listener": "^1.2.0",
+    "select": "^1.0.6",
+    "tiny-emitter": "^1.0.0"
+  },
+  "devDependencies": {
+    "babel-cli": "^6.5.1",
+    "babel-core": "^6.5.2",
+    "babel-plugin-transform-es2015-modules-umd": "^6.5.0",
+    "babel-preset-es2015": "^6.5.0",
+    "babelify": "^7.2.0",
+    "bannerify": "Vekat/bannerify#feature-option",
+    "browserify": "^13.0.0",
+    "chai": "^3.4.1",
+    "install": "^0.8.1",
+    "karma": "^1.3.0",
+    "karma-browserify": "^5.0.1",
+    "karma-chai": "^0.1.0",
+    "karma-mocha": "^1.2.0",
+    "karma-phantomjs-launcher": "^1.0.0",
+    "karma-sinon": "^1.0.4",
+    "mocha": "^3.1.2",
+    "phantomjs-prebuilt": "^2.1.4",
+    "sinon": "^1.17.2",
+    "uglify-js": "^2.4.24",
+    "watchify": "^3.4.0"
+  },
+  "scripts": {
+    "build": "npm run build-debug && npm run build-min",
+    "build-debug": "browserify src/clipboard.js -s Clipboard -t [babelify] -p [bannerify --file .banner ] -o dist/clipboard.js",
+    "build-min": "uglifyjs dist/clipboard.js --comments '/!/' -m screw_ie8=true -c screw_ie8=true,unused=false -o dist/clipboard.min.js",
+    "build-watch": "watchify src/clipboard.js -s Clipboard -t [babelify] -o dist/clipboard.js -v",
+    "test": "karma start --single-run",
+    "prepublish": "babel src --out-dir lib"
+  }
+}

public/vendor/clipboard/readme.md

+# clipboard.js
+
+[![Build Status](http://img.shields.io/travis/zenorocha/clipboard.js/master.svg?style=flat)](https://travis-ci.org/zenorocha/clipboard.js)
+![Killing Flash](https://img.shields.io/badge/killing-flash-brightgreen.svg?style=flat)
+
+> Modern copy to clipboard. No Flash. Just 3kb gzipped.
+
+<a href="https://clipboardjs.com/"><img width="728" src="https://cloud.githubusercontent.com/assets/398893/16165747/a0f6fc46-349a-11e6-8c9b-c5fd58d9099c.png" alt="Demo"></a>
+
+## Why
+
+Copying text to the clipboard shouldn't be hard. It shouldn't require dozens of steps to configure or hundreds of KBs to load. But most of all, it shouldn't depend on Flash or any bloated framework.
+
+That's why clipboard.js exists.
+
+## Install
+
+You can get it on npm.
+
+```
+npm install clipboard --save
+```
+
+Or bower, too.
+
+```
+bower install clipboard --save
+```
+
+If you're not into package management, just [download a ZIP](https://github.com/zenorocha/clipboard.js/archive/master.zip) file.
+
+## Setup
+
+First, include the script located on the `dist` folder or load it from [a third-party CDN provider](https://github.com/zenorocha/clipboard.js/wiki/CDN-Providers).
+
+```html
+<script src="dist/clipboard.min.js"></script>
+```
+
+Now, you need to instantiate it by [passing a DOM selector](https://github.com/zenorocha/clipboard.js/blob/master/demo/constructor-selector.html#L18), [HTML element](https://github.com/zenorocha/clipboard.js/blob/master/demo/constructor-node.html#L16-L17), or [list of HTML elements](https://github.com/zenorocha/clipboard.js/blob/master/demo/constructor-nodelist.html#L18-L19).
+
+```js
+new Clipboard('.btn');
+```
+
+Internally, we need to fetch all elements that matches with your selector and attach event listeners for each one. But guess what? If you have hundreds of matches, this operation can consume a lot of memory.
+
+For this reason we use [event delegation](http://stackoverflow.com/questions/1687296/what-is-dom-event-delegation) which replaces multiple event listeners with just a single listener. After all, [#perfmatters](https://twitter.com/hashtag/perfmatters).
+
+# Usage
+
+We're living a _declarative renaissance_, that's why we decided to take advantage of [HTML5 data attributes](https://developer.mozilla.org/en-US/docs/Web/Guide/HTML/Using_data_attributes) for better usability.
+
+### Copy text from another element
+
+A pretty common use case is to copy content from another element. You can do that by adding a `data-clipboard-target` attribute in your trigger element.
+
+The value you include on this attribute needs to match another's element selector.
+
+<a href="https://clipboardjs.com/#example-target"><img width="473" alt="example-2" src="https://cloud.githubusercontent.com/assets/398893/9983467/a4946aaa-5fb1-11e5-9780-f09fcd7ca6c8.png"></a>
+
+```html
+<!-- Target -->
+<input id="foo" value="https://github.com/zenorocha/clipboard.js.git">
+
+<!-- Trigger -->
+<button class="btn" data-clipboard-target="#foo">
+    <img src="assets/clippy.svg" alt="Copy to clipboard">
+</button>
+```
+
+### Cut text from another element
+
+Additionally, you can define a `data-clipboard-action` attribute to specify if you want to either `copy` or `cut` content.
+
+If you omit this attribute, `copy` will be used by default.
+
+<a href="https://clipboardjs.com/#example-action"><img width="473" alt="example-3" src="https://cloud.githubusercontent.com/assets/398893/10000358/7df57b9c-6050-11e5-9cd1-fbc51d2fd0a7.png"></a>
+
+```html
+<!-- Target -->
+<textarea id="bar">Mussum ipsum cacilds...</textarea>
+
+<!-- Trigger -->
+<button class="btn" data-clipboard-action="cut" data-clipboard-target="#bar">
+    Cut to clipboard
+</button>
+```
+
+As you may expect, the `cut` action only works on `<input>` or `<textarea>` elements.
+
+### Copy text from attribute
+
+Truth is, you don't even need another element to copy its content from. You can just include a `data-clipboard-text` attribute in your trigger element.
+
+<a href="https://clipboardjs.com/#example-text"><img width="147" alt="example-1" src="https://cloud.githubusercontent.com/assets/398893/10000347/6e16cf8c-6050-11e5-9883-1c5681f9ec45.png"></a>
+
+```html
+<!-- Trigger -->
+<button class="btn" data-clipboard-text="Just because you can doesn't mean you should — clipboard.js">
+    Copy to clipboard
+</button>
+```
+
+## Events
+
+There are cases where you'd like to show some user feedback or capture what has been selected after a copy/cut operation.
+
+That's why we fire custom events such as `success` and `error` for you to listen and implement your custom logic.
+
+```js
+var clipboard = new Clipboard('.btn');
+
+clipboard.on('success', function(e) {
+    console.info('Action:', e.action);
+    console.info('Text:', e.text);
+    console.info('Trigger:', e.trigger);
+
+    e.clearSelection();
+});
+
+clipboard.on('error', function(e) {
+    console.error('Action:', e.action);
+    console.error('Trigger:', e.trigger);
+});
+```
+
+For a live demonstration, open this [site](https://clipboardjs.com/) and just your console :)
+
+## Advanced Options
+
+If you don't want to modify your HTML, there's a pretty handy imperative API for you to use. All you need to do is declare a function, do your thing, and return a value.
+
+For instance, if you want to dynamically set a `target`, you'll need to return a Node.
+
+```js
+new Clipboard('.btn', {
+    target: function(trigger) {
+        return trigger.nextElementSibling;
+    }
+});
+```
+
+If you want to dynamically set a `text`, you'll return a String.
+
+```js
+new Clipboard('.btn', {
+    text: function(trigger) {
+        return trigger.getAttribute('aria-label');
+    }
+});
+```
+
+Also, if you are working with single page apps, you may want to manage the lifecycle of the DOM more precisely. Here's how you clean up the events and objects that we create.
+
+```js
+var clipboard = new Clipboard('.btn');
+clipboard.destroy();
+```
+
+## Browser Support
+
+This library relies on both [Selection](https://developer.mozilla.org/en-US/docs/Web/API/Selection) and [execCommand](https://developer.mozilla.org/en-US/docs/Web/API/Document/execCommand) APIs. The first one is [supported by all browsers](http://caniuse.com/#search=selection) while the second one is supported in the following browsers.
+
+| <img src="https://clipboardjs.com/assets/images/chrome.png" width="48px" height="48px" alt="Chrome logo"> | <img src="https://clipboardjs.com/assets/images/edge.png" width="48px" height="48px" alt="Edge logo"> | <img src="https://clipboardjs.com/assets/images/firefox.png" width="48px" height="48px" alt="Firefox logo"> | <img src="https://clipboardjs.com/assets/images/ie.png" width="48px" height="48px" alt="Internet Explorer logo"> | <img src="https://clipboardjs.com/assets/images/opera.png" width="48px" height="48px" alt="Opera logo"> | <img src="https://clipboardjs.com/assets/images/safari.png" width="48px" height="48px" alt="Safari logo"> |
+|:---:|:---:|:---:|:---:|:---:|:---:|
+| 42+ ✔ | 12+ ✔ | 41+ ✔ | 9+ ✔ | 29+ ✔ | 10+ ✔ |
+
+The good news is that clipboard.js gracefully degrades if you need to support older browsers. All you have to do is show a tooltip saying `Copied!` when `success` event is called and `Press Ctrl+C to copy` when `error` event is called because the text is already selected.
+
+## License
+
+[MIT License](http://zenorocha.mit-license.org/) © Zeno Rocha

public/vendor/zero_clipboard.js

-/*!
- * ZeroClipboard
- * The ZeroClipboard library provides an easy way to copy text to the clipboard using an invisible Adobe Flash movie and a JavaScript interface.
- * Copyright (c) 2009-2014 Jon Rohan, James M. Greene
- * Licensed MIT
- * http://zeroclipboard.org/
- * v2.2.0
- */
-(function(window, undefined) {
-  "use strict";
-  /**
- * Store references to critically important global functions that may be
- * overridden on certain web pages.
- */
-  var _window = window, _document = _window.document, _navigator = _window.navigator, _setTimeout = _window.setTimeout, _clearTimeout = _window.clearTimeout, _setInterval = _window.setInterval, _clearInterval = _window.clearInterval, _getComputedStyle = _window.getComputedStyle, _encodeURIComponent = _window.encodeURIComponent, _ActiveXObject = _window.ActiveXObject, _Error = _window.Error, _parseInt = _window.Number.parseInt || _window.parseInt, _parseFloat = _window.Number.parseFloat || _window.parseFloat, _isNaN = _window.Number.isNaN || _window.isNaN, _now = _window.Date.now, _keys = _window.Object.keys, _defineProperty = _window.Object.defineProperty, _hasOwn = _window.Object.prototype.hasOwnProperty, _slice = _window.Array.prototype.slice, _unwrap = function() {
-    var unwrapper = function(el) {
-      return el;
-    };
-    if (typeof _window.wrap === "function" && typeof _window.unwrap === "function") {
-      try {
-        var div = _document.createElement("div");
-        var unwrappedDiv = _window.unwrap(div);
-        if (div.nodeType === 1 && unwrappedDiv && unwrappedDiv.nodeType === 1) {
-          unwrapper = _window.unwrap;
-        }
-      } catch (e) {}
-    }
-    return unwrapper;
-  }();
-  /**
- * Convert an `arguments` object into an Array.
- *
- * @returns The arguments as an Array
- * @private
- */
-  var _args = function(argumentsObj) {
-    return _slice.call(argumentsObj, 0);
-  };
-  /**
- * Shallow-copy the owned, enumerable properties of one object over to another, similar to jQuery's `$.extend`.
- *
- * @returns The target object, augmented
- * @private
- */
-  var _extend = function() {
-    var i, len, arg, prop, src, copy, args = _args(arguments), target = args[0] || {};
-    for (i = 1, len = args.length; i < len; i++) {
-      if ((arg = args[i]) != null) {
-        for (prop in arg) {
-          if (_hasOwn.call(arg, prop)) {
-            src = target[prop];
-            copy = arg[prop];
-            if (target !== copy && copy !== undefined) {
-              target[prop] = copy;
-            }
-          }
-        }
-      }
-    }
-    return target;
-  };
-  /**
- * Return a deep copy of the source object or array.
- *
- * @returns Object or Array
- * @private
- */
-  var _deepCopy = function(source) {
-    var copy, i, len, prop;
-    if (typeof source !== "object" || source == null || typeof source.nodeType === "number") {
-      copy = source;
-    } else if (typeof source.length === "number") {
-      copy = [];
-      for (i = 0, len = source.length; i < len; i++) {
-        if (_hasOwn.call(source, i)) {
-          copy[i] = _deepCopy(source[i]);
-        }
-      }
-    } else {
-      copy = {};
-      for (prop in source) {
-        if (_hasOwn.call(source, prop)) {
-          copy[prop] = _deepCopy(source[prop]);
-        }
-      }
-    }
-    return copy;
-  };
-  /**
- * Makes a shallow copy of `obj` (like `_extend`) but filters its properties based on a list of `keys` to keep.
- * The inverse of `_omit`, mostly. The big difference is that these properties do NOT need to be enumerable to
- * be kept.
- *
- * @returns A new filtered object.
- * @private
- */
-  var _pick = function(obj, keys) {
-    var newObj = {};
-    for (var i = 0, len = keys.length; i < len; i++) {
-      if (keys[i] in obj) {
-        newObj[keys[i]] = obj[keys[i]];
-      }
-    }
-    return newObj;
-  };
-  /**
- * Makes a shallow copy of `obj` (like `_extend`) but filters its properties based on a list of `keys` to omit.
- * The inverse of `_pick`.
- *
- * @returns A new filtered object.
- * @private
- */
-  var _omit = function(obj, keys) {
-    var newObj = {};
-    for (var prop in obj) {
-      if (keys.indexOf(prop) === -1) {
-        newObj[prop] = obj[prop];
-      }
-    }
-    return newObj;
-  };
-  /**
- * Remove all owned, enumerable properties from an object.
- *
- * @returns The original object without its owned, enumerable properties.
- * @private
- */
-  var _deleteOwnProperties = function(obj) {
-    if (obj) {
-      for (var prop in obj) {
-        if (_hasOwn.call(obj, prop)) {
-          delete obj[prop];
-        }
-      }
-    }
-    return obj;
-  };
-  /**
- * Determine if an element is contained within another element.
- *
- * @returns Boolean
- * @private
- */
-  var _containedBy = function(el, ancestorEl) {
-    if (el && el.nodeType === 1 && el.ownerDocument && ancestorEl && (ancestorEl.nodeType === 1 && ancestorEl.ownerDocument && ancestorEl.ownerDocument === el.ownerDocument || ancestorEl.nodeType === 9 && !ancestorEl.ownerDocument && ancestorEl === el.ownerDocument)) {
-      do {
-        if (el === ancestorEl) {
-          return true;
-        }
-        el = el.parentNode;
-      } while (el);
-    }
-    return false;
-  };
-  /**
- * Get the URL path's parent directory.
- *
- * @returns String or `undefined`
- * @private
- */
-  var _getDirPathOfUrl = function(url) {
-    var dir;
-    if (typeof url === "string" && url) {
-      dir = url.split("#")[0].split("?")[0];
-      dir = url.slice(0, url.lastIndexOf("/") + 1);
-    }
-    return dir;
-  };
-  /**
- * Get the current script's URL by throwing an `Error` and analyzing it.
- *
- * @returns String or `undefined`
- * @private
- */
-  var _getCurrentScriptUrlFromErrorStack = function(stack) {
-    var url, matches;
-    if (typeof stack === "string" && stack) {
-      matches = stack.match(/^(?:|[^:@]*@|.+\)@(?=http[s]?|file)|.+?\s+(?: at |@)(?:[^:\(]+ )*[\(]?)((?:http[s]?|file):\/\/[\/]?.+?\/[^:\)]*?)(?::\d+)(?::\d+)?/);
-      if (matches && matches[1]) {
-        url = matches[1];
-      } else {
-        matches = stack.match(/\)@((?:http[s]?|file):\/\/[\/]?.+?\/[^:\)]*?)(?::\d+)(?::\d+)?/);
-        if (matches && matches[1]) {
-          url = matches[1];
-        }
-      }
-    }
-    return url;
-  };
-  /**
- * Get the current script's URL by throwing an `Error` and analyzing it.
- *
- * @returns String or `undefined`
- * @private
- */
-  var _getCurrentScriptUrlFromError = function() {
-    var url, err;
-    try {
-      throw new _Error();
-    } catch (e) {
-      err = e;
-    }
-    if (err) {
-      url = err.sourceURL || err.fileName || _getCurrentScriptUrlFromErrorStack(err.stack);
-    }
-    return url;
-  };
-  /**
- * Get the current script's URL.
- *
- * @returns String or `undefined`
- * @private
- */
-  var _getCurrentScriptUrl = function() {
-    var jsPath, scripts, i;
-    if (_document.currentScript && (jsPath = _document.currentScript.src)) {
-      return jsPath;
-    }
-    scripts = _document.getElementsByTagName("script");
-    if (scripts.length === 1) {
-      return scripts[0].src || undefined;
-    }
-    if ("readyState" in scripts[0]) {
-      for (i = scripts.length; i--; ) {
-        if (scripts[i].readyState === "interactive" && (jsPath = scripts[i].src)) {
-          return jsPath;
-        }
-      }
-    }
-    if (_document.readyState === "loading" && (jsPath = scripts[scripts.length - 1].src)) {
-      return jsPath;
-    }
-    if (jsPath = _getCurrentScriptUrlFromError()) {
-      return jsPath;
-    }
-    return undefined;
-  };
-  /**
- * Get the unanimous parent directory of ALL script tags.
- * If any script tags are either (a) inline or (b) from differing parent
- * directories, this method must return `undefined`.
- *
- * @returns String or `undefined`
- * @private
- */
-  var _getUnanimousScriptParentDir = function() {
-    var i, jsDir, jsPath, scripts = _document.getElementsByTagName("script");
-    for (i = scripts.length; i--; ) {
-      if (!(jsPath = scripts[i].src)) {
-        jsDir = null;
-        break;
-      }
-      jsPath = _getDirPathOfUrl(jsPath);
-      if (jsDir == null) {
-        jsDir = jsPath;
-      } else if (jsDir !== jsPath) {
-        jsDir = null;
-        break;
-      }
-    }
-    return jsDir || undefined;
-  };
-  /**
- * Get the presumed location of the "ZeroClipboard.swf" file, based on the location
- * of the executing JavaScript file (e.g. "ZeroClipboard.js", etc.).
- *
- * @returns String
- * @private
- */
-  var _getDefaultSwfPath = function() {
-    var jsDir = _getDirPathOfUrl(_getCurrentScriptUrl()) || _getUnanimousScriptParentDir() || "";
-    return jsDir + "ZeroClipboard.swf";
-  };
-  /**
- * Keep track of if the page is framed (in an `iframe`). This can never change.
- * @private
- */
-  var _pageIsFramed = function() {
-    return window.opener == null && (!!window.top && window != window.top || !!window.parent && window != window.parent);
-  }();
-  /**
- * Keep track of the state of the Flash object.
- * @private
- */
-  var _flashState = {
-    bridge: null,
-    version: "0.0.0",
-    pluginType: "unknown",
-    disabled: null,
-    outdated: null,
-    sandboxed: null,
-    unavailable: null,
-    degraded: null,
-    deactivated: null,
-    overdue: null,
-    ready: null
-  };
-  /**
- * The minimum Flash Player version required to use ZeroClipboard completely.
- * @readonly
- * @private
- */
-  var _minimumFlashVersion = "11.0.0";
-  /**
- * The ZeroClipboard library version number, as reported by Flash, at the time the SWF was compiled.
- */
-  var _zcSwfVersion;
-  /**
- * Keep track of all event listener registrations.
- * @private
- */
-  var _handlers = {};
-  /**
- * Keep track of the currently activated element.
- * @private
- */
-  var _currentElement;
-  /**
- * Keep track of the element that was activated when a `copy` process started.
- * @private
- */
-  var _copyTarget;
-  /**
- * Keep track of data for the pending clipboard transaction.
- * @private
- */
-  var _clipData = {};
-  /**
- * Keep track of data formats for the pending clipboard transaction.
- * @private
- */
-  var _clipDataFormatMap = null;
-  /**
- * Keep track of the Flash availability check timeout.
- * @private
- */
-  var _flashCheckTimeout = 0;
-  /**
- * Keep track of SWF network errors interval polling.
- * @private
- */
-  var _swfFallbackCheckInterval = 0;
-  /**
- * The `message` store for events
- * @private
- */
-  var _eventMessages = {
-    ready: "Flash communication is established",
-    error: {
-      "flash-disabled": "Flash is disabled or not installed. May also be attempting to run Flash in a sandboxed iframe, which is impossible.",
-      "flash-outdated": "Flash is too outdated to support ZeroClipboard",
-      "flash-sandboxed": "Attempting to run Flash in a sandboxed iframe, which is impossible",
-      "flash-unavailable": "Flash is unable to communicate bidirectionally with JavaScript",
-      "flash-degraded": "Flash is unable to preserve data fidelity when communicating with JavaScript",
-      "flash-deactivated": "Flash is too outdated for your browser and/or is configured as click-to-activate.\nThis may also mean that the ZeroClipboard SWF object could not be loaded, so please check your `swfPath` configuration and/or network connectivity.\nMay also be attempting to run Flash in a sandboxed iframe, which is impossible.",
-      "flash-overdue": "Flash communication was established but NOT within the acceptable time limit",
-      "version-mismatch": "ZeroClipboard JS version number does not match ZeroClipboard SWF version number",
-      "clipboard-error": "At least one error was thrown while ZeroClipboard was attempting to inject your data into the clipboard",
-      "config-mismatch": "ZeroClipboard configuration does not match Flash's reality",
-      "swf-not-found": "The ZeroClipboard SWF object could not be loaded, so please check your `swfPath` configuration and/or network connectivity"
-    }
-  };
-  /**
- * The `name`s of `error` events that can only occur is Flash has at least
- * been able to load the SWF successfully.
- * @private
- */
-  var _errorsThatOnlyOccurAfterFlashLoads = [ "flash-unavailable", "flash-degraded", "flash-overdue", "version-mismatch", "config-mismatch", "clipboard-error" ];
-  /**
- * The `name`s of `error` events that should likely result in the `_flashState`
- * variable's property values being updated.
- * @private
- */
-  var _flashStateErrorNames = [ "flash-disabled", "flash-outdated", "flash-sandboxed", "flash-unavailable", "flash-degraded", "flash-deactivated", "flash-overdue" ];
-  /**
- * A RegExp to match the `name` property of `error` events related to Flash.
- * @private
- */
-  var _flashStateErrorNameMatchingRegex = new RegExp("^flash-(" + _flashStateErrorNames.map(function(errorName) {
-    return errorName.replace(/^flash-/, "");
-  }).join("|") + ")$");
-  /**
- * A RegExp to match the `name` property of `error` events related to Flash,
- * which is enabled.
- * @private
- */
-  var _flashStateEnabledErrorNameMatchingRegex = new RegExp("^flash-(" + _flashStateErrorNames.slice(1).map(function(errorName) {
-    return errorName.replace(/^flash-/, "");
-  }).join("|") + ")$");
-  /**
- * ZeroClipboard configuration defaults for the Core module.
- * @private
- */
-  var _globalConfig = {
-    swfPath: _getDefaultSwfPath(),
-    trustedDomains: window.location.host ? [ window.location.host ] : [],
-    cacheBust: true,
-    forceEnhancedClipboard: false,
-    flashLoadTimeout: 3e4,
-    autoActivate: true,
-    bubbleEvents: true,
-    containerId: "global-zeroclipboard-html-bridge",
-    containerClass: "global-zeroclipboard-container",
-    swfObjectId: "global-zeroclipboard-flash-bridge",
-    hoverClass: "zeroclipboard-is-hover",
-    activeClass: "zeroclipboard-is-active",
-    forceHandCursor: false,
-    title: null,
-    zIndex: 999999999
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.config`.
- * @private
- */
-  var _config = function(options) {
-    if (typeof options === "object" && options !== null) {
-      for (var prop in options) {
-        if (_hasOwn.call(options, prop)) {
-          if (/^(?:forceHandCursor|title|zIndex|bubbleEvents)$/.test(prop)) {
-            _globalConfig[prop] = options[prop];
-          } else if (_flashState.bridge == null) {
-            if (prop === "containerId" || prop === "swfObjectId") {
-              if (_isValidHtml4Id(options[prop])) {
-                _globalConfig[prop] = options[prop];
-              } else {
-                throw new Error("The specified `" + prop + "` value is not valid as an HTML4 Element ID");
-              }
-            } else {
-              _globalConfig[prop] = options[prop];
-            }
-          }
-        }
-      }
-    }
-    if (typeof options === "string" && options) {
-      if (_hasOwn.call(_globalConfig, options)) {
-        return _globalConfig[options];
-      }
-      return;
-    }
-    return _deepCopy(_globalConfig);
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.state`.
- * @private
- */
-  var _state = function() {
-    _detectSandbox();
-    return {
-      browser: _pick(_navigator, [ "userAgent", "platform", "appName" ]),
-      flash: _omit(_flashState, [ "bridge" ]),
-      zeroclipboard: {
-        version: ZeroClipboard.version,
-        config: ZeroClipboard.config()
-      }
-    };
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.isFlashUnusable`.
- * @private
- */
-  var _isFlashUnusable = function() {
-    return !!(_flashState.disabled || _flashState.outdated || _flashState.sandboxed || _flashState.unavailable || _flashState.degraded || _flashState.deactivated);
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.on`.
- * @private
- */
-  var _on = function(eventType, listener) {
-    var i, len, events, added = {};
-    if (typeof eventType === "string" && eventType) {
-      events = eventType.toLowerCase().split(/\s+/);
-    } else if (typeof eventType === "object" && eventType && typeof listener === "undefined") {
-      for (i in eventType) {
-        if (_hasOwn.call(eventType, i) && typeof i === "string" && i && typeof eventType[i] === "function") {
-          ZeroClipboard.on(i, eventType[i]);
-        }
-      }
-    }
-    if (events && events.length) {
-      for (i = 0, len = events.length; i < len; i++) {
-        eventType = events[i].replace(/^on/, "");
-        added[eventType] = true;
-        if (!_handlers[eventType]) {
-          _handlers[eventType] = [];
-        }
-        _handlers[eventType].push(listener);
-      }
-      if (added.ready && _flashState.ready) {
-        ZeroClipboard.emit({
-          type: "ready"
-        });
-      }
-      if (added.error) {
-        for (i = 0, len = _flashStateErrorNames.length; i < len; i++) {
-          if (_flashState[_flashStateErrorNames[i].replace(/^flash-/, "")] === true) {
-            ZeroClipboard.emit({
-              type: "error",
-              name: _flashStateErrorNames[i]
-            });
-            break;
-          }
-        }
-        if (_zcSwfVersion !== undefined && ZeroClipboard.version !== _zcSwfVersion) {
-          ZeroClipboard.emit({
-            type: "error",
-            name: "version-mismatch",
-            jsVersion: ZeroClipboard.version,
-            swfVersion: _zcSwfVersion
-          });
-        }
-      }
-    }
-    return ZeroClipboard;
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.off`.
- * @private
- */
-  var _off = function(eventType, listener) {
-    var i, len, foundIndex, events, perEventHandlers;
-    if (arguments.length === 0) {
-      events = _keys(_handlers);
-    } else if (typeof eventType === "string" && eventType) {
-      events = eventType.split(/\s+/);
-    } else if (typeof eventType === "object" && eventType && typeof listener === "undefined") {
-      for (i in eventType) {
-        if (_hasOwn.call(eventType, i) && typeof i === "string" && i && typeof eventType[i] === "function") {
-          ZeroClipboard.off(i, eventType[i]);
-        }
-      }
-    }
-    if (events && events.length) {
-      for (i = 0, len = events.length; i < len; i++) {
-        eventType = events[i].toLowerCase().replace(/^on/, "");
-        perEventHandlers = _handlers[eventType];
-        if (perEventHandlers && perEventHandlers.length) {
-          if (listener) {
-            foundIndex = perEventHandlers.indexOf(listener);
-            while (foundIndex !== -1) {
-              perEventHandlers.splice(foundIndex, 1);
-              foundIndex = perEventHandlers.indexOf(listener, foundIndex);
-            }
-          } else {
-            perEventHandlers.length = 0;
-          }
-        }
-      }
-    }
-    return ZeroClipboard;
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.handlers`.
- * @private
- */
-  var _listeners = function(eventType) {
-    var copy;
-    if (typeof eventType === "string" && eventType) {
-      copy = _deepCopy(_handlers[eventType]) || null;
-    } else {
-      copy = _deepCopy(_handlers);
-    }
-    return copy;
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.emit`.
- * @private
- */
-  var _emit = function(event) {
-    var eventCopy, returnVal, tmp;
-    event = _createEvent(event);
-    if (!event) {
-      return;
-    }
-    if (_preprocessEvent(event)) {
-      return;
-    }
-    if (event.type === "ready" && _flashState.overdue === true) {
-      return ZeroClipboard.emit({
-        type: "error",
-        name: "flash-overdue"
-      });
-    }
-    eventCopy = _extend({}, event);
-    _dispatchCallbacks.call(this, eventCopy);
-    if (event.type === "copy") {
-      tmp = _mapClipDataToFlash(_clipData);
-      returnVal = tmp.data;
-      _clipDataFormatMap = tmp.formatMap;
-    }
-    return returnVal;
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.create`.
- * @private
- */
-  var _create = function() {
-    var previousState = _flashState.sandboxed;
-    _detectSandbox();
-    if (typeof _flashState.ready !== "boolean") {
-      _flashState.ready = false;
-    }
-    if (_flashState.sandboxed !== previousState && _flashState.sandboxed === true) {
-      _flashState.ready = false;
-      ZeroClipboard.emit({
-        type: "error",
-        name: "flash-sandboxed"
-      });
-    } else if (!ZeroClipboard.isFlashUnusable() && _flashState.bridge === null) {
-      var maxWait = _globalConfig.flashLoadTimeout;
-      if (typeof maxWait === "number" && maxWait >= 0) {
-        _flashCheckTimeout = _setTimeout(function() {
-          if (typeof _flashState.deactivated !== "boolean") {
-            _flashState.deactivated = true;
-          }
-          if (_flashState.deactivated === true) {
-            ZeroClipboard.emit({
-              type: "error",
-              name: "flash-deactivated"
-            });
-          }
-        }, maxWait);
-      }
-      _flashState.overdue = false;
-      _embedSwf();
-    }
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.destroy`.
- * @private
- */
-  var _destroy = function() {
-    ZeroClipboard.clearData();
-    ZeroClipboard.blur();
-    ZeroClipboard.emit("destroy");
-    _unembedSwf();
-    ZeroClipboard.off();
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.setData`.
- * @private
- */
-  var _setData = function(format, data) {
-    var dataObj;
-    if (typeof format === "object" && format && typeof data === "undefined") {
-      dataObj = format;
-      ZeroClipboard.clearData();
-    } else if (typeof format === "string" && format) {
-      dataObj = {};
-      dataObj[format] = data;
-    } else {
-      return;
-    }
-    for (var dataFormat in dataObj) {
-      if (typeof dataFormat === "string" && dataFormat && _hasOwn.call(dataObj, dataFormat) && typeof dataObj[dataFormat] === "string" && dataObj[dataFormat]) {
-        _clipData[dataFormat] = dataObj[dataFormat];
-      }
-    }
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.clearData`.
- * @private
- */
-  var _clearData = function(format) {
-    if (typeof format === "undefined") {
-      _deleteOwnProperties(_clipData);
-      _clipDataFormatMap = null;
-    } else if (typeof format === "string" && _hasOwn.call(_clipData, format)) {
-      delete _clipData[format];
-    }
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.getData`.
- * @private
- */
-  var _getData = function(format) {
-    if (typeof format === "undefined") {
-      return _deepCopy(_clipData);
-    } else if (typeof format === "string" && _hasOwn.call(_clipData, format)) {
-      return _clipData[format];
-    }
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.focus`/`ZeroClipboard.activate`.
- * @private
- */
-  var _focus = function(element) {
-    if (!(element && element.nodeType === 1)) {
-      return;
-    }
-    if (_currentElement) {
-      _removeClass(_currentElement, _globalConfig.activeClass);
-      if (_currentElement !== element) {
-        _removeClass(_currentElement, _globalConfig.hoverClass);
-      }
-    }
-    _currentElement = element;
-    _addClass(element, _globalConfig.hoverClass);
-    var newTitle = element.getAttribute("title") || _globalConfig.title;
-    if (typeof newTitle === "string" && newTitle) {
-      var htmlBridge = _getHtmlBridge(_flashState.bridge);
-      if (htmlBridge) {
-        htmlBridge.setAttribute("title", newTitle);
-      }
-    }
-    var useHandCursor = _globalConfig.forceHandCursor === true || _getStyle(element, "cursor") === "pointer";
-    _setHandCursor(useHandCursor);
-    _reposition();
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.blur`/`ZeroClipboard.deactivate`.
- * @private
- */
-  var _blur = function() {
-    var htmlBridge = _getHtmlBridge(_flashState.bridge);
-    if (htmlBridge) {
-      htmlBridge.removeAttribute("title");
-      htmlBridge.style.left = "0px";
-      htmlBridge.style.top = "-9999px";
-      htmlBridge.style.width = "1px";
-      htmlBridge.style.height = "1px";
-    }
-    if (_currentElement) {
-      _removeClass(_currentElement, _globalConfig.hoverClass);
-      _removeClass(_currentElement, _globalConfig.activeClass);
-      _currentElement = null;
-    }
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.activeElement`.
- * @private
- */
-  var _activeElement = function() {
-    return _currentElement || null;
-  };
-  /**
- * Check if a value is a valid HTML4 `ID` or `Name` token.
- * @private
- */
-  var _isValidHtml4Id = function(id) {
-    return typeof id === "string" && id && /^[A-Za-z][A-Za-z0-9_:\-\.]*$/.test(id);
-  };
-  /**
- * Create or update an `event` object, based on the `eventType`.
- * @private
- */
-  var _createEvent = function(event) {
-    var eventType;
-    if (typeof event === "string" && event) {
-      eventType = event;
-      event = {};
-    } else if (typeof event === "object" && event && typeof event.type === "string" && event.type) {
-      eventType = event.type;
-    }
-    if (!eventType) {
-      return;
-    }
-    eventType = eventType.toLowerCase();
-    if (!event.target && (/^(copy|aftercopy|_click)$/.test(eventType) || eventType === "error" && event.name === "clipboard-error")) {
-      event.target = _copyTarget;
-    }
-    _extend(event, {
-      type: eventType,
-      target: event.target || _currentElement || null,
-      relatedTarget: event.relatedTarget || null,
-      currentTarget: _flashState && _flashState.bridge || null,
-      timeStamp: event.timeStamp || _now() || null
-    });
-    var msg = _eventMessages[event.type];
-    if (event.type === "error" && event.name && msg) {
-      msg = msg[event.name];
-    }
-    if (msg) {
-      event.message = msg;
-    }
-    if (event.type === "ready") {
-      _extend(event, {
-        target: null,
-        version: _flashState.version
-      });
-    }
-    if (event.type === "error") {
-      if (_flashStateErrorNameMatchingRegex.test(event.name)) {
-        _extend(event, {
-          target: null,
-          minimumVersion: _minimumFlashVersion
-        });
-      }
-      if (_flashStateEnabledErrorNameMatchingRegex.test(event.name)) {
-        _extend(event, {
-          version: _flashState.version
-        });
-      }
-    }
-    if (event.type === "copy") {
-      event.clipboardData = {
-        setData: ZeroClipboard.setData,
-        clearData: ZeroClipboard.clearData
-      };
-    }
-    if (event.type === "aftercopy") {
-      event = _mapClipResultsFromFlash(event, _clipDataFormatMap);
-    }
-    if (event.target && !event.relatedTarget) {
-      event.relatedTarget = _getRelatedTarget(event.target);
-    }
-    return _addMouseData(event);
-  };
-  /**
- * Get a relatedTarget from the target's `data-clipboard-target` attribute
- * @private
- */
-  var _getRelatedTarget = function(targetEl) {
-    var relatedTargetId = targetEl && targetEl.getAttribute && targetEl.getAttribute("data-clipboard-target");
-    return relatedTargetId ? _document.getElementById(relatedTargetId) : null;
-  };
-  /**
- * Add element and position data to `MouseEvent` instances
- * @private
- */
-  var _addMouseData = function(event) {
-    if (event && /^_(?:click|mouse(?:over|out|down|up|move))$/.test(event.type)) {
-      var srcElement = event.target;
-      var fromElement = event.type === "_mouseover" && event.relatedTarget ? event.relatedTarget : undefined;
-      var toElement = event.type === "_mouseout" && event.relatedTarget ? event.relatedTarget : undefined;
-      var pos = _getElementPosition(srcElement);
-      var screenLeft = _window.screenLeft || _window.screenX || 0;
-      var screenTop = _window.screenTop || _window.screenY || 0;
-      var scrollLeft = _document.body.scrollLeft + _document.documentElement.scrollLeft;
-      var scrollTop = _document.body.scrollTop + _document.documentElement.scrollTop;
-      var pageX = pos.left + (typeof event._stageX === "number" ? event._stageX : 0);
-      var pageY = pos.top + (typeof event._stageY === "number" ? event._stageY : 0);
-      var clientX = pageX - scrollLeft;
-      var clientY = pageY - scrollTop;
-      var screenX = screenLeft + clientX;
-      var screenY = screenTop + clientY;
-      var moveX = typeof event.movementX === "number" ? event.movementX : 0;
-      var moveY = typeof event.movementY === "number" ? event.movementY : 0;
-      delete event._stageX;
-      delete event._stageY;
-      _extend(event, {
-        srcElement: srcElement,
-        fromElement: fromElement,
-        toElement: toElement,
-        screenX: screenX,
-        screenY: screenY,
-        pageX: pageX,
-        pageY: pageY,
-        clientX: clientX,
-        clientY: clientY,
-        x: clientX,
-        y: clientY,
-        movementX: moveX,
-        movementY: moveY,
-        offsetX: 0,
-        offsetY: 0,
-        layerX: 0,
-        layerY: 0
-      });
-    }
-    return event;
-  };
-  /**
- * Determine if an event's registered handlers should be execute synchronously or asynchronously.
- *
- * @returns {boolean}
- * @private
- */
-  var _shouldPerformAsync = function(event) {
-    var eventType = event && typeof event.type === "string" && event.type || "";
-    return !/^(?:(?:before)?copy|destroy)$/.test(eventType);
-  };
-  /**
- * Control if a callback should be executed asynchronously or not.
- *
- * @returns `undefined`
- * @private
- */
-  var _dispatchCallback = function(func, context, args, async) {
-    if (async) {
-      _setTimeout(function() {
-        func.apply(context, args);
-      }, 0);
-    } else {
-      func.apply(context, args);
-    }
-  };
-  /**
- * Handle the actual dispatching of events to client instances.
- *
- * @returns `undefined`
- * @private
- */
-  var _dispatchCallbacks = function(event) {
-    if (!(typeof event === "object" && event && event.type)) {
-      return;
-    }
-    var async = _shouldPerformAsync(event);
-    var wildcardTypeHandlers = _handlers["*"] || [];
-    var specificTypeHandlers = _handlers[event.type] || [];
-    var handlers = wildcardTypeHandlers.concat(specificTypeHandlers);
-    if (handlers && handlers.length) {
-      var i, len, func, context, eventCopy, originalContext = this;
-      for (i = 0, len = handlers.length; i < len; i++) {
-        func = handlers[i];
-        context = originalContext;
-        if (typeof func === "string" && typeof _window[func] === "function") {
-          func = _window[func];
-        }
-        if (typeof func === "object" && func && typeof func.handleEvent === "function") {
-          context = func;
-          func = func.handleEvent;
-        }
-        if (typeof func === "function") {
-          eventCopy = _extend({}, event);
-          _dispatchCallback(func, context, [ eventCopy ], async);
-        }
-      }
-    }
-    return this;
-  };
-  /**
- * Check an `error` event's `name` property to see if Flash has
- * already loaded, which rules out possible `iframe` sandboxing.
- * @private
- */
-  var _getSandboxStatusFromErrorEvent = function(event) {
-    var isSandboxed = null;
-    if (_pageIsFramed === false || event && event.type === "error" && event.name && _errorsThatOnlyOccurAfterFlashLoads.indexOf(event.name) !== -1) {
-      isSandboxed = false;
-    }
-    return isSandboxed;
-  };
-  /**
- * Preprocess any special behaviors, reactions, or state changes after receiving this event.
- * Executes only once per event emitted, NOT once per client.
- * @private
- */
-  var _preprocessEvent = function(event) {
-    var element = event.target || _currentElement || null;
-    var sourceIsSwf = event._source === "swf";
-    delete event._source;
-    switch (event.type) {
-     case "error":
-      var isSandboxed = event.name === "flash-sandboxed" || _getSandboxStatusFromErrorEvent(event);
-      if (typeof isSandboxed === "boolean") {
-        _flashState.sandboxed = isSandboxed;
-      }
-      if (_flashStateErrorNames.indexOf(event.name) !== -1) {
-        _extend(_flashState, {
-          disabled: event.name === "flash-disabled",
-          outdated: event.name === "flash-outdated",
-          unavailable: event.name === "flash-unavailable",
-          degraded: event.name === "flash-degraded",
-          deactivated: event.name === "flash-deactivated",
-          overdue: event.name === "flash-overdue",
-          ready: false
-        });
-      } else if (event.name === "version-mismatch") {
-        _zcSwfVersion = event.swfVersion;
-        _extend(_flashState, {
-          disabled: false,
-          outdated: false,
-          unavailable: false,
-          degraded: false,
-          deactivated: false,
-          overdue: false,
-          ready: false
-        });
-      }
-      _clearTimeoutsAndPolling();
-      break;
-
-     case "ready":
-      _zcSwfVersion = event.swfVersion;
-      var wasDeactivated = _flashState.deactivated === true;
-      _extend(_flashState, {
-        disabled: false,
-        outdated: false,
-        sandboxed: false,
-        unavailable: false,
-        degraded: false,
-        deactivated: false,
-        overdue: wasDeactivated,
-        ready: !wasDeactivated
-      });
-      _clearTimeoutsAndPolling();
-      break;
-
-     case "beforecopy":
-      _copyTarget = element;
-      break;
-
-     case "copy":
-      var textContent, htmlContent, targetEl = event.relatedTarget;
-      if (!(_clipData["text/html"] || _clipData["text/plain"]) && targetEl && (htmlContent = targetEl.value || targetEl.outerHTML || targetEl.innerHTML) && (textContent = targetEl.value || targetEl.textContent || targetEl.innerText)) {
-        event.clipboardData.clearData();
-        event.clipboardData.setData("text/plain", textContent);
-        if (htmlContent !== textContent) {
-          event.clipboardData.setData("text/html", htmlContent);
-        }
-      } else if (!_clipData["text/plain"] && event.target && (textContent = event.target.getAttribute("data-clipboard-text"))) {
-        event.clipboardData.clearData();
-        event.clipboardData.setData("text/plain", textContent);
-      }
-      break;
-
-     case "aftercopy":
-      _queueEmitClipboardErrors(event);
-      ZeroClipboard.clearData();
-      if (element && element !== _safeActiveElement() && element.focus) {
-        element.focus();
-      }
-      break;
-
-     case "_mouseover":
-      ZeroClipboard.focus(element);
-      if (_globalConfig.bubbleEvents === true && sourceIsSwf) {
-        if (element && element !== event.relatedTarget && !_containedBy(event.relatedTarget, element)) {
-          _fireMouseEvent(_extend({}, event, {
-            type: "mouseenter",
-            bubbles: false,
-            cancelable: false
-          }));
-        }
-        _fireMouseEvent(_extend({}, event, {
-          type: "mouseover"
-        }));
-      }
-      break;
-
-     case "_mouseout":
-      ZeroClipboard.blur();
-      if (_globalConfig.bubbleEvents === true && sourceIsSwf) {
-        if (element && element !== event.relatedTarget && !_containedBy(event.relatedTarget, element)) {
-          _fireMouseEvent(_extend({}, event, {
-            type: "mouseleave",
-            bubbles: false,
-            cancelable: false
-          }));
-        }
-        _fireMouseEvent(_extend({}, event, {
-          type: "mouseout"
-        }));
-      }
-      break;
-
-     case "_mousedown":
-      _addClass(element, _globalConfig.activeClass);
-      if (_globalConfig.bubbleEvents === true && sourceIsSwf) {
-        _fireMouseEvent(_extend({}, event, {
-          type: event.type.slice(1)
-        }));
-      }
-      break;
-
-     case "_mouseup":
-      _removeClass(element, _globalConfig.activeClass);
-      if (_globalConfig.bubbleEvents === true && sourceIsSwf) {
-        _fireMouseEvent(_extend({}, event, {
-          type: event.type.slice(1)
-        }));
-      }
-      break;
-
-     case "_click":
-      _copyTarget = null;
-      if (_globalConfig.bubbleEvents === true && sourceIsSwf) {
-        _fireMouseEvent(_extend({}, event, {
-          type: event.type.slice(1)
-        }));
-      }
-      break;
-
-     case "_mousemove":
-      if (_globalConfig.bubbleEvents === true && sourceIsSwf) {
-        _fireMouseEvent(_extend({}, event, {
-          type: event.type.slice(1)
-        }));
-      }
-      break;
-    }
-    if (/^_(?:click|mouse(?:over|out|down|up|move))$/.test(event.type)) {
-      return true;
-    }
-  };
-  /**
- * Check an "aftercopy" event for clipboard errors and emit a corresponding "error" event.
- * @private
- */
-  var _queueEmitClipboardErrors = function(aftercopyEvent) {
-    if (aftercopyEvent.errors && aftercopyEvent.errors.length > 0) {
-      var errorEvent = _deepCopy(aftercopyEvent);
-      _extend(errorEvent, {
-        type: "error",
-        name: "clipboard-error"
-      });
-      delete errorEvent.success;
-      _setTimeout(function() {
-        ZeroClipboard.emit(errorEvent);
-      }, 0);
-    }
-  };
-  /**
- * Dispatch a synthetic MouseEvent.
- *
- * @returns `undefined`
- * @private
- */
-  var _fireMouseEvent = function(event) {
-    if (!(event && typeof event.type === "string" && event)) {
-      return;
-    }
-    var e, target = event.target || null, doc = target && target.ownerDocument || _document, defaults = {
-      view: doc.defaultView || _window,
-      canBubble: true,
-      cancelable: true,
-      detail: event.type === "click" ? 1 : 0,
-      button: typeof event.which === "number" ? event.which - 1 : typeof event.button === "number" ? event.button : doc.createEvent ? 0 : 1
-    }, args = _extend(defaults, event);
-    if (!target) {
-      return;
-    }
-    if (doc.createEvent && target.dispatchEvent) {
-      args = [ args.type, args.canBubble, args.cancelable, args.view, args.detail, args.screenX, args.screenY, args.clientX, args.clientY, args.ctrlKey, args.altKey, args.shiftKey, args.metaKey, args.button, args.relatedTarget ];
-      e = doc.createEvent("MouseEvents");
-      if (e.initMouseEvent) {
-        e.initMouseEvent.apply(e, args);
-        e._source = "js";
-        target.dispatchEvent(e);
-      }
-    }
-  };
-  /**
- * Continuously poll the DOM until either:
- *  (a) the fallback content becomes visible, or
- *  (b) we receive an event from SWF (handled elsewhere)
- *
- * IMPORTANT:
- * This is NOT a necessary check but it can result in significantly faster
- * detection of bad `swfPath` configuration and/or network/server issues [in
- * supported browsers] than waiting for the entire `flashLoadTimeout` duration
- * to elapse before detecting that the SWF cannot be loaded. The detection
- * duration can be anywhere from 10-30 times faster [in supported browsers] by
- * using this approach.
- *
- * @returns `undefined`
- * @private
- */
-  var _watchForSwfFallbackContent = function() {
-    var maxWait = _globalConfig.flashLoadTimeout;
-    if (typeof maxWait === "number" && maxWait >= 0) {
-      var pollWait = Math.min(1e3, maxWait / 10);
-      var fallbackContentId = _globalConfig.swfObjectId + "_fallbackContent";
-      _swfFallbackCheckInterval = _setInterval(function() {
-        var el = _document.getElementById(fallbackContentId);
-        if (_isElementVisible(el)) {
-          _clearTimeoutsAndPolling();
-          _flashState.deactivated = null;
-          ZeroClipboard.emit({
-            type: "error",
-            name: "swf-not-found"
-          });
-        }
-      }, pollWait);
-    }
-  };
-  /**
- * Create the HTML bridge element to embed the Flash object into.
- * @private
- */
-  var _createHtmlBridge = function() {
-    var container = _document.createElement("div");
-    container.id = _globalConfig.containerId;
-    container.className = _globalConfig.containerClass;
-    container.style.position = "absolute";
-    container.style.left = "0px";
-    container.style.top = "-9999px";
-    container.style.width = "1px";
-    container.style.height = "1px";
-    container.style.zIndex = "" + _getSafeZIndex(_globalConfig.zIndex);
-    return container;
-  };
-  /**
- * Get the HTML element container that wraps the Flash bridge object/element.
- * @private
- */
-  var _getHtmlBridge = function(flashBridge) {
-    var htmlBridge = flashBridge && flashBridge.parentNode;
-    while (htmlBridge && htmlBridge.nodeName === "OBJECT" && htmlBridge.parentNode) {
-      htmlBridge = htmlBridge.parentNode;
-    }
-    return htmlBridge || null;
-  };
-  /**
- * Create the SWF object.
- *
- * @returns The SWF object reference.
- * @private
- */
-  var _embedSwf = function() {
-    var len, flashBridge = _flashState.bridge, container = _getHtmlBridge(flashBridge);
-    if (!flashBridge) {
-      var allowScriptAccess = _determineScriptAccess(_window.location.host, _globalConfig);
-      var allowNetworking = allowScriptAccess === "never" ? "none" : "all";
-      var flashvars = _vars(_extend({
-        jsVersion: ZeroClipboard.version
-      }, _globalConfig));
-      var swfUrl = _globalConfig.swfPath + _cacheBust(_globalConfig.swfPath, _globalConfig);
-      container = _createHtmlBridge();
-      var divToBeReplaced = _document.createElement("div");
-      container.appendChild(divToBeReplaced);
-      _document.body.appendChild(container);
-      var tmpDiv = _document.createElement("div");
-      var usingActiveX = _flashState.pluginType === "activex";
-      tmpDiv.innerHTML = '<object id="' + _globalConfig.swfObjectId + '" name="' + _globalConfig.swfObjectId + '" ' + 'width="100%" height="100%" ' + (usingActiveX ? 'classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000"' : 'type="application/x-shockwave-flash" data="' + swfUrl + '"') + ">" + (usingActiveX ? '<param name="movie" value="' + swfUrl + '"/>' : "") + '<param name="allowScriptAccess" value="' + allowScriptAccess + '"/>' + '<param name="allowNetworking" value="' + allowNetworking + '"/>' + '<param name="menu" value="false"/>' + '<param name="wmode" value="transparent"/>' + '<param name="flashvars" value="' + flashvars + '"/>' + '<div id="' + _globalConfig.swfObjectId + '_fallbackContent">&nbsp;</div>' + "</object>";
-      flashBridge = tmpDiv.firstChild;
-      tmpDiv = null;
-      _unwrap(flashBridge).ZeroClipboard = ZeroClipboard;
-      container.replaceChild(flashBridge, divToBeReplaced);
-      _watchForSwfFallbackContent();
-    }
-    if (!flashBridge) {
-      flashBridge = _document[_globalConfig.swfObjectId];
-      if (flashBridge && (len = flashBridge.length)) {
-        flashBridge = flashBridge[len - 1];
-      }
-      if (!flashBridge && container) {
-        flashBridge = container.firstChild;
-      }
-    }
-    _flashState.bridge = flashBridge || null;
-    return flashBridge;
-  };
-  /**
- * Destroy the SWF object.
- * @private
- */
-  var _unembedSwf = function() {
-    var flashBridge = _flashState.bridge;
-    if (flashBridge) {
-      var htmlBridge = _getHtmlBridge(flashBridge);
-      if (htmlBridge) {
-        if (_flashState.pluginType === "activex" && "readyState" in flashBridge) {
-          flashBridge.style.display = "none";
-          (function removeSwfFromIE() {
-            if (flashBridge.readyState === 4) {
-              for (var prop in flashBridge) {
-                if (typeof flashBridge[prop] === "function") {
-                  flashBridge[prop] = null;
-                }
-              }
-              if (flashBridge.parentNode) {
-                flashBridge.parentNode.removeChild(flashBridge);
-              }
-              if (htmlBridge.parentNode) {
-                htmlBridge.parentNode.removeChild(htmlBridge);
-              }
-            } else {
-              _setTimeout(removeSwfFromIE, 10);
-            }
-          })();
-        } else {
-          if (flashBridge.parentNode) {
-            flashBridge.parentNode.removeChild(flashBridge);
-          }
-          if (htmlBridge.parentNode) {
-            htmlBridge.parentNode.removeChild(htmlBridge);
-          }
-        }
-      }
-      _clearTimeoutsAndPolling();
-      _flashState.ready = null;
-      _flashState.bridge = null;
-      _flashState.deactivated = null;
-      _zcSwfVersion = undefined;
-    }
-  };
-  /**
- * Map the data format names of the "clipData" to Flash-friendly names.
- *
- * @returns A new transformed object.
- * @private
- */
-  var _mapClipDataToFlash = function(clipData) {
-    var newClipData = {}, formatMap = {};
-    if (!(typeof clipData === "object" && clipData)) {
-      return;
-    }
-    for (var dataFormat in clipData) {
-      if (dataFormat && _hasOwn.call(clipData, dataFormat) && typeof clipData[dataFormat] === "string" && clipData[dataFormat]) {
-        switch (dataFormat.toLowerCase()) {
-         case "text/plain":
-         case "text":
-         case "air:text":
-         case "flash:text":
-          newClipData.text = clipData[dataFormat];
-          formatMap.text = dataFormat;
-          break;
-
-         case "text/html":
-         case "html":
-         case "air:html":
-         case "flash:html":
-          newClipData.html = clipData[dataFormat];
-          formatMap.html = dataFormat;
-          break;
-
-         case "application/rtf":
-         case "text/rtf":
-         case "rtf":
-         case "richtext":
-         case "air:rtf":
-         case "flash:rtf":
-          newClipData.rtf = clipData[dataFormat];
-          formatMap.rtf = dataFormat;
-          break;
-
-         default:
-          break;
-        }
-      }
-    }
-    return {
-      data: newClipData,
-      formatMap: formatMap
-    };
-  };
-  /**
- * Map the data format names from Flash-friendly names back to their original "clipData" names (via a format mapping).
- *
- * @returns A new transformed object.
- * @private
- */
-  var _mapClipResultsFromFlash = function(clipResults, formatMap) {
-    if (!(typeof clipResults === "object" && clipResults && typeof formatMap === "object" && formatMap)) {
-      return clipResults;
-    }
-    var newResults = {};
-    for (var prop in clipResults) {
-      if (_hasOwn.call(clipResults, prop)) {
-        if (prop === "errors") {
-          newResults[prop] = clipResults[prop] ? clipResults[prop].slice() : [];
-          for (var i = 0, len = newResults[prop].length; i < len; i++) {
-            newResults[prop][i].format = formatMap[newResults[prop][i].format];
-          }
-        } else if (prop !== "success" && prop !== "data") {
-          newResults[prop] = clipResults[prop];
-        } else {
-          newResults[prop] = {};
-          var tmpHash = clipResults[prop];
-          for (var dataFormat in tmpHash) {
-            if (dataFormat && _hasOwn.call(tmpHash, dataFormat) && _hasOwn.call(formatMap, dataFormat)) {
-              newResults[prop][formatMap[dataFormat]] = tmpHash[dataFormat];
-            }
-          }
-        }
-      }
-    }
-    return newResults;
-  };
-  /**
- * Will look at a path, and will create a "?noCache={time}" or "&noCache={time}"
- * query param string to return. Does NOT append that string to the original path.
- * This is useful because ExternalInterface often breaks when a Flash SWF is cached.
- *
- * @returns The `noCache` query param with necessary "?"/"&" prefix.
- * @private
- */
-  var _cacheBust = function(path, options) {
-    var cacheBust = options == null || options && options.cacheBust === true;
-    if (cacheBust) {
-      return (path.indexOf("?") === -1 ? "?" : "&") + "noCache=" + _now();
-    } else {
-      return "";
-    }
-  };
-  /**
- * Creates a query string for the FlashVars param.
- * Does NOT include the cache-busting query param.
- *
- * @returns FlashVars query string
- * @private
- */
-  var _vars = function(options) {
-    var i, len, domain, domains, str = "", trustedOriginsExpanded = [];
-    if (options.trustedDomains) {
-      if (typeof options.trustedDomains === "string") {
-        domains = [ options.trustedDomains ];
-      } else if (typeof options.trustedDomains === "object" && "length" in options.trustedDomains) {
-        domains = options.trustedDomains;
-      }
-    }
-    if (domains && domains.length) {
-      for (i = 0, len = domains.length; i < len; i++) {
-        if (_hasOwn.call(domains, i) && domains[i] && typeof domains[i] === "string") {
-          domain = _extractDomain(domains[i]);
-          if (!domain) {
-            continue;
-          }
-          if (domain === "*") {
-            trustedOriginsExpanded.length = 0;
-            trustedOriginsExpanded.push(domain);
-            break;
-          }
-          trustedOriginsExpanded.push.apply(trustedOriginsExpanded, [ domain, "//" + domain, _window.location.protocol + "//" + domain ]);
-        }
-      }
-    }
-    if (trustedOriginsExpanded.length) {
-      str += "trustedOrigins=" + _encodeURIComponent(trustedOriginsExpanded.join(","));
-    }
-    if (options.forceEnhancedClipboard === true) {
-      str += (str ? "&" : "") + "forceEnhancedClipboard=true";
-    }
-    if (typeof options.swfObjectId === "string" && options.swfObjectId) {
-      str += (str ? "&" : "") + "swfObjectId=" + _encodeURIComponent(options.swfObjectId);
-    }
-    if (typeof options.jsVersion === "string" && options.jsVersion) {
-      str += (str ? "&" : "") + "jsVersion=" + _encodeURIComponent(options.jsVersion);
-    }
-    return str;
-  };
-  /**
- * Extract the domain (e.g. "github.com") from an origin (e.g. "https://github.com") or
- * URL (e.g. "https://github.com/zeroclipboard/zeroclipboard/").
- *
- * @returns the domain
- * @private
- */
-  var _extractDomain = function(originOrUrl) {
-    if (originOrUrl == null || originOrUrl === "") {
-      return null;
-    }
-    originOrUrl = originOrUrl.replace(/^\s+|\s+$/g, "");
-    if (originOrUrl === "") {
-      return null;
-    }
-    var protocolIndex = originOrUrl.indexOf("//");
-    originOrUrl = protocolIndex === -1 ? originOrUrl : originOrUrl.slice(protocolIndex + 2);
-    var pathIndex = originOrUrl.indexOf("/");
-    originOrUrl = pathIndex === -1 ? originOrUrl : protocolIndex === -1 || pathIndex === 0 ? null : originOrUrl.slice(0, pathIndex);
-    if (originOrUrl && originOrUrl.slice(-4).toLowerCase() === ".swf") {
-      return null;
-    }
-    return originOrUrl || null;
-  };
-  /**
- * Set `allowScriptAccess` based on `trustedDomains` and `window.location.host` vs. `swfPath`.
- *
- * @returns The appropriate script access level.
- * @private
- */
-  var _determineScriptAccess = function() {
-    var _extractAllDomains = function(origins) {
-      var i, len, tmp, resultsArray = [];
-      if (typeof origins === "string") {
-        origins = [ origins ];
-      }
-      if (!(typeof origins === "object" && origins && typeof origins.length === "number")) {
-        return resultsArray;
-      }
-      for (i = 0, len = origins.length; i < len; i++) {
-        if (_hasOwn.call(origins, i) && (tmp = _extractDomain(origins[i]))) {
-          if (tmp === "*") {
-            resultsArray.length = 0;
-            resultsArray.push("*");
-            break;
-          }
-          if (resultsArray.indexOf(tmp) === -1) {
-            resultsArray.push(tmp);
-          }
-        }
-      }
-      return resultsArray;
-    };
-    return function(currentDomain, configOptions) {
-      var swfDomain = _extractDomain(configOptions.swfPath);
-      if (swfDomain === null) {
-        swfDomain = currentDomain;
-      }
-      var trustedDomains = _extractAllDomains(configOptions.trustedDomains);
-      var len = trustedDomains.length;
-      if (len > 0) {
-        if (len === 1 && trustedDomains[0] === "*") {
-          return "always";
-        }
-        if (trustedDomains.indexOf(currentDomain) !== -1) {
-          if (len === 1 && currentDomain === swfDomain) {
-            return "sameDomain";
-          }
-          return "always";
-        }
-      }
-      return "never";
-    };
-  }();
-  /**
- * Get the currently active/focused DOM element.
- *
- * @returns the currently active/focused element, or `null`
- * @private
- */
-  var _safeActiveElement = function() {
-    try {
-      return _document.activeElement;
-    } catch (err) {
-      return null;
-    }
-  };
-  /**
- * Add a class to an element, if it doesn't already have it.
- *
- * @returns The element, with its new class added.
- * @private
- */
-  var _addClass = function(element, value) {
-    var c, cl, className, classNames = [];
-    if (typeof value === "string" && value) {
-      classNames = value.split(/\s+/);
-    }
-    if (element && element.nodeType === 1 && classNames.length > 0) {
-      if (element.classList) {
-        for (c = 0, cl = classNames.length; c < cl; c++) {
-          element.classList.add(classNames[c]);
-        }
-      } else if (element.hasOwnProperty("className")) {
-        className = " " + element.className + " ";
-        for (c = 0, cl = classNames.length; c < cl; c++) {
-          if (className.indexOf(" " + classNames[c] + " ") === -1) {
-            className += classNames[c] + " ";
-          }
-        }
-        element.className = className.replace(/^\s+|\s+$/g, "");
-      }
-    }
-    return element;
-  };
-  /**
- * Remove a class from an element, if it has it.
- *
- * @returns The element, with its class removed.
- * @private
- */
-  var _removeClass = function(element, value) {
-    var c, cl, className, classNames = [];
-    if (typeof value === "string" && value) {
-      classNames = value.split(/\s+/);
-    }
-    if (element && element.nodeType === 1 && classNames.length > 0) {
-      if (element.classList && element.classList.length > 0) {
-        for (c = 0, cl = classNames.length; c < cl; c++) {
-          element.classList.remove(classNames[c]);
-        }
-      } else if (element.className) {
-        className = (" " + element.className + " ").replace(/[\r\n\t]/g, " ");
-        for (c = 0, cl = classNames.length; c < cl; c++) {
-          className = className.replace(" " + classNames[c] + " ", " ");
-        }
-        element.className = className.replace(/^\s+|\s+$/g, "");
-      }
-    }
-    return element;
-  };
-  /**
- * Attempt to interpret the element's CSS styling. If `prop` is `"cursor"`,
- * then we assume that it should be a hand ("pointer") cursor if the element
- * is an anchor element ("a" tag).
- *
- * @returns The computed style property.
- * @private
- */
-  var _getStyle = function(el, prop) {
-    var value = _getComputedStyle(el, null).getPropertyValue(prop);
-    if (prop === "cursor") {
-      if (!value || value === "auto") {
-        if (el.nodeName === "A") {
-          return "pointer";
-        }
-      }
-    }
-    return value;
-  };
-  /**
- * Get the absolutely positioned coordinates of a DOM element.
- *
- * @returns Object containing the element's position, width, and height.
- * @private
- */
-  var _getElementPosition = function(el) {
-    var pos = {
-      left: 0,
-      top: 0,
-      width: 0,
-      height: 0
-    };
-    if (el.getBoundingClientRect) {
-      var elRect = el.getBoundingClientRect();
-      var pageXOffset = _window.pageXOffset;
-      var pageYOffset = _window.pageYOffset;
-      var leftBorderWidth = _document.documentElement.clientLeft || 0;
-      var topBorderWidth = _document.documentElement.clientTop || 0;
-      var leftBodyOffset = 0;
-      var topBodyOffset = 0;
-      if (_getStyle(_document.body, "position") === "relative") {
-        var bodyRect = _document.body.getBoundingClientRect();
-        var htmlRect = _document.documentElement.getBoundingClientRect();
-        leftBodyOffset = bodyRect.left - htmlRect.left || 0;
-        topBodyOffset = bodyRect.top - htmlRect.top || 0;
-      }
-      pos.left = elRect.left + pageXOffset - leftBorderWidth - leftBodyOffset;
-      pos.top = elRect.top + pageYOffset - topBorderWidth - topBodyOffset;
-      pos.width = "width" in elRect ? elRect.width : elRect.right - elRect.left;
-      pos.height = "height" in elRect ? elRect.height : elRect.bottom - elRect.top;
-    }
-    return pos;
-  };
-  /**
- * Determine is an element is visible somewhere within the document (page).
- *
- * @returns Boolean
- * @private
- */
-  var _isElementVisible = function(el) {
-    if (!el) {
-      return false;
-    }
-    var styles = _getComputedStyle(el, null);
-    var hasCssHeight = _parseFloat(styles.height) > 0;
-    var hasCssWidth = _parseFloat(styles.width) > 0;
-    var hasCssTop = _parseFloat(styles.top) >= 0;
-    var hasCssLeft = _parseFloat(styles.left) >= 0;
-    var cssKnows = hasCssHeight && hasCssWidth && hasCssTop && hasCssLeft;
-    var rect = cssKnows ? null : _getElementPosition(el);
-    var isVisible = styles.display !== "none" && styles.visibility !== "collapse" && (cssKnows || !!rect && (hasCssHeight || rect.height > 0) && (hasCssWidth || rect.width > 0) && (hasCssTop || rect.top >= 0) && (hasCssLeft || rect.left >= 0));
-    return isVisible;
-  };
-  /**
- * Clear all existing timeouts and interval polling delegates.
- *
- * @returns `undefined`
- * @private
- */
-  var _clearTimeoutsAndPolling = function() {
-    _clearTimeout(_flashCheckTimeout);
-    _flashCheckTimeout = 0;
-    _clearInterval(_swfFallbackCheckInterval);
-    _swfFallbackCheckInterval = 0;
-  };
-  /**
- * Reposition the Flash object to cover the currently activated element.
- *
- * @returns `undefined`
- * @private
- */
-  var _reposition = function() {
-    var htmlBridge;
-    if (_currentElement && (htmlBridge = _getHtmlBridge(_flashState.bridge))) {
-      var pos = _getElementPosition(_currentElement);
-      _extend(htmlBridge.style, {
-        width: pos.width + "px",
-        height: pos.height + "px",
-        top: pos.top + "px",
-        left: pos.left + "px",
-        zIndex: "" + _getSafeZIndex(_globalConfig.zIndex)
-      });
-    }
-  };
-  /**
- * Sends a signal to the Flash object to display the hand cursor if `true`.
- *
- * @returns `undefined`
- * @private
- */
-  var _setHandCursor = function(enabled) {
-    if (_flashState.ready === true) {
-      if (_flashState.bridge && typeof _flashState.bridge.setHandCursor === "function") {
-        _flashState.bridge.setHandCursor(enabled);
-      } else {
-        _flashState.ready = false;
-      }
-    }
-  };
-  /**
- * Get a safe value for `zIndex`
- *
- * @returns an integer, or "auto"
- * @private
- */
-  var _getSafeZIndex = function(val) {
-    if (/^(?:auto|inherit)$/.test(val)) {
-      return val;
-    }
-    var zIndex;
-    if (typeof val === "number" && !_isNaN(val)) {
-      zIndex = val;
-    } else if (typeof val === "string") {
-      zIndex = _getSafeZIndex(_parseInt(val, 10));
-    }
-    return typeof zIndex === "number" ? zIndex : "auto";
-  };
-  /**
- * Attempt to detect if ZeroClipboard is executing inside of a sandboxed iframe.
- * If it is, Flash Player cannot be used, so ZeroClipboard is dead in the water.
- *
- * @see {@link http://lists.w3.org/Archives/Public/public-whatwg-archive/2014Dec/0002.html}
- * @see {@link https://github.com/zeroclipboard/zeroclipboard/issues/511}
- * @see {@link http://zeroclipboard.org/test-iframes.html}
- *
- * @returns `true` (is sandboxed), `false` (is not sandboxed), or `null` (uncertain) 
- * @private
- */
-  var _detectSandbox = function(doNotReassessFlashSupport) {
-    var effectiveScriptOrigin, frame, frameError, previousState = _flashState.sandboxed, isSandboxed = null;
-    doNotReassessFlashSupport = doNotReassessFlashSupport === true;
-    if (_pageIsFramed === false) {
-      isSandboxed = false;
-    } else {
-      try {
-        frame = window.frameElement || null;
-      } catch (e) {
-        frameError = {
-          name: e.name,
-          message: e.message
-        };
-      }
-      if (frame && frame.nodeType === 1 && frame.nodeName === "IFRAME") {
-        try {
-          isSandboxed = frame.hasAttribute("sandbox");
-        } catch (e) {
-          isSandboxed = null;
-        }
-      } else {
-        try {
-          effectiveScriptOrigin = document.domain || null;
-        } catch (e) {
-          effectiveScriptOrigin = null;
-        }
-        if (effectiveScriptOrigin === null || frameError && frameError.name === "SecurityError" && /(^|[\s\(\[@])sandbox(es|ed|ing|[\s\.,!\)\]@]|$)/.test(frameError.message.toLowerCase())) {
-          isSandboxed = true;
-        }
-      }
-    }
-    _flashState.sandboxed = isSandboxed;
-    if (previousState !== isSandboxed && !doNotReassessFlashSupport) {
-      _detectFlashSupport(_ActiveXObject);
-    }
-    return isSandboxed;
-  };
-  /**
- * Detect the Flash Player status, version, and plugin type.
- *
- * @see {@link https://code.google.com/p/doctype-mirror/wiki/ArticleDetectFlash#The_code}
- * @see {@link http://stackoverflow.com/questions/12866060/detecting-pepper-ppapi-flash-with-javascript}
- *
- * @returns `undefined`
- * @private
- */
-  var _detectFlashSupport = function(ActiveXObject) {
-    var plugin, ax, mimeType, hasFlash = false, isActiveX = false, isPPAPI = false, flashVersion = "";
-    /**
-   * Derived from Apple's suggested sniffer.
-   * @param {String} desc e.g. "Shockwave Flash 7.0 r61"
-   * @returns {String} "7.0.61"
-   * @private
-   */
-    function parseFlashVersion(desc) {
-      var matches = desc.match(/[\d]+/g);
-      matches.length = 3;
-      return matches.join(".");
-    }
-    function isPepperFlash(flashPlayerFileName) {
-      return !!flashPlayerFileName && (flashPlayerFileName = flashPlayerFileName.toLowerCase()) && (/^(pepflashplayer\.dll|libpepflashplayer\.so|pepperflashplayer\.plugin)$/.test(flashPlayerFileName) || flashPlayerFileName.slice(-13) === "chrome.plugin");
-    }
-    function inspectPlugin(plugin) {
-      if (plugin) {
-        hasFlash = true;
-        if (plugin.version) {
-          flashVersion = parseFlashVersion(plugin.version);
-        }
-        if (!flashVersion && plugin.description) {
-          flashVersion = parseFlashVersion(plugin.description);
-        }
-        if (plugin.filename) {
-          isPPAPI = isPepperFlash(plugin.filename);
-        }
-      }
-    }
-    if (_navigator.plugins && _navigator.plugins.length) {
-      plugin = _navigator.plugins["Shockwave Flash"];
-      inspectPlugin(plugin);
-      if (_navigator.plugins["Shockwave Flash 2.0"]) {
-        hasFlash = true;
-        flashVersion = "2.0.0.11";
-      }
-    } else if (_navigator.mimeTypes && _navigator.mimeTypes.length) {
-      mimeType = _navigator.mimeTypes["application/x-shockwave-flash"];
-      plugin = mimeType && mimeType.enabledPlugin;
-      inspectPlugin(plugin);
-    } else if (typeof ActiveXObject !== "undefined") {
-      isActiveX = true;
-      try {
-        ax = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.7");
-        hasFlash = true;
-        flashVersion = parseFlashVersion(ax.GetVariable("$version"));
-      } catch (e1) {
-        try {
-          ax = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.6");
-          hasFlash = true;
-          flashVersion = "6.0.21";
-        } catch (e2) {
-          try {
-            ax = new ActiveXObject("ShockwaveFlash.ShockwaveFlash");
-            hasFlash = true;
-            flashVersion = parseFlashVersion(ax.GetVariable("$version"));
-          } catch (e3) {
-            isActiveX = false;
-          }
-        }
-      }
-    }
-    _flashState.disabled = hasFlash !== true;
-    _flashState.outdated = flashVersion && _parseFloat(flashVersion) < _parseFloat(_minimumFlashVersion);
-    _flashState.version = flashVersion || "0.0.0";
-    _flashState.pluginType = isPPAPI ? "pepper" : isActiveX ? "activex" : hasFlash ? "netscape" : "unknown";
-  };
-  /**
- * Invoke the Flash detection algorithms immediately upon inclusion so we're not waiting later.
- */
-  _detectFlashSupport(_ActiveXObject);
-  /**
- * Always assess the `sandboxed` state of the page at important Flash-related moments.
- */
-  _detectSandbox(true);
-  /**
- * A shell constructor for `ZeroClipboard` client instances.
- *
- * @constructor
- */
-  var ZeroClipboard = function() {
-    if (!(this instanceof ZeroClipboard)) {
-      return new ZeroClipboard();
-    }
-    if (typeof ZeroClipboard._createClient === "function") {
-      ZeroClipboard._createClient.apply(this, _args(arguments));
-    }
-  };
-  /**
- * The ZeroClipboard library's version number.
- *
- * @static
- * @readonly
- * @property {string}
- */
-  _defineProperty(ZeroClipboard, "version", {
-    value: "2.2.0",
-    writable: false,
-    configurable: true,
-    enumerable: true
-  });
-  /**
- * Update or get a copy of the ZeroClipboard global configuration.
- * Returns a copy of the current/updated configuration.
- *
- * @returns Object
- * @static
- */
-  ZeroClipboard.config = function() {
-    return _config.apply(this, _args(arguments));
-  };
-  /**
- * Diagnostic method that describes the state of the browser, Flash Player, and ZeroClipboard.
- *
- * @returns Object
- * @static
- */
-  ZeroClipboard.state = function() {
-    return _state.apply(this, _args(arguments));
-  };
-  /**
- * Check if Flash is unusable for any reason: disabled, outdated, deactivated, etc.
- *
- * @returns Boolean
- * @static
- */
-  ZeroClipboard.isFlashUnusable = function() {
-    return _isFlashUnusable.apply(this, _args(arguments));
-  };
-  /**
- * Register an event listener.
- *
- * @returns `ZeroClipboard`
- * @static
- */
-  ZeroClipboard.on = function() {
-    return _on.apply(this, _args(arguments));
-  };
-  /**
- * Unregister an event listener.
- * If no `listener` function/object is provided, it will unregister all listeners for the provided `eventType`.
- * If no `eventType` is provided, it will unregister all listeners for every event type.
- *
- * @returns `ZeroClipboard`
- * @static
- */
-  ZeroClipboard.off = function() {
-    return _off.apply(this, _args(arguments));
-  };
-  /**
- * Retrieve event listeners for an `eventType`.
- * If no `eventType` is provided, it will retrieve all listeners for every event type.
- *
- * @returns array of listeners for the `eventType`; if no `eventType`, then a map/hash object of listeners for all event types; or `null`
- */
-  ZeroClipboard.handlers = function() {
-    return _listeners.apply(this, _args(arguments));
-  };
-  /**
- * Event emission receiver from the Flash object, forwarding to any registered JavaScript event listeners.
- *
- * @returns For the "copy" event, returns the Flash-friendly "clipData" object; otherwise `undefined`.
- * @static
- */
-  ZeroClipboard.emit = function() {
-    return _emit.apply(this, _args(arguments));
-  };
-  /**
- * Create and embed the Flash object.
- *
- * @returns The Flash object
- * @static
- */
-  ZeroClipboard.create = function() {
-    return _create.apply(this, _args(arguments));
-  };
-  /**
- * Self-destruct and clean up everything, including the embedded Flash object.
- *
- * @returns `undefined`
- * @static
- */
-  ZeroClipboard.destroy = function() {
-    return _destroy.apply(this, _args(arguments));
-  };
-  /**
- * Set the pending data for clipboard injection.
- *
- * @returns `undefined`
- * @static
- */
-  ZeroClipboard.setData = function() {
-    return _setData.apply(this, _args(arguments));
-  };
-  /**
- * Clear the pending data for clipboard injection.
- * If no `format` is provided, all pending data formats will be cleared.
- *
- * @returns `undefined`
- * @static
- */
-  ZeroClipboard.clearData = function() {
-    return _clearData.apply(this, _args(arguments));
-  };
-  /**
- * Get a copy of the pending data for clipboard injection.
- * If no `format` is provided, a copy of ALL pending data formats will be returned.
- *
- * @returns `String` or `Object`
- * @static
- */
-  ZeroClipboard.getData = function() {
-    return _getData.apply(this, _args(arguments));
-  };
-  /**
- * Sets the current HTML object that the Flash object should overlay. This will put the global
- * Flash object on top of the current element; depending on the setup, this may also set the
- * pending clipboard text data as well as the Flash object's wrapping element's title attribute
- * based on the underlying HTML element and ZeroClipboard configuration.
- *
- * @returns `undefined`
- * @static
- */
-  ZeroClipboard.focus = ZeroClipboard.activate = function() {
-    return _focus.apply(this, _args(arguments));
-  };
-  /**
- * Un-overlays the Flash object. This will put the global Flash object off-screen; depending on
- * the setup, this may also unset the Flash object's wrapping element's title attribute based on
- * the underlying HTML element and ZeroClipboard configuration.
- *
- * @returns `undefined`
- * @static
- */
-  ZeroClipboard.blur = ZeroClipboard.deactivate = function() {
-    return _blur.apply(this, _args(arguments));
-  };
-  /**
- * Returns the currently focused/"activated" HTML element that the Flash object is wrapping.
- *
- * @returns `HTMLElement` or `null`
- * @static
- */
-  ZeroClipboard.activeElement = function() {
-    return _activeElement.apply(this, _args(arguments));
-  };
-  /**
- * Keep track of the ZeroClipboard client instance counter.
- */
-  var _clientIdCounter = 0;
-  /**
- * Keep track of the state of the client instances.
- *
- * Entry structure:
- *   _clientMeta[client.id] = {
- *     instance: client,
- *     elements: [],
- *     handlers: {}
- *   };
- */
-  var _clientMeta = {};
-  /**
- * Keep track of the ZeroClipboard clipped elements counter.
- */
-  var _elementIdCounter = 0;
-  /**
- * Keep track of the state of the clipped element relationships to clients.
- *
- * Entry structure:
- *   _elementMeta[element.zcClippingId] = [client1.id, client2.id];
- */
-  var _elementMeta = {};
-  /**
- * Keep track of the state of the mouse event handlers for clipped elements.
- *
- * Entry structure:
- *   _mouseHandlers[element.zcClippingId] = {
- *     mouseover:  function(event) {},
- *     mouseout:   function(event) {},
- *     mouseenter: function(event) {},
- *     mouseleave: function(event) {},
- *     mousemove:  function(event) {}
- *   };
- */
-  var _mouseHandlers = {};
-  /**
- * Extending the ZeroClipboard configuration defaults for the Client module.
- */
-  _extend(_globalConfig, {
-    autoActivate: true
-  });
-  /**
- * The real constructor for `ZeroClipboard` client instances.
- * @private
- */
-  var _clientConstructor = function(elements) {
-    var client = this;
-    client.id = "" + _clientIdCounter++;
-    _clientMeta[client.id] = {
-      instance: client,
-      elements: [],
-      handlers: {}
-    };
-    if (elements) {
-      client.clip(elements);
-    }
-    ZeroClipboard.on("*", function(event) {
-      return client.emit(event);
-    });
-    ZeroClipboard.on("destroy", function() {
-      client.destroy();
-    });
-    ZeroClipboard.create();
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.Client.prototype.on`.
- * @private
- */
-  var _clientOn = function(eventType, listener) {
-    var i, len, events, added = {}, meta = _clientMeta[this.id], handlers = meta && meta.handlers;
-    if (!meta) {
-      throw new Error("Attempted to add new listener(s) to a destroyed ZeroClipboard client instance");
-    }
-    if (typeof eventType === "string" && eventType) {
-      events = eventType.toLowerCase().split(/\s+/);
-    } else if (typeof eventType === "object" && eventType && typeof listener === "undefined") {
-      for (i in eventType) {
-        if (_hasOwn.call(eventType, i) && typeof i === "string" && i && typeof eventType[i] === "function") {
-          this.on(i, eventType[i]);
-        }
-      }
-    }
-    if (events && events.length) {
-      for (i = 0, len = events.length; i < len; i++) {
-        eventType = events[i].replace(/^on/, "");
-        added[eventType] = true;
-        if (!handlers[eventType]) {
-          handlers[eventType] = [];
-        }
-        handlers[eventType].push(listener);
-      }
-      if (added.ready && _flashState.ready) {
-        this.emit({
-          type: "ready",
-          client: this
-        });
-      }
-      if (added.error) {
-        for (i = 0, len = _flashStateErrorNames.length; i < len; i++) {
-          if (_flashState[_flashStateErrorNames[i].replace(/^flash-/, "")]) {
-            this.emit({
-              type: "error",
-              name: _flashStateErrorNames[i],
-              client: this
-            });
-            break;
-          }
-        }
-        if (_zcSwfVersion !== undefined && ZeroClipboard.version !== _zcSwfVersion) {
-          this.emit({
-            type: "error",
-            name: "version-mismatch",
-            jsVersion: ZeroClipboard.version,
-            swfVersion: _zcSwfVersion
-          });
-        }
-      }
-    }
-    return this;
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.Client.prototype.off`.
- * @private
- */
-  var _clientOff = function(eventType, listener) {
-    var i, len, foundIndex, events, perEventHandlers, meta = _clientMeta[this.id], handlers = meta && meta.handlers;
-    if (!handlers) {
-      return this;
-    }
-    if (arguments.length === 0) {
-      events = _keys(handlers);
-    } else if (typeof eventType === "string" && eventType) {
-      events = eventType.split(/\s+/);
-    } else if (typeof eventType === "object" && eventType && typeof listener === "undefined") {
-      for (i in eventType) {
-        if (_hasOwn.call(eventType, i) && typeof i === "string" && i && typeof eventType[i] === "function") {
-          this.off(i, eventType[i]);
-        }
-      }
-    }
-    if (events && events.length) {
-      for (i = 0, len = events.length; i < len; i++) {
-        eventType = events[i].toLowerCase().replace(/^on/, "");
-        perEventHandlers = handlers[eventType];
-        if (perEventHandlers && perEventHandlers.length) {
-          if (listener) {
-            foundIndex = perEventHandlers.indexOf(listener);
-            while (foundIndex !== -1) {
-              perEventHandlers.splice(foundIndex, 1);
-              foundIndex = perEventHandlers.indexOf(listener, foundIndex);
-            }
-          } else {
-            perEventHandlers.length = 0;
-          }
-        }
-      }
-    }
-    return this;
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.Client.prototype.handlers`.
- * @private
- */
-  var _clientListeners = function(eventType) {
-    var copy = null, handlers = _clientMeta[this.id] && _clientMeta[this.id].handlers;
-    if (handlers) {
-      if (typeof eventType === "string" && eventType) {
-        copy = handlers[eventType] ? handlers[eventType].slice(0) : [];
-      } else {
-        copy = _deepCopy(handlers);
-      }
-    }
-    return copy;
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.Client.prototype.emit`.
- * @private
- */
-  var _clientEmit = function(event) {
-    if (_clientShouldEmit.call(this, event)) {
-      if (typeof event === "object" && event && typeof event.type === "string" && event.type) {
-        event = _extend({}, event);
-      }
-      var eventCopy = _extend({}, _createEvent(event), {
-        client: this
-      });
-      _clientDispatchCallbacks.call(this, eventCopy);
-    }
-    return this;
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.Client.prototype.clip`.
- * @private
- */
-  var _clientClip = function(elements) {
-    if (!_clientMeta[this.id]) {
-      throw new Error("Attempted to clip element(s) to a destroyed ZeroClipboard client instance");
-    }
-    elements = _prepClip(elements);
-    for (var i = 0; i < elements.length; i++) {
-      if (_hasOwn.call(elements, i) && elements[i] && elements[i].nodeType === 1) {
-        if (!elements[i].zcClippingId) {
-          elements[i].zcClippingId = "zcClippingId_" + _elementIdCounter++;
-          _elementMeta[elements[i].zcClippingId] = [ this.id ];
-          if (_globalConfig.autoActivate === true) {
-            _addMouseHandlers(elements[i]);
-          }
-        } else if (_elementMeta[elements[i].zcClippingId].indexOf(this.id) === -1) {
-          _elementMeta[elements[i].zcClippingId].push(this.id);
-        }
-        var clippedElements = _clientMeta[this.id] && _clientMeta[this.id].elements;
-        if (clippedElements.indexOf(elements[i]) === -1) {
-          clippedElements.push(elements[i]);
-        }
-      }
-    }
-    return this;
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.Client.prototype.unclip`.
- * @private
- */
-  var _clientUnclip = function(elements) {
-    var meta = _clientMeta[this.id];
-    if (!meta) {
-      return this;
-    }
-    var clippedElements = meta.elements;
-    var arrayIndex;
-    if (typeof elements === "undefined") {
-      elements = clippedElements.slice(0);
-    } else {
-      elements = _prepClip(elements);
-    }
-    for (var i = elements.length; i--; ) {
-      if (_hasOwn.call(elements, i) && elements[i] && elements[i].nodeType === 1) {
-        arrayIndex = 0;
-        while ((arrayIndex = clippedElements.indexOf(elements[i], arrayIndex)) !== -1) {
-          clippedElements.splice(arrayIndex, 1);
-        }
-        var clientIds = _elementMeta[elements[i].zcClippingId];
-        if (clientIds) {
-          arrayIndex = 0;
-          while ((arrayIndex = clientIds.indexOf(this.id, arrayIndex)) !== -1) {
-            clientIds.splice(arrayIndex, 1);
-          }
-          if (clientIds.length === 0) {
-            if (_globalConfig.autoActivate === true) {
-              _removeMouseHandlers(elements[i]);
-            }
-            delete elements[i].zcClippingId;
-          }
-        }
-      }
-    }
-    return this;
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.Client.prototype.elements`.
- * @private
- */
-  var _clientElements = function() {
-    var meta = _clientMeta[this.id];
-    return meta && meta.elements ? meta.elements.slice(0) : [];
-  };
-  /**
- * The underlying implementation of `ZeroClipboard.Client.prototype.destroy`.
- * @private
- */
-  var _clientDestroy = function() {
-    if (!_clientMeta[this.id]) {
-      return;
-    }
-    this.unclip();
-    this.off();
-    delete _clientMeta[this.id];
-  };
-  /**
- * Inspect an Event to see if the Client (`this`) should honor it for emission.
- * @private
- */
-  var _clientShouldEmit = function(event) {
-    if (!(event && event.type)) {
-      return false;
-    }
-    if (event.client && event.client !== this) {
-      return false;
-    }
-    var meta = _clientMeta[this.id];
-    var clippedEls = meta && meta.elements;
-    var hasClippedEls = !!clippedEls && clippedEls.length > 0;
-    var goodTarget = !event.target || hasClippedEls && clippedEls.indexOf(event.target) !== -1;
-    var goodRelTarget = event.relatedTarget && hasClippedEls && clippedEls.indexOf(event.relatedTarget) !== -1;
-    var goodClient = event.client && event.client === this;
-    if (!meta || !(goodTarget || goodRelTarget || goodClient)) {
-      return false;
-    }
-    return true;
-  };
-  /**
- * Handle the actual dispatching of events to a client instance.
- *
- * @returns `undefined`
- * @private
- */
-  var _clientDispatchCallbacks = function(event) {
-    var meta = _clientMeta[this.id];
-    if (!(typeof event === "object" && event && event.type && meta)) {
-      return;
-    }
-    var async = _shouldPerformAsync(event);
-    var wildcardTypeHandlers = meta && meta.handlers["*"] || [];
-    var specificTypeHandlers = meta && meta.handlers[event.type] || [];
-    var handlers = wildcardTypeHandlers.concat(specificTypeHandlers);
-    if (handlers && handlers.length) {
-      var i, len, func, context, eventCopy, originalContext = this;
-      for (i = 0, len = handlers.length; i < len; i++) {
-        func = handlers[i];
-        context = originalContext;
-        if (typeof func === "string" && typeof _window[func] === "function") {
-          func = _window[func];
-        }
-        if (typeof func === "object" && func && typeof func.handleEvent === "function") {
-          context = func;
-          func = func.handleEvent;
-        }
-        if (typeof func === "function") {
-          eventCopy = _extend({}, event);
-          _dispatchCallback(func, context, [ eventCopy ], async);
-        }
-      }
-    }
-  };
-  /**
- * Prepares the elements for clipping/unclipping.
- *
- * @returns An Array of elements.
- * @private
- */
-  var _prepClip = function(elements) {
-    if (typeof elements === "string") {
-      elements = [];
-    }
-    return typeof elements.length !== "number" ? [ elements ] : elements;
-  };
-  /**
- * Add a `mouseover` handler function for a clipped element.
- *
- * @returns `undefined`
- * @private
- */
-  var _addMouseHandlers = function(element) {
-    if (!(element && element.nodeType === 1)) {
-      return;
-    }
-    var _suppressMouseEvents = function(event) {
-      if (!(event || (event = _window.event))) {
-        return;
-      }
-      if (event._source !== "js") {
-        event.stopImmediatePropagation();
-        event.preventDefault();
-      }
-      delete event._source;
-    };
-    var _elementMouseOver = function(event) {
-      if (!(event || (event = _window.event))) {
-        return;
-      }
-      _suppressMouseEvents(event);
-      ZeroClipboard.focus(element);
-    };
-    element.addEventListener("mouseover", _elementMouseOver, false);
-    element.addEventListener("mouseout", _suppressMouseEvents, false);
-    element.addEventListener("mouseenter", _suppressMouseEvents, false);
-    element.addEventListener("mouseleave", _suppressMouseEvents, false);
-    element.addEventListener("mousemove", _suppressMouseEvents, false);
-    _mouseHandlers[element.zcClippingId] = {
-      mouseover: _elementMouseOver,
-      mouseout: _suppressMouseEvents,
-      mouseenter: _suppressMouseEvents,
-      mouseleave: _suppressMouseEvents,
-      mousemove: _suppressMouseEvents
-    };
-  };
-  /**
- * Remove a `mouseover` handler function for a clipped element.
- *
- * @returns `undefined`
- * @private
- */
-  var _removeMouseHandlers = function(element) {
-    if (!(element && element.nodeType === 1)) {
-      return;
-    }
-    var mouseHandlers = _mouseHandlers[element.zcClippingId];
-    if (!(typeof mouseHandlers === "object" && mouseHandlers)) {
-      return;
-    }
-    var key, val, mouseEvents = [ "move", "leave", "enter", "out", "over" ];
-    for (var i = 0, len = mouseEvents.length; i < len; i++) {
-      key = "mouse" + mouseEvents[i];
-      val = mouseHandlers[key];
-      if (typeof val === "function") {
-        element.removeEventListener(key, val, false);
-      }
-    }
-    delete _mouseHandlers[element.zcClippingId];
-  };
-  /**
- * Creates a new ZeroClipboard client instance.
- * Optionally, auto-`clip` an element or collection of elements.
- *
- * @constructor
- */
-  ZeroClipboard._createClient = function() {
-    _clientConstructor.apply(this, _args(arguments));
-  };
-  /**
- * Register an event listener to the client.
- *
- * @returns `this`
- */
-  ZeroClipboard.prototype.on = function() {
-    return _clientOn.apply(this, _args(arguments));
-  };
-  /**
- * Unregister an event handler from the client.
- * If no `listener` function/object is provided, it will unregister all handlers for the provided `eventType`.
- * If no `eventType` is provided, it will unregister all handlers for every event type.
- *
- * @returns `this`
- */
-  ZeroClipboard.prototype.off = function() {
-    return _clientOff.apply(this, _args(arguments));
-  };
-  /**
- * Retrieve event listeners for an `eventType` from the client.
- * If no `eventType` is provided, it will retrieve all listeners for every event type.
- *
- * @returns array of listeners for the `eventType`; if no `eventType`, then a map/hash object of listeners for all event types; or `null`
- */
-  ZeroClipboard.prototype.handlers = function() {
-    return _clientListeners.apply(this, _args(arguments));
-  };
-  /**
- * Event emission receiver from the Flash object for this client's registered JavaScript event listeners.
- *
- * @returns For the "copy" event, returns the Flash-friendly "clipData" object; otherwise `undefined`.
- */
-  ZeroClipboard.prototype.emit = function() {
-    return _clientEmit.apply(this, _args(arguments));
-  };
-  /**
- * Register clipboard actions for new element(s) to the client.
- *
- * @returns `this`
- */
-  ZeroClipboard.prototype.clip = function() {
-    return _clientClip.apply(this, _args(arguments));
-  };
-  /**
- * Unregister the clipboard actions of previously registered element(s) on the page.
- * If no elements are provided, ALL registered elements will be unregistered.
- *
- * @returns `this`
- */
-  ZeroClipboard.prototype.unclip = function() {
-    return _clientUnclip.apply(this, _args(arguments));
-  };
-  /**
- * Get all of the elements to which this client is clipped.
- *
- * @returns array of clipped elements
- */
-  ZeroClipboard.prototype.elements = function() {
-    return _clientElements.apply(this, _args(arguments));
-  };
-  /**
- * Self-destruct and clean up everything for a single client.
- * This will NOT destroy the embedded Flash object.
- *
- * @returns `undefined`
- */
-  ZeroClipboard.prototype.destroy = function() {
-    return _clientDestroy.apply(this, _args(arguments));
-  };
-  /**
- * Stores the pending plain text to inject into the clipboard.
- *
- * @returns `this`
- */
-  ZeroClipboard.prototype.setText = function(text) {
-    if (!_clientMeta[this.id]) {
-      throw new Error("Attempted to set pending clipboard data from a destroyed ZeroClipboard client instance");
-    }
-    ZeroClipboard.setData("text/plain", text);
-    return this;
-  };
-  /**
- * Stores the pending HTML text to inject into the clipboard.
- *
- * @returns `this`
- */
-  ZeroClipboard.prototype.setHtml = function(html) {
-    if (!_clientMeta[this.id]) {
-      throw new Error("Attempted to set pending clipboard data from a destroyed ZeroClipboard client instance");
-    }
-    ZeroClipboard.setData("text/html", html);
-    return this;
-  };
-  /**
- * Stores the pending rich text (RTF) to inject into the clipboard.
- *
- * @returns `this`
- */
-  ZeroClipboard.prototype.setRichText = function(richText) {
-    if (!_clientMeta[this.id]) {
-      throw new Error("Attempted to set pending clipboard data from a destroyed ZeroClipboard client instance");
-    }
-    ZeroClipboard.setData("application/rtf", richText);
-    return this;
-  };
-  /**
- * Stores the pending data to inject into the clipboard.
- *
- * @returns `this`
- */
-  ZeroClipboard.prototype.setData = function() {
-    if (!_clientMeta[this.id]) {
-      throw new Error("Attempted to set pending clipboard data from a destroyed ZeroClipboard client instance");
-    }
-    ZeroClipboard.setData.apply(this, _args(arguments));
-    return this;
-  };
-  /**
- * Clears the pending data to inject into the clipboard.
- * If no `format` is provided, all pending data formats will be cleared.
- *
- * @returns `this`
- */
-  ZeroClipboard.prototype.clearData = function() {
-    if (!_clientMeta[this.id]) {
-      throw new Error("Attempted to clear pending clipboard data from a destroyed ZeroClipboard client instance");
-    }
-    ZeroClipboard.clearData.apply(this, _args(arguments));
-    return this;
-  };
-  /**
- * Gets a copy of the pending data to inject into the clipboard.
- * If no `format` is provided, a copy of ALL pending data formats will be returned.
- *
- * @returns `String` or `Object`
- */
-  ZeroClipboard.prototype.getData = function() {
-    if (!_clientMeta[this.id]) {
-      throw new Error("Attempted to get pending clipboard data from a destroyed ZeroClipboard client instance");
-    }
-    return ZeroClipboard.getData.apply(this, _args(arguments));
-  };
-  if (typeof define === "function" && define.amd) {
-    define(function() {
-      return ZeroClipboard;
-    });
-  } else if (typeof module === "object" && module && typeof module.exports === "object" && module.exports) {
-    module.exports = ZeroClipboard;
-  } else {
-    window.ZeroClipboard = ZeroClipboard;
-  }
-})(function() {
-  return this || window;
-}());
\ No newline at end of file