1 /*!

     2  * ZeroClipboard

     3  * The ZeroClipboard library provides an easy way to copy text to the clipboard using an invisible Adobe Flash movie and a JavaScript interface.

     4  * Copyright (c) 2009-2014 Jon Rohan, James M. Greene

     5  * Licensed MIT

     6  * http://zeroclipboard.org/

     7  * v2.2.0

     8  */

     9 (function(window, undefined) {

    10   "use strict";

    11   /**

    12  * Store references to critically important global functions that may be

    13  * overridden on certain web pages.

    14  */

    15   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() {

    16     var unwrapper = function(el) {

    17       return el;

    18     };

    19     if (typeof _window.wrap === "function" && typeof _window.unwrap === "function") {

    20       try {

    21         var div = _document.createElement("div");

    22         var unwrappedDiv = _window.unwrap(div);

    23         if (div.nodeType === 1 && unwrappedDiv && unwrappedDiv.nodeType === 1) {

    24           unwrapper = _window.unwrap;

    25         }

    26       } catch (e) {}

    27     }

    28     return unwrapper;

    29   }();

    30   /**

    31  * Convert an `arguments` object into an Array.

    32  *

    33  * @returns The arguments as an Array

    34  * @private

    35  */

    36   var _args = function(argumentsObj) {

    37     return _slice.call(argumentsObj, 0);

    38   };

    39   /**

    40  * Shallow-copy the owned, enumerable properties of one object over to another, similar to jQuery's `$.extend`.

    41  *

    42  * @returns The target object, augmented

    43  * @private

    44  */

    45   var _extend = function() {

    46     var i, len, arg, prop, src, copy, args = _args(arguments), target = args[0] || {};

    47     for (i = 1, len = args.length; i < len; i++) {

    48       if ((arg = args[i]) != null) {

    49         for (prop in arg) {

    50           if (_hasOwn.call(arg, prop)) {

    51             src = target[prop];

    52             copy = arg[prop];

    53             if (target !== copy && copy !== undefined) {

    54               target[prop] = copy;

    55             }

    56           }

    57         }

    58       }

    59     }

    60     return target;

    61   };

    62   /**

    63  * Return a deep copy of the source object or array.

    64  *

    65  * @returns Object or Array

    66  * @private

    67  */

    68   var _deepCopy = function(source) {

    69     var copy, i, len, prop;

    70     if (typeof source !== "object" || source == null || typeof source.nodeType === "number") {

    71       copy = source;

    72     } else if (typeof source.length === "number") {

    73       copy = [];

    74       for (i = 0, len = source.length; i < len; i++) {

    75         if (_hasOwn.call(source, i)) {

    76           copy[i] = _deepCopy(source[i]);

    77         }

    78       }

    79     } else {

    80       copy = {};

    81       for (prop in source) {

    82         if (_hasOwn.call(source, prop)) {

    83           copy[prop] = _deepCopy(source[prop]);

    84         }

    85       }

    86     }

    87     return copy;

    88   };

    89   /**

    90  * Makes a shallow copy of `obj` (like `_extend`) but filters its properties based on a list of `keys` to keep.

    91  * The inverse of `_omit`, mostly. The big difference is that these properties do NOT need to be enumerable to

    92  * be kept.

    93  *

    94  * @returns A new filtered object.

    95  * @private

    96  */

    97   var _pick = function(obj, keys) {

    98     var newObj = {};

    99     for (var i = 0, len = keys.length; i < len; i++) {

   100       if (keys[i] in obj) {

   101         newObj[keys[i]] = obj[keys[i]];

   102       }

   103     }

   104     return newObj;

   105   };

   106   /**

   107  * Makes a shallow copy of `obj` (like `_extend`) but filters its properties based on a list of `keys` to omit.

   108  * The inverse of `_pick`.

   109  *

   110  * @returns A new filtered object.

   111  * @private

   112  */

   113   var _omit = function(obj, keys) {

   114     var newObj = {};

   115     for (var prop in obj) {

   116       if (keys.indexOf(prop) === -1) {

   117         newObj[prop] = obj[prop];

   118       }

   119     }

   120     return newObj;

   121   };

   122   /**

   123  * Remove all owned, enumerable properties from an object.

   124  *

   125  * @returns The original object without its owned, enumerable properties.

   126  * @private

   127  */

   128   var _deleteOwnProperties = function(obj) {

   129     if (obj) {

   130       for (var prop in obj) {

   131         if (_hasOwn.call(obj, prop)) {

   132           delete obj[prop];

   133         }

   134       }

   135     }

   136     return obj;

   137   };

   138   /**

   139  * Determine if an element is contained within another element.

   140  *

   141  * @returns Boolean

   142  * @private

   143  */

   144   var _containedBy = function(el, ancestorEl) {

   145     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)) {

   146       do {

   147         if (el === ancestorEl) {

   148           return true;

   149         }

   150         el = el.parentNode;

   151       } while (el);

   152     }

   153     return false;

   154   };

   155   /**

   156  * Get the URL path's parent directory.

   157  *

   158  * @returns String or `undefined`

   159  * @private

   160  */

   161   var _getDirPathOfUrl = function(url) {

   162     var dir;

   163     if (typeof url === "string" && url) {

   164       dir = url.split("#")[0].split("?")[0];

   165       dir = url.slice(0, url.lastIndexOf("/") + 1);

   166     }

   167     return dir;

   168   };

   169   /**

   170  * Get the current script's URL by throwing an `Error` and analyzing it.

   171  *

   172  * @returns String or `undefined`

   173  * @private

   174  */

   175   var _getCurrentScriptUrlFromErrorStack = function(stack) {

   176     var url, matches;

   177     if (typeof stack === "string" && stack) {

   178       matches = stack.match(/^(?:|[^:@]*@|.+\)@(?=http[s]?|file)|.+?\s+(?: at |@)(?:[^:\(]+ )*[\(]?)((?:http[s]?|file):\/\/[\/]?.+?\/[^:\)]*?)(?::\d+)(?::\d+)?/);

   179       if (matches && matches[1]) {

   180         url = matches[1];

   181       } else {

   182         matches = stack.match(/\)@((?:http[s]?|file):\/\/[\/]?.+?\/[^:\)]*?)(?::\d+)(?::\d+)?/);

   183         if (matches && matches[1]) {

   184           url = matches[1];

   185         }

   186       }

   187     }

   188     return url;

   189   };

   190   /**

   191  * Get the current script's URL by throwing an `Error` and analyzing it.

   192  *

   193  * @returns String or `undefined`

   194  * @private

   195  */

   196   var _getCurrentScriptUrlFromError = function() {

   197     var url, err;

   198     try {

   199       throw new _Error();

   200     } catch (e) {

   201       err = e;

   202     }

   203     if (err) {

   204       url = err.sourceURL || err.fileName || _getCurrentScriptUrlFromErrorStack(err.stack);

   205     }

   206     return url;

   207   };

   208   /**

   209  * Get the current script's URL.

   210  *

   211  * @returns String or `undefined`

   212  * @private

   213  */

   214   var _getCurrentScriptUrl = function() {

   215     var jsPath, scripts, i;

   216     if (_document.currentScript && (jsPath = _document.currentScript.src)) {

   217       return jsPath;

   218     }

   219     scripts = _document.getElementsByTagName("script");

   220     if (scripts.length === 1) {

   221       return scripts[0].src || undefined;

   222     }

   223     if ("readyState" in scripts[0]) {

   224       for (i = scripts.length; i--; ) {

   225         if (scripts[i].readyState === "interactive" && (jsPath = scripts[i].src)) {

   226           return jsPath;

   227         }

   228       }

   229     }

   230     if (_document.readyState === "loading" && (jsPath = scripts[scripts.length - 1].src)) {

   231       return jsPath;

   232     }

   233     if (jsPath = _getCurrentScriptUrlFromError()) {

   234       return jsPath;

   235     }

   236     return undefined;

   237   };

   238   /**

   239  * Get the unanimous parent directory of ALL script tags.

   240  * If any script tags are either (a) inline or (b) from differing parent

   241  * directories, this method must return `undefined`.

   242  *

   243  * @returns String or `undefined`

   244  * @private

   245  */

   246   var _getUnanimousScriptParentDir = function() {

   247     var i, jsDir, jsPath, scripts = _document.getElementsByTagName("script");

   248     for (i = scripts.length; i--; ) {

   249       if (!(jsPath = scripts[i].src)) {

   250         jsDir = null;

   251         break;

   252       }

   253       jsPath = _getDirPathOfUrl(jsPath);

   254       if (jsDir == null) {

   255         jsDir = jsPath;

   256       } else if (jsDir !== jsPath) {

   257         jsDir = null;

   258         break;

   259       }

   260     }

   261     return jsDir || undefined;

   262   };

   263   /**

   264  * Get the presumed location of the "ZeroClipboard.swf" file, based on the location

   265  * of the executing JavaScript file (e.g. "ZeroClipboard.js", etc.).

   266  *

   267  * @returns String

   268  * @private

   269  */

   270   var _getDefaultSwfPath = function() {

   271     var jsDir = _getDirPathOfUrl(_getCurrentScriptUrl()) || _getUnanimousScriptParentDir() || "";

   272     return jsDir + "ZeroClipboard.swf";

   273   };

   274   /**

   275  * Keep track of if the page is framed (in an `iframe`). This can never change.

   276  * @private

   277  */

   278   var _pageIsFramed = function() {

   279     return window.opener == null && (!!window.top && window != window.top || !!window.parent && window != window.parent);

   280   }();

   281   /**

   282  * Keep track of the state of the Flash object.

   283  * @private

   284  */

   285   var _flashState = {

   286     bridge: null,

   287     version: "0.0.0",

   288     pluginType: "unknown",

   289     disabled: null,

   290     outdated: null,

   291     sandboxed: null,

   292     unavailable: null,

   293     degraded: null,

   294     deactivated: null,

   295     overdue: null,

   296     ready: null

   297   };

   298   /**

   299  * The minimum Flash Player version required to use ZeroClipboard completely.

   300  * @readonly

   301  * @private

   302  */

   303   var _minimumFlashVersion = "11.0.0";

   304   /**

   305  * The ZeroClipboard library version number, as reported by Flash, at the time the SWF was compiled.

   306  */

   307   var _zcSwfVersion;

   308   /**

   309  * Keep track of all event listener registrations.

   310  * @private

   311  */

   312   var _handlers = {};

   313   /**

   314  * Keep track of the currently activated element.

   315  * @private

   316  */

   317   var _currentElement;

   318   /**

   319  * Keep track of the element that was activated when a `copy` process started.

   320  * @private

   321  */

   322   var _copyTarget;

   323   /**

   324  * Keep track of data for the pending clipboard transaction.

   325  * @private

   326  */

   327   var _clipData = {};

   328   /**

   329  * Keep track of data formats for the pending clipboard transaction.

   330  * @private

   331  */

   332   var _clipDataFormatMap = null;

   333   /**

   334  * Keep track of the Flash availability check timeout.

   335  * @private

   336  */

   337   var _flashCheckTimeout = 0;

   338   /**

   339  * Keep track of SWF network errors interval polling.

   340  * @private

   341  */

   342   var _swfFallbackCheckInterval = 0;

   343   /**

   344  * The `message` store for events

   345  * @private

   346  */

   347   var _eventMessages = {

   348     ready: "Flash communication is established",

   349     error: {

   350       "flash-disabled": "Flash is disabled or not installed. May also be attempting to run Flash in a sandboxed iframe, which is impossible.",

   351       "flash-outdated": "Flash is too outdated to support ZeroClipboard",

   352       "flash-sandboxed": "Attempting to run Flash in a sandboxed iframe, which is impossible",

   353       "flash-unavailable": "Flash is unable to communicate bidirectionally with JavaScript",

   354       "flash-degraded": "Flash is unable to preserve data fidelity when communicating with JavaScript",

   355       "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.",

   356       "flash-overdue": "Flash communication was established but NOT within the acceptable time limit",

   357       "version-mismatch": "ZeroClipboard JS version number does not match ZeroClipboard SWF version number",

   358       "clipboard-error": "At least one error was thrown while ZeroClipboard was attempting to inject your data into the clipboard",

   359       "config-mismatch": "ZeroClipboard configuration does not match Flash's reality",

   360       "swf-not-found": "The ZeroClipboard SWF object could not be loaded, so please check your `swfPath` configuration and/or network connectivity"

   361     }

   362   };

   363   /**

   364  * The `name`s of `error` events that can only occur is Flash has at least

   365  * been able to load the SWF successfully.

   366  * @private

   367  */

   368   var _errorsThatOnlyOccurAfterFlashLoads = [ "flash-unavailable", "flash-degraded", "flash-overdue", "version-mismatch", "config-mismatch", "clipboard-error" ];

   369   /**

   370  * The `name`s of `error` events that should likely result in the `_flashState`

   371  * variable's property values being updated.

   372  * @private

   373  */

   374   var _flashStateErrorNames = [ "flash-disabled", "flash-outdated", "flash-sandboxed", "flash-unavailable", "flash-degraded", "flash-deactivated", "flash-overdue" ];

   375   /**

   376  * A RegExp to match the `name` property of `error` events related to Flash.

   377  * @private

   378  */

   379   var _flashStateErrorNameMatchingRegex = new RegExp("^flash-(" + _flashStateErrorNames.map(function(errorName) {

   380     return errorName.replace(/^flash-/, "");

   381   }).join("|") + ")$");

   382   /**

   383  * A RegExp to match the `name` property of `error` events related to Flash,

   384  * which is enabled.

   385  * @private

   386  */

   387   var _flashStateEnabledErrorNameMatchingRegex = new RegExp("^flash-(" + _flashStateErrorNames.slice(1).map(function(errorName) {

   388     return errorName.replace(/^flash-/, "");

   389   }).join("|") + ")$");

   390   /**

   391  * ZeroClipboard configuration defaults for the Core module.

   392  * @private

   393  */

   394   var _globalConfig = {

   395     swfPath: _getDefaultSwfPath(),

   396     trustedDomains: window.location.host ? [ window.location.host ] : [],

   397     cacheBust: true,

   398     forceEnhancedClipboard: false,

   399     flashLoadTimeout: 3e4,

   400     autoActivate: true,

   401     bubbleEvents: true,

   402     containerId: "global-zeroclipboard-html-bridge",

   403     containerClass: "global-zeroclipboard-container",

   404     swfObjectId: "global-zeroclipboard-flash-bridge",

   405     hoverClass: "zeroclipboard-is-hover",

   406     activeClass: "zeroclipboard-is-active",

   407     forceHandCursor: false,

   408     title: null,

   409     zIndex: 999999999

   410   };

   411   /**

   412  * The underlying implementation of `ZeroClipboard.config`.

   413  * @private

   414  */

   415   var _config = function(options) {

   416     if (typeof options === "object" && options !== null) {

   417       for (var prop in options) {

   418         if (_hasOwn.call(options, prop)) {

   419           if (/^(?:forceHandCursor|title|zIndex|bubbleEvents)$/.test(prop)) {

   420             _globalConfig[prop] = options[prop];

   421           } else if (_flashState.bridge == null) {

   422             if (prop === "containerId" || prop === "swfObjectId") {

   423               if (_isValidHtml4Id(options[prop])) {

   424                 _globalConfig[prop] = options[prop];

   425               } else {

   426                 throw new Error("The specified `" + prop + "` value is not valid as an HTML4 Element ID");

   427               }

   428             } else {

   429               _globalConfig[prop] = options[prop];

   430             }

   431           }

   432         }

   433       }

   434     }

   435     if (typeof options === "string" && options) {

   436       if (_hasOwn.call(_globalConfig, options)) {

   437         return _globalConfig[options];

   438       }

   439       return;

   440     }

   441     return _deepCopy(_globalConfig);

   442   };

   443   /**

   444  * The underlying implementation of `ZeroClipboard.state`.

   445  * @private

   446  */

   447   var _state = function() {

   448     _detectSandbox();

   449     return {

   450       browser: _pick(_navigator, [ "userAgent", "platform", "appName" ]),

   451       flash: _omit(_flashState, [ "bridge" ]),

   452       zeroclipboard: {

   453         version: ZeroClipboard.version,

   454         config: ZeroClipboard.config()

   455       }

   456     };

   457   };

   458   /**

   459  * The underlying implementation of `ZeroClipboard.isFlashUnusable`.

   460  * @private

   461  */

   462   var _isFlashUnusable = function() {

   463     return !!(_flashState.disabled || _flashState.outdated || _flashState.sandboxed || _flashState.unavailable || _flashState.degraded || _flashState.deactivated);

   464   };

   465   /**

   466  * The underlying implementation of `ZeroClipboard.on`.

   467  * @private

   468  */

   469   var _on = function(eventType, listener) {

   470     var i, len, events, added = {};

   471     if (typeof eventType === "string" && eventType) {

   472       events = eventType.toLowerCase().split(/\s+/);

   473     } else if (typeof eventType === "object" && eventType && typeof listener === "undefined") {

   474       for (i in eventType) {

   475         if (_hasOwn.call(eventType, i) && typeof i === "string" && i && typeof eventType[i] === "function") {

   476           ZeroClipboard.on(i, eventType[i]);

   477         }

   478       }

   479     }

   480     if (events && events.length) {

   481       for (i = 0, len = events.length; i < len; i++) {

   482         eventType = events[i].replace(/^on/, "");

   483         added[eventType] = true;

   484         if (!_handlers[eventType]) {

   485           _handlers[eventType] = [];

   486         }

   487         _handlers[eventType].push(listener);

   488       }

   489       if (added.ready && _flashState.ready) {

   490         ZeroClipboard.emit({

   491           type: "ready"

   492         });

   493       }

   494       if (added.error) {

   495         for (i = 0, len = _flashStateErrorNames.length; i < len; i++) {

   496           if (_flashState[_flashStateErrorNames[i].replace(/^flash-/, "")] === true) {

   497             ZeroClipboard.emit({

   498               type: "error",

   499               name: _flashStateErrorNames[i]

   500             });

   501             break;

   502           }

   503         }

   504         if (_zcSwfVersion !== undefined && ZeroClipboard.version !== _zcSwfVersion) {

   505           ZeroClipboard.emit({

   506             type: "error",

   507             name: "version-mismatch",

   508             jsVersion: ZeroClipboard.version,

   509             swfVersion: _zcSwfVersion

   510           });

   511         }

   512       }

   513     }

   514     return ZeroClipboard;

   515   };

   516   /**

   517  * The underlying implementation of `ZeroClipboard.off`.

   518  * @private

   519  */

   520   var _off = function(eventType, listener) {

   521     var i, len, foundIndex, events, perEventHandlers;

   522     if (arguments.length === 0) {

   523       events = _keys(_handlers);

   524     } else if (typeof eventType === "string" && eventType) {

   525       events = eventType.split(/\s+/);

   526     } else if (typeof eventType === "object" && eventType && typeof listener === "undefined") {

   527       for (i in eventType) {

   528         if (_hasOwn.call(eventType, i) && typeof i === "string" && i && typeof eventType[i] === "function") {

   529           ZeroClipboard.off(i, eventType[i]);

   530         }

   531       }

   532     }

   533     if (events && events.length) {

   534       for (i = 0, len = events.length; i < len; i++) {

   535         eventType = events[i].toLowerCase().replace(/^on/, "");

   536         perEventHandlers = _handlers[eventType];

   537         if (perEventHandlers && perEventHandlers.length) {

   538           if (listener) {

   539             foundIndex = perEventHandlers.indexOf(listener);

   540             while (foundIndex !== -1) {

   541               perEventHandlers.splice(foundIndex, 1);

   542               foundIndex = perEventHandlers.indexOf(listener, foundIndex);

   543             }

   544           } else {

   545             perEventHandlers.length = 0;

   546           }

   547         }

   548       }

   549     }

   550     return ZeroClipboard;

   551   };

   552   /**

   553  * The underlying implementation of `ZeroClipboard.handlers`.

   554  * @private

   555  */

   556   var _listeners = function(eventType) {

   557     var copy;

   558     if (typeof eventType === "string" && eventType) {

   559       copy = _deepCopy(_handlers[eventType]) || null;

   560     } else {

   561       copy = _deepCopy(_handlers);

   562     }

   563     return copy;

   564   };

   565   /**

   566  * The underlying implementation of `ZeroClipboard.emit`.

   567  * @private

   568  */

   569   var _emit = function(event) {

   570     var eventCopy, returnVal, tmp;

   571     event = _createEvent(event);

   572     if (!event) {

   573       return;

   574     }

   575     if (_preprocessEvent(event)) {

   576       return;

   577     }

   578     if (event.type === "ready" && _flashState.overdue === true) {

   579       return ZeroClipboard.emit({

   580         type: "error",

   581         name: "flash-overdue"

   582       });

   583     }

   584     eventCopy = _extend({}, event);

   585     _dispatchCallbacks.call(this, eventCopy);

   586     if (event.type === "copy") {

   587       tmp = _mapClipDataToFlash(_clipData);

   588       returnVal = tmp.data;

   589       _clipDataFormatMap = tmp.formatMap;

   590     }

   591     return returnVal;

   592   };

   593   /**

   594  * The underlying implementation of `ZeroClipboard.create`.

   595  * @private

   596  */

   597   var _create = function() {

   598     var previousState = _flashState.sandboxed;

   599     _detectSandbox();

   600     if (typeof _flashState.ready !== "boolean") {

   601       _flashState.ready = false;

   602     }

   603     if (_flashState.sandboxed !== previousState && _flashState.sandboxed === true) {

   604       _flashState.ready = false;

   605       ZeroClipboard.emit({

   606         type: "error",

   607         name: "flash-sandboxed"

   608       });

   609     } else if (!ZeroClipboard.isFlashUnusable() && _flashState.bridge === null) {

   610       var maxWait = _globalConfig.flashLoadTimeout;

   611       if (typeof maxWait === "number" && maxWait >= 0) {

   612         _flashCheckTimeout = _setTimeout(function() {

   613           if (typeof _flashState.deactivated !== "boolean") {

   614             _flashState.deactivated = true;

   615           }

   616           if (_flashState.deactivated === true) {

   617             ZeroClipboard.emit({

   618               type: "error",

   619               name: "flash-deactivated"

   620             });

   621           }

   622         }, maxWait);

   623       }

   624       _flashState.overdue = false;

   625       _embedSwf();

   626     }

   627   };

   628   /**

   629  * The underlying implementation of `ZeroClipboard.destroy`.

   630  * @private

   631  */

   632   var _destroy = function() {

   633     ZeroClipboard.clearData();

   634     ZeroClipboard.blur();

   635     ZeroClipboard.emit("destroy");

   636     _unembedSwf();

   637     ZeroClipboard.off();

   638   };

   639   /**

   640  * The underlying implementation of `ZeroClipboard.setData`.

   641  * @private

   642  */

   643   var _setData = function(format, data) {

   644     var dataObj;

   645     if (typeof format === "object" && format && typeof data === "undefined") {

   646       dataObj = format;

   647       ZeroClipboard.clearData();

   648     } else if (typeof format === "string" && format) {

   649       dataObj = {};

   650       dataObj[format] = data;

   651     } else {

   652       return;

   653     }

   654     for (var dataFormat in dataObj) {

   655       if (typeof dataFormat === "string" && dataFormat && _hasOwn.call(dataObj, dataFormat) && typeof dataObj[dataFormat] === "string" && dataObj[dataFormat]) {

   656         _clipData[dataFormat] = dataObj[dataFormat];

   657       }

   658     }

   659   };

   660   /**

   661  * The underlying implementation of `ZeroClipboard.clearData`.

   662  * @private

   663  */

   664   var _clearData = function(format) {

   665     if (typeof format === "undefined") {

   666       _deleteOwnProperties(_clipData);

   667       _clipDataFormatMap = null;

   668     } else if (typeof format === "string" && _hasOwn.call(_clipData, format)) {

   669       delete _clipData[format];

   670     }

   671   };

   672   /**

   673  * The underlying implementation of `ZeroClipboard.getData`.

   674  * @private

   675  */

   676   var _getData = function(format) {

   677     if (typeof format === "undefined") {

   678       return _deepCopy(_clipData);

   679     } else if (typeof format === "string" && _hasOwn.call(_clipData, format)) {

   680       return _clipData[format];

   681     }

   682   };

   683   /**

   684  * The underlying implementation of `ZeroClipboard.focus`/`ZeroClipboard.activate`.

   685  * @private

   686  */

   687   var _focus = function(element) {

   688     if (!(element && element.nodeType === 1)) {

   689       return;

   690     }

   691     if (_currentElement) {

   692       _removeClass(_currentElement, _globalConfig.activeClass);

   693       if (_currentElement !== element) {

   694         _removeClass(_currentElement, _globalConfig.hoverClass);

   695       }

   696     }

   697     _currentElement = element;

   698     _addClass(element, _globalConfig.hoverClass);

   699     var newTitle = element.getAttribute("title") || _globalConfig.title;

   700     if (typeof newTitle === "string" && newTitle) {

   701       var htmlBridge = _getHtmlBridge(_flashState.bridge);

   702       if (htmlBridge) {

   703         htmlBridge.setAttribute("title", newTitle);

   704       }

   705     }

   706     var useHandCursor = _globalConfig.forceHandCursor === true || _getStyle(element, "cursor") === "pointer";

   707     _setHandCursor(useHandCursor);

   708     _reposition();

   709   };

   710   /**

   711  * The underlying implementation of `ZeroClipboard.blur`/`ZeroClipboard.deactivate`.

   712  * @private

   713  */

   714   var _blur = function() {

   715     var htmlBridge = _getHtmlBridge(_flashState.bridge);

   716     if (htmlBridge) {

   717       htmlBridge.removeAttribute("title");

   718       htmlBridge.style.left = "0px";

   719       htmlBridge.style.top = "-9999px";

   720       htmlBridge.style.width = "1px";

   721       htmlBridge.style.height = "1px";

   722     }

   723     if (_currentElement) {

   724       _removeClass(_currentElement, _globalConfig.hoverClass);

   725       _removeClass(_currentElement, _globalConfig.activeClass);

   726       _currentElement = null;

   727     }

   728   };

   729   /**

   730  * The underlying implementation of `ZeroClipboard.activeElement`.

   731  * @private

   732  */

   733   var _activeElement = function() {

   734     return _currentElement || null;

   735   };

   736   /**

   737  * Check if a value is a valid HTML4 `ID` or `Name` token.

   738  * @private

   739  */

   740   var _isValidHtml4Id = function(id) {

   741     return typeof id === "string" && id && /^[A-Za-z][A-Za-z0-9_:\-\.]*$/.test(id);

   742   };

   743   /**

   744  * Create or update an `event` object, based on the `eventType`.

   745  * @private

   746  */

   747   var _createEvent = function(event) {

   748     var eventType;

   749     if (typeof event === "string" && event) {

   750       eventType = event;

   751       event = {};

   752     } else if (typeof event === "object" && event && typeof event.type === "string" && event.type) {

   753       eventType = event.type;

   754     }

   755     if (!eventType) {

   756       return;

   757     }

   758     eventType = eventType.toLowerCase();

   759     if (!event.target && (/^(copy|aftercopy|_click)$/.test(eventType) || eventType === "error" && event.name === "clipboard-error")) {

   760       event.target = _copyTarget;

   761     }

   762     _extend(event, {

   763       type: eventType,

   764       target: event.target || _currentElement || null,

   765       relatedTarget: event.relatedTarget || null,

   766       currentTarget: _flashState && _flashState.bridge || null,

   767       timeStamp: event.timeStamp || _now() || null

   768     });

   769     var msg = _eventMessages[event.type];

   770     if (event.type === "error" && event.name && msg) {

   771       msg = msg[event.name];

   772     }

   773     if (msg) {

   774       event.message = msg;

   775     }

   776     if (event.type === "ready") {

   777       _extend(event, {

   778         target: null,

   779         version: _flashState.version

   780       });

   781     }

   782     if (event.type === "error") {

   783       if (_flashStateErrorNameMatchingRegex.test(event.name)) {

   784         _extend(event, {

   785           target: null,

   786           minimumVersion: _minimumFlashVersion

   787         });

   788       }

   789       if (_flashStateEnabledErrorNameMatchingRegex.test(event.name)) {

   790         _extend(event, {

   791           version: _flashState.version

   792         });

   793       }

   794     }

   795     if (event.type === "copy") {

   796       event.clipboardData = {

   797         setData: ZeroClipboard.setData,

   798         clearData: ZeroClipboard.clearData

   799       };

   800     }

   801     if (event.type === "aftercopy") {

   802       event = _mapClipResultsFromFlash(event, _clipDataFormatMap);

   803     }

   804     if (event.target && !event.relatedTarget) {

   805       event.relatedTarget = _getRelatedTarget(event.target);

   806     }

   807     return _addMouseData(event);

   808   };

   809   /**

   810  * Get a relatedTarget from the target's `data-clipboard-target` attribute

   811  * @private

   812  */

   813   var _getRelatedTarget = function(targetEl) {

   814     var relatedTargetId = targetEl && targetEl.getAttribute && targetEl.getAttribute("data-clipboard-target");

   815     return relatedTargetId ? _document.getElementById(relatedTargetId) : null;

   816   };

   817   /**

   818  * Add element and position data to `MouseEvent` instances

   819  * @private

   820  */

   821   var _addMouseData = function(event) {

   822     if (event && /^_(?:click|mouse(?:over|out|down|up|move))$/.test(event.type)) {

   823       var srcElement = event.target;

   824       var fromElement = event.type === "_mouseover" && event.relatedTarget ? event.relatedTarget : undefined;

   825       var toElement = event.type === "_mouseout" && event.relatedTarget ? event.relatedTarget : undefined;

   826       var pos = _getElementPosition(srcElement);

   827       var screenLeft = _window.screenLeft || _window.screenX || 0;

   828       var screenTop = _window.screenTop || _window.screenY || 0;

   829       var scrollLeft = _document.body.scrollLeft + _document.documentElement.scrollLeft;

   830       var scrollTop = _document.body.scrollTop + _document.documentElement.scrollTop;

   831       var pageX = pos.left + (typeof event._stageX === "number" ? event._stageX : 0);

   832       var pageY = pos.top + (typeof event._stageY === "number" ? event._stageY : 0);

   833       var clientX = pageX - scrollLeft;

   834       var clientY = pageY - scrollTop;

   835       var screenX = screenLeft + clientX;

   836       var screenY = screenTop + clientY;

   837       var moveX = typeof event.movementX === "number" ? event.movementX : 0;

   838       var moveY = typeof event.movementY === "number" ? event.movementY : 0;

   839       delete event._stageX;

   840       delete event._stageY;

   841       _extend(event, {

   842         srcElement: srcElement,

   843         fromElement: fromElement,

   844         toElement: toElement,

   845         screenX: screenX,

   846         screenY: screenY,

   847         pageX: pageX,

   848         pageY: pageY,

   849         clientX: clientX,

   850         clientY: clientY,

   851         x: clientX,

   852         y: clientY,

   853         movementX: moveX,

   854         movementY: moveY,

   855         offsetX: 0,

   856         offsetY: 0,

   857         layerX: 0,

   858         layerY: 0

   859       });

   860     }

   861     return event;

   862   };

   863   /**

   864  * Determine if an event's registered handlers should be execute synchronously or asynchronously.

   865  *

   866  * @returns {boolean}

   867  * @private

   868  */

   869   var _shouldPerformAsync = function(event) {

   870     var eventType = event && typeof event.type === "string" && event.type || "";

   871     return !/^(?:(?:before)?copy|destroy)$/.test(eventType);

   872   };

   873   /**

   874  * Control if a callback should be executed asynchronously or not.

   875  *

   876  * @returns `undefined`

   877  * @private

   878  */

   879   var _dispatchCallback = function(func, context, args, async) {

   880     if (async) {

   881       _setTimeout(function() {

   882         func.apply(context, args);

   883       }, 0);

   884     } else {

   885       func.apply(context, args);

   886     }

   887   };

   888   /**

   889  * Handle the actual dispatching of events to client instances.

   890  *

   891  * @returns `undefined`

   892  * @private

   893  */

   894   var _dispatchCallbacks = function(event) {

   895     if (!(typeof event === "object" && event && event.type)) {

   896       return;

   897     }

   898     var async = _shouldPerformAsync(event);

   899     var wildcardTypeHandlers = _handlers["*"] || [];

   900     var specificTypeHandlers = _handlers[event.type] || [];

   901     var handlers = wildcardTypeHandlers.concat(specificTypeHandlers);

   902     if (handlers && handlers.length) {

   903       var i, len, func, context, eventCopy, originalContext = this;

   904       for (i = 0, len = handlers.length; i < len; i++) {

   905         func = handlers[i];

   906         context = originalContext;

   907         if (typeof func === "string" && typeof _window[func] === "function") {

   908           func = _window[func];

   909         }

   910         if (typeof func === "object" && func && typeof func.handleEvent === "function") {

   911           context = func;

   912           func = func.handleEvent;

   913         }

   914         if (typeof func === "function") {

   915           eventCopy = _extend({}, event);

   916           _dispatchCallback(func, context, [ eventCopy ], async);

   917         }

   918       }

   919     }

   920     return this;

   921   };

   922   /**

   923  * Check an `error` event's `name` property to see if Flash has

   924  * already loaded, which rules out possible `iframe` sandboxing.

   925  * @private

   926  */

   927   var _getSandboxStatusFromErrorEvent = function(event) {

   928     var isSandboxed = null;

   929     if (_pageIsFramed === false || event && event.type === "error" && event.name && _errorsThatOnlyOccurAfterFlashLoads.indexOf(event.name) !== -1) {

   930       isSandboxed = false;

   931     }

   932     return isSandboxed;

   933   };

   934   /**

   935  * Preprocess any special behaviors, reactions, or state changes after receiving this event.

   936  * Executes only once per event emitted, NOT once per client.

   937  * @private

   938  */

   939   var _preprocessEvent = function(event) {

   940     var element = event.target || _currentElement || null;

   941     var sourceIsSwf = event._source === "swf";

   942     delete event._source;

   943     switch (event.type) {

   944      case "error":

   945       var isSandboxed = event.name === "flash-sandboxed" || _getSandboxStatusFromErrorEvent(event);

   946       if (typeof isSandboxed === "boolean") {

   947         _flashState.sandboxed = isSandboxed;

   948       }

   949       if (_flashStateErrorNames.indexOf(event.name) !== -1) {

   950         _extend(_flashState, {

   951           disabled: event.name === "flash-disabled",

   952           outdated: event.name === "flash-outdated",

   953           unavailable: event.name === "flash-unavailable",

   954           degraded: event.name === "flash-degraded",

   955           deactivated: event.name === "flash-deactivated",

   956           overdue: event.name === "flash-overdue",

   957           ready: false

   958         });

   959       } else if (event.name === "version-mismatch") {

   960         _zcSwfVersion = event.swfVersion;

   961         _extend(_flashState, {

   962           disabled: false,

   963           outdated: false,

   964           unavailable: false,

   965           degraded: false,

   966           deactivated: false,

   967           overdue: false,

   968           ready: false

   969         });

   970       }

   971       _clearTimeoutsAndPolling();

   972       break;

   973 

   974      case "ready":

   975       _zcSwfVersion = event.swfVersion;

   976       var wasDeactivated = _flashState.deactivated === true;

   977       _extend(_flashState, {

   978         disabled: false,

   979         outdated: false,

   980         sandboxed: false,

   981         unavailable: false,

   982         degraded: false,

   983         deactivated: false,

   984         overdue: wasDeactivated,

   985         ready: !wasDeactivated

   986       });

   987       _clearTimeoutsAndPolling();

   988       break;

   989 

   990      case "beforecopy":

   991       _copyTarget = element;

   992       break;

   993 

   994      case "copy":

   995       var textContent, htmlContent, targetEl = event.relatedTarget;

   996       if (!(_clipData["text/html"] || _clipData["text/plain"]) && targetEl && (htmlContent = targetEl.value || targetEl.outerHTML || targetEl.innerHTML) && (textContent = targetEl.value || targetEl.textContent || targetEl.innerText)) {

   997         event.clipboardData.clearData();

   998         event.clipboardData.setData("text/plain", textContent);

   999         if (htmlContent !== textContent) {

  1000           event.clipboardData.setData("text/html", htmlContent);

  1001         }

  1002       } else if (!_clipData["text/plain"] && event.target && (textContent = event.target.getAttribute("data-clipboard-text"))) {

  1003         event.clipboardData.clearData();

  1004         event.clipboardData.setData("text/plain", textContent);

  1005       }

  1006       break;

  1007 

  1008      case "aftercopy":

  1009       _queueEmitClipboardErrors(event);

  1010       ZeroClipboard.clearData();

  1011       if (element && element !== _safeActiveElement() && element.focus) {

  1012         element.focus();

  1013       }

  1014       break;

  1015 

  1016      case "_mouseover":

  1017       ZeroClipboard.focus(element);

  1018       if (_globalConfig.bubbleEvents === true && sourceIsSwf) {

  1019         if (element && element !== event.relatedTarget && !_containedBy(event.relatedTarget, element)) {

  1020           _fireMouseEvent(_extend({}, event, {

  1021             type: "mouseenter",

  1022             bubbles: false,

  1023             cancelable: false

  1024           }));

  1025         }

  1026         _fireMouseEvent(_extend({}, event, {

  1027           type: "mouseover"

  1028         }));

  1029       }

  1030       break;

  1031 

  1032      case "_mouseout":

  1033       ZeroClipboard.blur();

  1034       if (_globalConfig.bubbleEvents === true && sourceIsSwf) {

  1035         if (element && element !== event.relatedTarget && !_containedBy(event.relatedTarget, element)) {

  1036           _fireMouseEvent(_extend({}, event, {

  1037             type: "mouseleave",

  1038             bubbles: false,

  1039             cancelable: false

  1040           }));

  1041         }

  1042         _fireMouseEvent(_extend({}, event, {

  1043           type: "mouseout"

  1044         }));

  1045       }

  1046       break;

  1047 

  1048      case "_mousedown":

  1049       _addClass(element, _globalConfig.activeClass);

  1050       if (_globalConfig.bubbleEvents === true && sourceIsSwf) {

  1051         _fireMouseEvent(_extend({}, event, {

  1052           type: event.type.slice(1)

  1053         }));

  1054       }

  1055       break;

  1056 

  1057      case "_mouseup":

  1058       _removeClass(element, _globalConfig.activeClass);

  1059       if (_globalConfig.bubbleEvents === true && sourceIsSwf) {

  1060         _fireMouseEvent(_extend({}, event, {

  1061           type: event.type.slice(1)

  1062         }));

  1063       }

  1064       break;

  1065 

  1066      case "_click":

  1067       _copyTarget = null;

  1068       if (_globalConfig.bubbleEvents === true && sourceIsSwf) {

  1069         _fireMouseEvent(_extend({}, event, {

  1070           type: event.type.slice(1)

  1071         }));

  1072       }

  1073       break;

  1074 

  1075      case "_mousemove":

  1076       if (_globalConfig.bubbleEvents === true && sourceIsSwf) {

  1077         _fireMouseEvent(_extend({}, event, {

  1078           type: event.type.slice(1)

  1079         }));

  1080       }

  1081       break;

  1082     }

  1083     if (/^_(?:click|mouse(?:over|out|down|up|move))$/.test(event.type)) {

  1084       return true;

  1085     }

  1086   };

  1087   /**

  1088  * Check an "aftercopy" event for clipboard errors and emit a corresponding "error" event.

  1089  * @private

  1090  */

  1091   var _queueEmitClipboardErrors = function(aftercopyEvent) {

  1092     if (aftercopyEvent.errors && aftercopyEvent.errors.length > 0) {

  1093       var errorEvent = _deepCopy(aftercopyEvent);

  1094       _extend(errorEvent, {

  1095         type: "error",

  1096         name: "clipboard-error"

  1097       });

  1098       delete errorEvent.success;

  1099       _setTimeout(function() {

  1100         ZeroClipboard.emit(errorEvent);

  1101       }, 0);

  1102     }

  1103   };

  1104   /**

  1105  * Dispatch a synthetic MouseEvent.

  1106  *

  1107  * @returns `undefined`

  1108  * @private

  1109  */

  1110   var _fireMouseEvent = function(event) {

  1111     if (!(event && typeof event.type === "string" && event)) {

  1112       return;

  1113     }

  1114     var e, target = event.target || null, doc = target && target.ownerDocument || _document, defaults = {

  1115       view: doc.defaultView || _window,

  1116       canBubble: true,

  1117       cancelable: true,

  1118       detail: event.type === "click" ? 1 : 0,

  1119       button: typeof event.which === "number" ? event.which - 1 : typeof event.button === "number" ? event.button : doc.createEvent ? 0 : 1

  1120     }, args = _extend(defaults, event);

  1121     if (!target) {

  1122       return;

  1123     }

  1124     if (doc.createEvent && target.dispatchEvent) {

  1125       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 ];

  1126       e = doc.createEvent("MouseEvents");

  1127       if (e.initMouseEvent) {

  1128         e.initMouseEvent.apply(e, args);

  1129         e._source = "js";

  1130         target.dispatchEvent(e);

  1131       }

  1132     }

  1133   };

  1134   /**

  1135  * Continuously poll the DOM until either: