[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-includes/js/tinymce/plugins/paste/ -> plugin.js (source)

   1  (function () {
   2  var paste = (function (domGlobals) {
   3      'use strict';
   4  
   5      var Cell = function (initial) {
   6        var value = initial;
   7        var get = function () {
   8          return value;
   9        };
  10        var set = function (v) {
  11          value = v;
  12        };
  13        var clone = function () {
  14          return Cell(get());
  15        };
  16        return {
  17          get: get,
  18          set: set,
  19          clone: clone
  20        };
  21      };
  22  
  23      var global$1 = tinymce.util.Tools.resolve('tinymce.PluginManager');
  24  
  25      var hasProPlugin = function (editor) {
  26        if (/(^|[ ,])powerpaste([, ]|$)/.test(editor.settings.plugins) && global$1.get('powerpaste')) {
  27          if (typeof domGlobals.window.console !== 'undefined' && domGlobals.window.console.log) {
  28            domGlobals.window.console.log('PowerPaste is incompatible with Paste plugin! Remove \'paste\' from the \'plugins\' option.');
  29          }
  30          return true;
  31        } else {
  32          return false;
  33        }
  34      };
  35      var DetectProPlugin = { hasProPlugin: hasProPlugin };
  36  
  37      var get = function (clipboard, quirks) {
  38        return {
  39          clipboard: clipboard,
  40          quirks: quirks
  41        };
  42      };
  43      var Api = { get: get };
  44  
  45      var firePastePreProcess = function (editor, html, internal, isWordHtml) {
  46        return editor.fire('PastePreProcess', {
  47          content: html,
  48          internal: internal,
  49          wordContent: isWordHtml
  50        });
  51      };
  52      var firePastePostProcess = function (editor, node, internal, isWordHtml) {
  53        return editor.fire('PastePostProcess', {
  54          node: node,
  55          internal: internal,
  56          wordContent: isWordHtml
  57        });
  58      };
  59      var firePastePlainTextToggle = function (editor, state) {
  60        return editor.fire('PastePlainTextToggle', { state: state });
  61      };
  62      var firePaste = function (editor, ieFake) {
  63        return editor.fire('paste', { ieFake: ieFake });
  64      };
  65      var Events = {
  66        firePastePreProcess: firePastePreProcess,
  67        firePastePostProcess: firePastePostProcess,
  68        firePastePlainTextToggle: firePastePlainTextToggle,
  69        firePaste: firePaste
  70      };
  71  
  72      var shouldPlainTextInform = function (editor) {
  73        return editor.getParam('paste_plaintext_inform', true);
  74      };
  75      var shouldBlockDrop = function (editor) {
  76        return editor.getParam('paste_block_drop', false);
  77      };
  78      var shouldPasteDataImages = function (editor) {
  79        return editor.getParam('paste_data_images', false);
  80      };
  81      var shouldFilterDrop = function (editor) {
  82        return editor.getParam('paste_filter_drop', true);
  83      };
  84      var getPreProcess = function (editor) {
  85        return editor.getParam('paste_preprocess');
  86      };
  87      var getPostProcess = function (editor) {
  88        return editor.getParam('paste_postprocess');
  89      };
  90      var getWebkitStyles = function (editor) {
  91        return editor.getParam('paste_webkit_styles');
  92      };
  93      var shouldRemoveWebKitStyles = function (editor) {
  94        return editor.getParam('paste_remove_styles_if_webkit', true);
  95      };
  96      var shouldMergeFormats = function (editor) {
  97        return editor.getParam('paste_merge_formats', true);
  98      };
  99      var isSmartPasteEnabled = function (editor) {
 100        return editor.getParam('smart_paste', true);
 101      };
 102      var isPasteAsTextEnabled = function (editor) {
 103        return editor.getParam('paste_as_text', false);
 104      };
 105      var getRetainStyleProps = function (editor) {
 106        return editor.getParam('paste_retain_style_properties');
 107      };
 108      var getWordValidElements = function (editor) {
 109        var defaultValidElements = '-strong/b,-em/i,-u,-span,-p,-ol,-ul,-li,-h1,-h2,-h3,-h4,-h5,-h6,' + '-p/div,-a[href|name],sub,sup,strike,br,del,table[width],tr,' + 'td[colspan|rowspan|width],th[colspan|rowspan|width],thead,tfoot,tbody';
 110        return editor.getParam('paste_word_valid_elements', defaultValidElements);
 111      };
 112      var shouldConvertWordFakeLists = function (editor) {
 113        return editor.getParam('paste_convert_word_fake_lists', true);
 114      };
 115      var shouldUseDefaultFilters = function (editor) {
 116        return editor.getParam('paste_enable_default_filters', true);
 117      };
 118      var Settings = {
 119        shouldPlainTextInform: shouldPlainTextInform,
 120        shouldBlockDrop: shouldBlockDrop,
 121        shouldPasteDataImages: shouldPasteDataImages,
 122        shouldFilterDrop: shouldFilterDrop,
 123        getPreProcess: getPreProcess,
 124        getPostProcess: getPostProcess,
 125        getWebkitStyles: getWebkitStyles,
 126        shouldRemoveWebKitStyles: shouldRemoveWebKitStyles,
 127        shouldMergeFormats: shouldMergeFormats,
 128        isSmartPasteEnabled: isSmartPasteEnabled,
 129        isPasteAsTextEnabled: isPasteAsTextEnabled,
 130        getRetainStyleProps: getRetainStyleProps,
 131        getWordValidElements: getWordValidElements,
 132        shouldConvertWordFakeLists: shouldConvertWordFakeLists,
 133        shouldUseDefaultFilters: shouldUseDefaultFilters
 134      };
 135  
 136      var shouldInformUserAboutPlainText = function (editor, userIsInformedState) {
 137        return userIsInformedState.get() === false && Settings.shouldPlainTextInform(editor);
 138      };
 139      var displayNotification = function (editor, message) {
 140        editor.notificationManager.open({
 141          text: editor.translate(message),
 142          type: 'info'
 143        });
 144      };
 145      var togglePlainTextPaste = function (editor, clipboard, userIsInformedState) {
 146        if (clipboard.pasteFormat.get() === 'text') {
 147          clipboard.pasteFormat.set('html');
 148          Events.firePastePlainTextToggle(editor, false);
 149        } else {
 150          clipboard.pasteFormat.set('text');
 151          Events.firePastePlainTextToggle(editor, true);
 152          if (shouldInformUserAboutPlainText(editor, userIsInformedState)) {
 153            displayNotification(editor, 'Paste is now in plain text mode. Contents will now be pasted as plain text until you toggle this option off.');
 154            userIsInformedState.set(true);
 155          }
 156        }
 157        editor.focus();
 158      };
 159      var Actions = { togglePlainTextPaste: togglePlainTextPaste };
 160  
 161      var register = function (editor, clipboard, userIsInformedState) {
 162        editor.addCommand('mceTogglePlainTextPaste', function () {
 163          Actions.togglePlainTextPaste(editor, clipboard, userIsInformedState);
 164        });
 165        editor.addCommand('mceInsertClipboardContent', function (ui, value) {
 166          if (value.content) {
 167            clipboard.pasteHtml(value.content, value.internal);
 168          }
 169          if (value.text) {
 170            clipboard.pasteText(value.text);
 171          }
 172        });
 173      };
 174      var Commands = { register: register };
 175  
 176      var global$2 = tinymce.util.Tools.resolve('tinymce.Env');
 177  
 178      var global$3 = tinymce.util.Tools.resolve('tinymce.util.Delay');
 179  
 180      var global$4 = tinymce.util.Tools.resolve('tinymce.util.Tools');
 181  
 182      var global$5 = tinymce.util.Tools.resolve('tinymce.util.VK');
 183  
 184      var internalMimeType = 'x-tinymce/html';
 185      var internalMark = '<!-- ' + internalMimeType + ' -->';
 186      var mark = function (html) {
 187        return internalMark + html;
 188      };
 189      var unmark = function (html) {
 190        return html.replace(internalMark, '');
 191      };
 192      var isMarked = function (html) {
 193        return html.indexOf(internalMark) !== -1;
 194      };
 195      var InternalHtml = {
 196        mark: mark,
 197        unmark: unmark,
 198        isMarked: isMarked,
 199        internalHtmlMime: function () {
 200          return internalMimeType;
 201        }
 202      };
 203  
 204      var global$6 = tinymce.util.Tools.resolve('tinymce.html.Entities');
 205  
 206      var isPlainText = function (text) {
 207        return !/<(?:\/?(?!(?:div|p|br|span)>)\w+|(?:(?!(?:span style="white-space:\s?pre;?">)|br\s?\/>))\w+\s[^>]+)>/i.test(text);
 208      };
 209      var toBRs = function (text) {
 210        return text.replace(/\r?\n/g, '<br>');
 211      };
 212      var openContainer = function (rootTag, rootAttrs) {
 213        var key;
 214        var attrs = [];
 215        var tag = '<' + rootTag;
 216        if (typeof rootAttrs === 'object') {
 217          for (key in rootAttrs) {
 218            if (rootAttrs.hasOwnProperty(key)) {
 219              attrs.push(key + '="' + global$6.encodeAllRaw(rootAttrs[key]) + '"');
 220            }
 221          }
 222          if (attrs.length) {
 223            tag += ' ' + attrs.join(' ');
 224          }
 225        }
 226        return tag + '>';
 227      };
 228      var toBlockElements = function (text, rootTag, rootAttrs) {
 229        var blocks = text.split(/\n\n/);
 230        var tagOpen = openContainer(rootTag, rootAttrs);
 231        var tagClose = '</' + rootTag + '>';
 232        var paragraphs = global$4.map(blocks, function (p) {
 233          return p.split(/\n/).join('<br />');
 234        });
 235        var stitch = function (p) {
 236          return tagOpen + p + tagClose;
 237        };
 238        return paragraphs.length === 1 ? paragraphs[0] : global$4.map(paragraphs, stitch).join('');
 239      };
 240      var convert = function (text, rootTag, rootAttrs) {
 241        return rootTag ? toBlockElements(text, rootTag, rootAttrs) : toBRs(text);
 242      };
 243      var Newlines = {
 244        isPlainText: isPlainText,
 245        convert: convert,
 246        toBRs: toBRs,
 247        toBlockElements: toBlockElements
 248      };
 249  
 250      var global$7 = tinymce.util.Tools.resolve('tinymce.html.DomParser');
 251  
 252      var global$8 = tinymce.util.Tools.resolve('tinymce.html.Serializer');
 253  
 254      var global$9 = tinymce.util.Tools.resolve('tinymce.html.Node');
 255  
 256      var global$a = tinymce.util.Tools.resolve('tinymce.html.Schema');
 257  
 258      function filter(content, items) {
 259        global$4.each(items, function (v) {
 260          if (v.constructor === RegExp) {
 261            content = content.replace(v, '');
 262          } else {
 263            content = content.replace(v[0], v[1]);
 264          }
 265        });
 266        return content;
 267      }
 268      function innerText(html) {
 269        var schema = global$a();
 270        var domParser = global$7({}, schema);
 271        var text = '';
 272        var shortEndedElements = schema.getShortEndedElements();
 273        var ignoreElements = global$4.makeMap('script noscript style textarea video audio iframe object', ' ');
 274        var blockElements = schema.getBlockElements();
 275        function walk(node) {
 276          var name = node.name, currentNode = node;
 277          if (name === 'br') {
 278            text += '\n';
 279            return;
 280          }
 281          if (name === 'wbr') {
 282            return;
 283          }
 284          if (shortEndedElements[name]) {
 285            text += ' ';
 286          }
 287          if (ignoreElements[name]) {
 288            text += ' ';
 289            return;
 290          }
 291          if (node.type === 3) {
 292            text += node.value;
 293          }
 294          if (!node.shortEnded) {
 295            if (node = node.firstChild) {
 296              do {
 297                walk(node);
 298              } while (node = node.next);
 299            }
 300          }
 301          if (blockElements[name] && currentNode.next) {
 302            text += '\n';
 303            if (name === 'p') {
 304              text += '\n';
 305            }
 306          }
 307        }
 308        html = filter(html, [/<!\[[^\]]+\]>/g]);
 309        walk(domParser.parse(html));
 310        return text;
 311      }
 312      function trimHtml(html) {
 313        function trimSpaces(all, s1, s2) {
 314          if (!s1 && !s2) {
 315            return ' ';
 316          }
 317          return '\xA0';
 318        }
 319        html = filter(html, [
 320          /^[\s\S]*<body[^>]*>\s*|\s*<\/body[^>]*>[\s\S]*$/ig,
 321          /<!--StartFragment-->|<!--EndFragment-->/g,
 322          [
 323            /( ?)<span class="Apple-converted-space">\u00a0<\/span>( ?)/g,
 324            trimSpaces
 325          ],
 326          /<br class="Apple-interchange-newline">/g,
 327          /<br>$/i
 328        ]);
 329        return html;
 330      }
 331      function createIdGenerator(prefix) {
 332        var count = 0;
 333        return function () {
 334          return prefix + count++;
 335        };
 336      }
 337      var isMsEdge = function () {
 338        return domGlobals.navigator.userAgent.indexOf(' Edge/') !== -1;
 339      };
 340      var Utils = {
 341        filter: filter,
 342        innerText: innerText,
 343        trimHtml: trimHtml,
 344        createIdGenerator: createIdGenerator,
 345        isMsEdge: isMsEdge
 346      };
 347  
 348      function isWordContent(content) {
 349        return /<font face="Times New Roman"|class="?Mso|style="[^"]*\bmso-|style='[^'']*\bmso-|w:WordDocument/i.test(content) || /class="OutlineElement/.test(content) || /id="?docs\-internal\-guid\-/.test(content);
 350      }
 351      function isNumericList(text) {
 352        var found, patterns;
 353        patterns = [
 354          /^[IVXLMCD]{1,2}\.[ \u00a0]/,
 355          /^[ivxlmcd]{1,2}\.[ \u00a0]/,
 356          /^[a-z]{1,2}[\.\)][ \u00a0]/,
 357          /^[A-Z]{1,2}[\.\)][ \u00a0]/,
 358          /^[0-9]+\.[ \u00a0]/,
 359          /^[\u3007\u4e00\u4e8c\u4e09\u56db\u4e94\u516d\u4e03\u516b\u4e5d]+\.[ \u00a0]/,
 360          /^[\u58f1\u5f10\u53c2\u56db\u4f0d\u516d\u4e03\u516b\u4e5d\u62fe]+\.[ \u00a0]/
 361        ];
 362        text = text.replace(/^[\u00a0 ]+/, '');
 363        global$4.each(patterns, function (pattern) {
 364          if (pattern.test(text)) {
 365            found = true;
 366            return false;
 367          }
 368        });
 369        return found;
 370      }
 371      function isBulletList(text) {
 372        return /^[\s\u00a0]*[\u2022\u00b7\u00a7\u25CF]\s*/.test(text);
 373      }
 374      function convertFakeListsToProperLists(node) {
 375        var currentListNode, prevListNode, lastLevel = 1;
 376        function getText(node) {
 377          var txt = '';
 378          if (node.type === 3) {
 379            return node.value;
 380          }
 381          if (node = node.firstChild) {
 382            do {
 383              txt += getText(node);
 384            } while (node = node.next);
 385          }
 386          return txt;
 387        }
 388        function trimListStart(node, regExp) {
 389          if (node.type === 3) {
 390            if (regExp.test(node.value)) {
 391              node.value = node.value.replace(regExp, '');
 392              return false;
 393            }
 394          }
 395          if (node = node.firstChild) {
 396            do {
 397              if (!trimListStart(node, regExp)) {
 398                return false;
 399              }
 400            } while (node = node.next);
 401          }
 402          return true;
 403        }
 404        function removeIgnoredNodes(node) {
 405          if (node._listIgnore) {
 406            node.remove();
 407            return;
 408          }
 409          if (node = node.firstChild) {
 410            do {
 411              removeIgnoredNodes(node);
 412            } while (node = node.next);
 413          }
 414        }
 415        function convertParagraphToLi(paragraphNode, listName, start) {
 416          var level = paragraphNode._listLevel || lastLevel;
 417          if (level !== lastLevel) {
 418            if (level < lastLevel) {
 419              if (currentListNode) {
 420                currentListNode = currentListNode.parent.parent;
 421              }
 422            } else {
 423              prevListNode = currentListNode;
 424              currentListNode = null;
 425            }
 426          }
 427          if (!currentListNode || currentListNode.name !== listName) {
 428            prevListNode = prevListNode || currentListNode;
 429            currentListNode = new global$9(listName, 1);
 430            if (start > 1) {
 431              currentListNode.attr('start', '' + start);
 432            }
 433            paragraphNode.wrap(currentListNode);
 434          } else {
 435            currentListNode.append(paragraphNode);
 436          }
 437          paragraphNode.name = 'li';
 438          if (level > lastLevel && prevListNode) {
 439            prevListNode.lastChild.append(currentListNode);
 440          }
 441          lastLevel = level;
 442          removeIgnoredNodes(paragraphNode);
 443          trimListStart(paragraphNode, /^\u00a0+/);
 444          trimListStart(paragraphNode, /^\s*([\u2022\u00b7\u00a7\u25CF]|\w+\.)/);
 445          trimListStart(paragraphNode, /^\u00a0+/);
 446        }
 447        var elements = [];
 448        var child = node.firstChild;
 449        while (typeof child !== 'undefined' && child !== null) {
 450          elements.push(child);
 451          child = child.walk();
 452          if (child !== null) {
 453            while (typeof child !== 'undefined' && child.parent !== node) {
 454              child = child.walk();
 455            }
 456          }
 457        }
 458        for (var i = 0; i < elements.length; i++) {
 459          node = elements[i];
 460          if (node.name === 'p' && node.firstChild) {
 461            var nodeText = getText(node);
 462            if (isBulletList(nodeText)) {
 463              convertParagraphToLi(node, 'ul');
 464              continue;
 465            }
 466            if (isNumericList(nodeText)) {
 467              var matches = /([0-9]+)\./.exec(nodeText);
 468              var start = 1;
 469              if (matches) {
 470                start = parseInt(matches[1], 10);
 471              }
 472              convertParagraphToLi(node, 'ol', start);
 473              continue;
 474            }
 475            if (node._listLevel) {
 476              convertParagraphToLi(node, 'ul', 1);
 477              continue;
 478            }
 479            currentListNode = null;
 480          } else {
 481            prevListNode = currentListNode;
 482            currentListNode = null;
 483          }
 484        }
 485      }
 486      function filterStyles(editor, validStyles, node, styleValue) {
 487        var outputStyles = {}, matches;
 488        var styles = editor.dom.parseStyle(styleValue);
 489        global$4.each(styles, function (value, name) {
 490          switch (name) {
 491          case 'mso-list':
 492            matches = /\w+ \w+([0-9]+)/i.exec(styleValue);
 493            if (matches) {
 494              node._listLevel = parseInt(matches[1], 10);
 495            }
 496            if (/Ignore/i.test(value) && node.firstChild) {
 497              node._listIgnore = true;
 498              node.firstChild._listIgnore = true;
 499            }
 500            break;
 501          case 'horiz-align':
 502            name = 'text-align';
 503            break;
 504          case 'vert-align':
 505            name = 'vertical-align';
 506            break;
 507          case 'font-color':
 508          case 'mso-foreground':
 509            name = 'color';
 510            break;
 511          case 'mso-background':
 512          case 'mso-highlight':
 513            name = 'background';
 514            break;
 515          case 'font-weight':
 516          case 'font-style':
 517            if (value !== 'normal') {
 518              outputStyles[name] = value;
 519            }
 520            return;
 521          case 'mso-element':
 522            if (/^(comment|comment-list)$/i.test(value)) {
 523              node.remove();
 524              return;
 525            }
 526            break;
 527          }
 528          if (name.indexOf('mso-comment') === 0) {
 529            node.remove();
 530            return;
 531          }
 532          if (name.indexOf('mso-') === 0) {
 533            return;
 534          }
 535          if (Settings.getRetainStyleProps(editor) === 'all' || validStyles && validStyles[name]) {
 536            outputStyles[name] = value;
 537          }
 538        });
 539        if (/(bold)/i.test(outputStyles['font-weight'])) {
 540          delete outputStyles['font-weight'];
 541          node.wrap(new global$9('b', 1));
 542        }
 543        if (/(italic)/i.test(outputStyles['font-style'])) {
 544          delete outputStyles['font-style'];
 545          node.wrap(new global$9('i', 1));
 546        }
 547        outputStyles = editor.dom.serializeStyle(outputStyles, node.name);
 548        if (outputStyles) {
 549          return outputStyles;
 550        }
 551        return null;
 552      }
 553      var filterWordContent = function (editor, content) {
 554        var retainStyleProperties, validStyles;
 555        retainStyleProperties = Settings.getRetainStyleProps(editor);
 556        if (retainStyleProperties) {
 557          validStyles = global$4.makeMap(retainStyleProperties.split(/[, ]/));
 558        }
 559        content = Utils.filter(content, [
 560          /<br class="?Apple-interchange-newline"?>/gi,
 561          /<b[^>]+id="?docs-internal-[^>]*>/gi,
 562          /<!--[\s\S]+?-->/gi,
 563          /<(!|script[^>]*>.*?<\/script(?=[>\s])|\/?(\?xml(:\w+)?|img|meta|link|style|\w:\w+)(?=[\s\/>]))[^>]*>/gi,
 564          [
 565            /<(\/?)s>/gi,
 566            '<$1strike>'
 567          ],
 568          [
 569            /&nbsp;/gi,
 570            '\xA0'
 571          ],
 572          [
 573            /<span\s+style\s*=\s*"\s*mso-spacerun\s*:\s*yes\s*;?\s*"\s*>([\s\u00a0]*)<\/span>/gi,
 574            function (str, spaces) {
 575              return spaces.length > 0 ? spaces.replace(/./, ' ').slice(Math.floor(spaces.length / 2)).split('').join('\xA0') : '';
 576            }
 577          ]
 578        ]);
 579        var validElements = Settings.getWordValidElements(editor);
 580        var schema = global$a({
 581          valid_elements: validElements,
 582          valid_children: '-li[p]'
 583        });
 584        global$4.each(schema.elements, function (rule) {
 585          if (!rule.attributes.class) {
 586            rule.attributes.class = {};
 587            rule.attributesOrder.push('class');
 588          }
 589          if (!rule.attributes.style) {
 590            rule.attributes.style = {};
 591            rule.attributesOrder.push('style');
 592          }
 593        });
 594        var domParser = global$7({}, schema);
 595        domParser.addAttributeFilter('style', function (nodes) {
 596          var i = nodes.length, node;
 597          while (i--) {
 598            node = nodes[i];
 599            node.attr('style', filterStyles(editor, validStyles, node, node.attr('style')));
 600            if (node.name === 'span' && node.parent && !node.attributes.length) {
 601              node.unwrap();
 602            }
 603          }
 604        });
 605        domParser.addAttributeFilter('class', function (nodes) {
 606          var i = nodes.length, node, className;
 607          while (i--) {
 608            node = nodes[i];
 609            className = node.attr('class');
 610            if (/^(MsoCommentReference|MsoCommentText|msoDel)$/i.test(className)) {
 611              node.remove();
 612            }
 613            node.attr('class', null);
 614          }
 615        });
 616        domParser.addNodeFilter('del', function (nodes) {
 617          var i = nodes.length;
 618          while (i--) {
 619            nodes[i].remove();
 620          }
 621        });
 622        domParser.addNodeFilter('a', function (nodes) {
 623          var i = nodes.length, node, href, name;
 624          while (i--) {
 625            node = nodes[i];
 626            href = node.attr('href');
 627            name = node.attr('name');
 628            if (href && href.indexOf('#_msocom_') !== -1) {
 629              node.remove();
 630              continue;
 631            }
 632            if (href && href.indexOf('file://') === 0) {
 633              href = href.split('#')[1];
 634              if (href) {
 635                href = '#' + href;
 636              }
 637            }
 638            if (!href && !name) {
 639              node.unwrap();
 640            } else {
 641              if (name && !/^_?(?:toc|edn|ftn)/i.test(name)) {
 642                node.unwrap();
 643                continue;
 644              }
 645              node.attr({
 646                href: href,
 647                name: name
 648              });
 649            }
 650          }
 651        });
 652        var rootNode = domParser.parse(content);
 653        if (Settings.shouldConvertWordFakeLists(editor)) {
 654          convertFakeListsToProperLists(rootNode);
 655        }
 656        content = global$8({ validate: editor.settings.validate }, schema).serialize(rootNode);
 657        return content;
 658      };
 659      var preProcess = function (editor, content) {
 660        return Settings.shouldUseDefaultFilters(editor) ? filterWordContent(editor, content) : content;
 661      };
 662      var WordFilter = {
 663        preProcess: preProcess,
 664        isWordContent: isWordContent
 665      };
 666  
 667      var preProcess$1 = function (editor, html) {
 668        var parser = global$7({}, editor.schema);
 669        parser.addNodeFilter('meta', function (nodes) {
 670          global$4.each(nodes, function (node) {
 671            return node.remove();
 672          });
 673        });
 674        var fragment = parser.parse(html, {
 675          forced_root_block: false,
 676          isRootContent: true
 677        });
 678        return global$8({ validate: editor.settings.validate }, editor.schema).serialize(fragment);
 679      };
 680      var processResult = function (content, cancelled) {
 681        return {
 682          content: content,
 683          cancelled: cancelled
 684        };
 685      };
 686      var postProcessFilter = function (editor, html, internal, isWordHtml) {
 687        var tempBody = editor.dom.create('div', { style: 'display:none' }, html);
 688        var postProcessArgs = Events.firePastePostProcess(editor, tempBody, internal, isWordHtml);
 689        return processResult(postProcessArgs.node.innerHTML, postProcessArgs.isDefaultPrevented());
 690      };
 691      var filterContent = function (editor, content, internal, isWordHtml) {
 692        var preProcessArgs = Events.firePastePreProcess(editor, content, internal, isWordHtml);
 693        var filteredContent = preProcess$1(editor, preProcessArgs.content);
 694        if (editor.hasEventListeners('PastePostProcess') && !preProcessArgs.isDefaultPrevented()) {
 695          return postProcessFilter(editor, filteredContent, internal, isWordHtml);
 696        } else {
 697          return processResult(filteredContent, preProcessArgs.isDefaultPrevented());
 698        }
 699      };
 700      var process = function (editor, html, internal) {
 701        var isWordHtml = WordFilter.isWordContent(html);
 702        var content = isWordHtml ? WordFilter.preProcess(editor, html) : html;
 703        return filterContent(editor, content, internal, isWordHtml);
 704      };
 705      var ProcessFilters = { process: process };
 706  
 707      var pasteHtml = function (editor, html) {
 708        editor.insertContent(html, {
 709          merge: Settings.shouldMergeFormats(editor),
 710          paste: true
 711        });
 712        return true;
 713      };
 714      var isAbsoluteUrl = function (url) {
 715        return /^https?:\/\/[\w\?\-\/+=.&%@~#]+$/i.test(url);
 716      };
 717      var isImageUrl = function (url) {
 718        return isAbsoluteUrl(url) && /.(gif|jpe?g|png)$/.test(url);
 719      };
 720      var createImage = function (editor, url, pasteHtmlFn) {
 721        editor.undoManager.extra(function () {
 722          pasteHtmlFn(editor, url);
 723        }, function () {
 724          editor.insertContent('<img src="' + url + '">');
 725        });
 726        return true;
 727      };
 728      var createLink = function (editor, url, pasteHtmlFn) {
 729        editor.undoManager.extra(function () {
 730          pasteHtmlFn(editor, url);
 731        }, function () {
 732          editor.execCommand('mceInsertLink', false, url);
 733        });
 734        return true;
 735      };
 736      var linkSelection = function (editor, html, pasteHtmlFn) {
 737        return editor.selection.isCollapsed() === false && isAbsoluteUrl(html) ? createLink(editor, html, pasteHtmlFn) : false;
 738      };
 739      var insertImage = function (editor, html, pasteHtmlFn) {
 740        return isImageUrl(html) ? createImage(editor, html, pasteHtmlFn) : false;
 741      };
 742      var smartInsertContent = function (editor, html) {
 743        global$4.each([
 744          linkSelection,
 745          insertImage,
 746          pasteHtml
 747        ], function (action) {
 748          return action(editor, html, pasteHtml) !== true;
 749        });
 750      };
 751      var insertContent = function (editor, html) {
 752        if (Settings.isSmartPasteEnabled(editor) === false) {
 753          pasteHtml(editor, html);
 754        } else {
 755          smartInsertContent(editor, html);
 756        }
 757      };
 758      var SmartPaste = {
 759        isImageUrl: isImageUrl,
 760        isAbsoluteUrl: isAbsoluteUrl,
 761        insertContent: insertContent
 762      };
 763  
 764      var noop = function () {
 765      };
 766      var constant = function (value) {
 767        return function () {
 768          return value;
 769        };
 770      };
 771      function curry(fn) {
 772        var initialArgs = [];
 773        for (var _i = 1; _i < arguments.length; _i++) {
 774          initialArgs[_i - 1] = arguments[_i];
 775        }
 776        return function () {
 777          var restArgs = [];
 778          for (var _i = 0; _i < arguments.length; _i++) {
 779            restArgs[_i] = arguments[_i];
 780          }
 781          var all = initialArgs.concat(restArgs);
 782          return fn.apply(null, all);
 783        };
 784      }
 785      var never = constant(false);
 786      var always = constant(true);
 787  
 788      var none = function () {
 789        return NONE;
 790      };
 791      var NONE = function () {
 792        var eq = function (o) {
 793          return o.isNone();
 794        };
 795        var call = function (thunk) {
 796          return thunk();
 797        };
 798        var id = function (n) {
 799          return n;
 800        };
 801        var me = {
 802          fold: function (n, s) {
 803            return n();
 804          },
 805          is: never,
 806          isSome: never,
 807          isNone: always,
 808          getOr: id,
 809          getOrThunk: call,
 810          getOrDie: function (msg) {
 811            throw new Error(msg || 'error: getOrDie called on none.');
 812          },
 813          getOrNull: constant(null),
 814          getOrUndefined: constant(undefined),
 815          or: id,
 816          orThunk: call,
 817          map: none,
 818          each: noop,
 819          bind: none,
 820          exists: never,
 821          forall: always,
 822          filter: none,
 823          equals: eq,
 824          equals_: eq,
 825          toArray: function () {
 826            return [];
 827          },
 828          toString: constant('none()')
 829        };
 830        if (Object.freeze) {
 831          Object.freeze(me);
 832        }
 833        return me;
 834      }();
 835      var some = function (a) {
 836        var constant_a = constant(a);
 837        var self = function () {
 838          return me;
 839        };
 840        var bind = function (f) {
 841          return f(a);
 842        };
 843        var me = {
 844          fold: function (n, s) {
 845            return s(a);
 846          },
 847          is: function (v) {
 848            return a === v;
 849          },
 850          isSome: always,
 851          isNone: never,
 852          getOr: constant_a,
 853          getOrThunk: constant_a,
 854          getOrDie: constant_a,
 855          getOrNull: constant_a,
 856          getOrUndefined: constant_a,
 857          or: self,
 858          orThunk: self,
 859          map: function (f) {
 860            return some(f(a));
 861          },
 862          each: function (f) {
 863            f(a);
 864          },
 865          bind: bind,
 866          exists: bind,
 867          forall: bind,
 868          filter: function (f) {
 869            return f(a) ? me : NONE;
 870          },
 871          toArray: function () {
 872            return [a];
 873          },
 874          toString: function () {
 875            return 'some(' + a + ')';
 876          },
 877          equals: function (o) {
 878            return o.is(a);
 879          },
 880          equals_: function (o, elementEq) {
 881            return o.fold(never, function (b) {
 882              return elementEq(a, b);
 883            });
 884          }
 885        };
 886        return me;
 887      };
 888      var from = function (value) {
 889        return value === null || value === undefined ? NONE : some(value);
 890      };
 891      var Option = {
 892        some: some,
 893        none: none,
 894        from: from
 895      };
 896  
 897      var typeOf = function (x) {
 898        if (x === null) {
 899          return 'null';
 900        }
 901        var t = typeof x;
 902        if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) {
 903          return 'array';
 904        }
 905        if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) {
 906          return 'string';
 907        }
 908        return t;
 909      };
 910      var isType = function (type) {
 911        return function (value) {
 912          return typeOf(value) === type;
 913        };
 914      };
 915      var isFunction = isType('function');
 916  
 917      var nativeSlice = Array.prototype.slice;
 918      var map = function (xs, f) {
 919        var len = xs.length;
 920        var r = new Array(len);
 921        for (var i = 0; i < len; i++) {
 922          var x = xs[i];
 923          r[i] = f(x, i);
 924        }
 925        return r;
 926      };
 927      var each = function (xs, f) {
 928        for (var i = 0, len = xs.length; i < len; i++) {
 929          var x = xs[i];
 930          f(x, i);
 931        }
 932      };
 933      var filter$1 = function (xs, pred) {
 934        var r = [];
 935        for (var i = 0, len = xs.length; i < len; i++) {
 936          var x = xs[i];
 937          if (pred(x, i)) {
 938            r.push(x);
 939          }
 940        }
 941        return r;
 942      };
 943      var from$1 = isFunction(Array.from) ? Array.from : function (x) {
 944        return nativeSlice.call(x);
 945      };
 946  
 947      var exports$1 = {}, module = { exports: exports$1 };
 948      (function (define, exports, module, require) {
 949        (function (f) {
 950          if (typeof exports === 'object' && typeof module !== 'undefined') {
 951            module.exports = f();
 952          } else if (typeof define === 'function' && define.amd) {
 953            define([], f);
 954          } else {
 955            var g;
 956            if (typeof window !== 'undefined') {
 957              g = window;
 958            } else if (typeof global !== 'undefined') {
 959              g = global;
 960            } else if (typeof self !== 'undefined') {
 961              g = self;
 962            } else {
 963              g = this;
 964            }
 965            g.EphoxContactWrapper = f();
 966          }
 967        }(function () {
 968          return function () {
 969            function r(e, n, t) {
 970              function o(i, f) {
 971                if (!n[i]) {
 972                  if (!e[i]) {
 973                    var c = 'function' == typeof require && require;
 974                    if (!f && c)
 975                      return c(i, !0);
 976                    if (u)
 977                      return u(i, !0);
 978                    var a = new Error('Cannot find module \'' + i + '\'');
 979                    throw a.code = 'MODULE_NOT_FOUND', a;
 980                  }
 981                  var p = n[i] = { exports: {} };
 982                  e[i][0].call(p.exports, function (r) {
 983                    var n = e[i][1][r];
 984                    return o(n || r);
 985                  }, p, p.exports, r, e, n, t);
 986                }
 987                return n[i].exports;
 988              }
 989              for (var u = 'function' == typeof require && require, i = 0; i < t.length; i++)
 990                o(t[i]);
 991              return o;
 992            }
 993            return r;
 994          }()({
 995            1: [
 996              function (require, module, exports) {
 997                var process = module.exports = {};
 998                var cachedSetTimeout;
 999                var cachedClearTimeout;
1000                function defaultSetTimout() {
1001                  throw new Error('setTimeout has not been defined');
1002                }
1003                function defaultClearTimeout() {
1004                  throw new Error('clearTimeout has not been defined');
1005                }
1006                (function () {
1007                  try {
1008                    if (typeof setTimeout === 'function') {
1009                      cachedSetTimeout = setTimeout;
1010                    } else {
1011                      cachedSetTimeout = defaultSetTimout;
1012                    }
1013                  } catch (e) {
1014                    cachedSetTimeout = defaultSetTimout;
1015                  }
1016                  try {
1017                    if (typeof clearTimeout === 'function') {
1018                      cachedClearTimeout = clearTimeout;
1019                    } else {
1020                      cachedClearTimeout = defaultClearTimeout;
1021                    }
1022                  } catch (e) {
1023                    cachedClearTimeout = defaultClearTimeout;
1024                  }
1025                }());
1026                function runTimeout(fun) {
1027                  if (cachedSetTimeout === setTimeout) {
1028                    return setTimeout(fun, 0);
1029                  }
1030                  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
1031                    cachedSetTimeout = setTimeout;
1032                    return setTimeout(fun, 0);
1033                  }
1034                  try {
1035                    return cachedSetTimeout(fun, 0);
1036                  } catch (e) {
1037                    try {
1038                      return cachedSetTimeout.call(null, fun, 0);
1039                    } catch (e) {
1040                      return cachedSetTimeout.call(this, fun, 0);
1041                    }
1042                  }
1043                }
1044                function runClearTimeout(marker) {
1045                  if (cachedClearTimeout === clearTimeout) {
1046                    return clearTimeout(marker);
1047                  }
1048                  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
1049                    cachedClearTimeout = clearTimeout;
1050                    return clearTimeout(marker);
1051                  }
1052                  try {
1053                    return cachedClearTimeout(marker);
1054                  } catch (e) {
1055                    try {
1056                      return cachedClearTimeout.call(null, marker);
1057                    } catch (e) {
1058                      return cachedClearTimeout.call(this, marker);
1059                    }
1060                  }
1061                }
1062                var queue = [];
1063                var draining = false;
1064                var currentQueue;
1065                var queueIndex = -1;
1066                function cleanUpNextTick() {
1067                  if (!draining || !currentQueue) {
1068                    return;
1069                  }
1070                  draining = false;
1071                  if (currentQueue.length) {
1072                    queue = currentQueue.concat(queue);
1073                  } else {
1074                    queueIndex = -1;
1075                  }
1076                  if (queue.length) {
1077                    drainQueue();
1078                  }
1079                }
1080                function drainQueue() {
1081                  if (draining) {
1082                    return;
1083                  }
1084                  var timeout = runTimeout(cleanUpNextTick);
1085                  draining = true;
1086                  var len = queue.length;
1087                  while (len) {
1088                    currentQueue = queue;
1089                    queue = [];
1090                    while (++queueIndex < len) {
1091                      if (currentQueue) {
1092                        currentQueue[queueIndex].run();
1093                      }
1094                    }
1095                    queueIndex = -1;
1096                    len = queue.length;
1097                  }
1098                  currentQueue = null;
1099                  draining = false;
1100                  runClearTimeout(timeout);
1101                }
1102                process.nextTick = function (fun) {
1103                  var args = new Array(arguments.length - 1);
1104                  if (arguments.length > 1) {
1105                    for (var i = 1; i < arguments.length; i++) {
1106                      args[i - 1] = arguments[i];
1107                    }
1108                  }
1109                  queue.push(new Item(fun, args));
1110                  if (queue.length === 1 && !draining) {
1111                    runTimeout(drainQueue);
1112                  }
1113                };
1114                function Item(fun, array) {
1115                  this.fun = fun;
1116                  this.array = array;
1117                }
1118                Item.prototype.run = function () {
1119                  this.fun.apply(null, this.array);
1120                };
1121                process.title = 'browser';
1122                process.browser = true;
1123                process.env = {};
1124                process.argv = [];
1125                process.version = '';
1126                process.versions = {};
1127                function noop() {
1128                }
1129                process.on = noop;
1130                process.addListener = noop;
1131                process.once = noop;
1132                process.off = noop;
1133                process.removeListener = noop;
1134                process.removeAllListeners = noop;
1135                process.emit = noop;
1136                process.prependListener = noop;
1137                process.prependOnceListener = noop;
1138                process.listeners = function (name) {
1139                  return [];
1140                };
1141                process.binding = function (name) {
1142                  throw new Error('process.binding is not supported');
1143                };
1144                process.cwd = function () {
1145                  return '/';
1146                };
1147                process.chdir = function (dir) {
1148                  throw new Error('process.chdir is not supported');
1149                };
1150                process.umask = function () {
1151                  return 0;
1152                };
1153              },
1154              {}
1155            ],
1156            2: [
1157              function (require, module, exports) {
1158                (function (setImmediate) {
1159                  (function (root) {
1160                    var setTimeoutFunc = setTimeout;
1161                    function noop() {
1162                    }
1163                    function bind(fn, thisArg) {
1164                      return function () {
1165                        fn.apply(thisArg, arguments);
1166                      };
1167                    }
1168                    function Promise(fn) {
1169                      if (typeof this !== 'object')
1170                        throw new TypeError('Promises must be constructed via new');
1171                      if (typeof fn !== 'function')
1172                        throw new TypeError('not a function');
1173                      this._state = 0;
1174                      this._handled = false;
1175                      this._value = undefined;
1176                      this._deferreds = [];
1177                      doResolve(fn, this);
1178                    }
1179                    function handle(self, deferred) {
1180                      while (self._state === 3) {
1181                        self = self._value;
1182                      }
1183                      if (self._state === 0) {
1184                        self._deferreds.push(deferred);
1185                        return;
1186                      }
1187                      self._handled = true;
1188                      Promise._immediateFn(function () {
1189                        var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;
1190                        if (cb === null) {
1191                          (self._state === 1 ? resolve : reject)(deferred.promise, self._value);
1192                          return;
1193                        }
1194                        var ret;
1195                        try {
1196                          ret = cb(self._value);
1197                        } catch (e) {
1198                          reject(deferred.promise, e);
1199                          return;
1200                        }
1201                        resolve(deferred.promise, ret);
1202                      });
1203                    }
1204                    function resolve(self, newValue) {
1205                      try {
1206                        if (newValue === self)
1207                          throw new TypeError('A promise cannot be resolved with itself.');
1208                        if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
1209                          var then = newValue.then;
1210                          if (newValue instanceof Promise) {
1211                            self._state = 3;
1212                            self._value = newValue;
1213                            finale(self);
1214                            return;
1215                          } else if (typeof then === 'function') {
1216                            doResolve(bind(then, newValue), self);
1217                            return;
1218                          }
1219                        }
1220                        self._state = 1;
1221                        self._value = newValue;
1222                        finale(self);
1223                      } catch (e) {
1224                        reject(self, e);
1225                      }
1226                    }
1227                    function reject(self, newValue) {
1228                      self._state = 2;
1229                      self._value = newValue;
1230                      finale(self);
1231                    }
1232                    function finale(self) {
1233                      if (self._state === 2 && self._deferreds.length === 0) {
1234                        Promise._immediateFn(function () {
1235                          if (!self._handled) {
1236                            Promise._unhandledRejectionFn(self._value);
1237                          }
1238                        });
1239                      }
1240                      for (var i = 0, len = self._deferreds.length; i < len; i++) {
1241                        handle(self, self._deferreds[i]);
1242                      }
1243                      self._deferreds = null;
1244                    }
1245                    function Handler(onFulfilled, onRejected, promise) {
1246                      this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
1247                      this.onRejected = typeof onRejected === 'function' ? onRejected : null;
1248                      this.promise = promise;
1249                    }
1250                    function doResolve(fn, self) {
1251                      var done = false;
1252                      try {
1253                        fn(function (value) {
1254                          if (done)
1255                            return;
1256                          done = true;
1257                          resolve(self, value);
1258                        }, function (reason) {
1259                          if (done)
1260                            return;
1261                          done = true;
1262                          reject(self, reason);
1263                        });
1264                      } catch (ex) {
1265                        if (done)
1266                          return;
1267                        done = true;
1268                        reject(self, ex);
1269                      }
1270                    }
1271                    Promise.prototype['catch'] = function (onRejected) {
1272                      return this.then(null, onRejected);
1273                    };
1274                    Promise.prototype.then = function (onFulfilled, onRejected) {
1275                      var prom = new this.constructor(noop);
1276                      handle(this, new Handler(onFulfilled, onRejected, prom));
1277                      return prom;
1278                    };
1279                    Promise.all = function (arr) {
1280                      var args = Array.prototype.slice.call(arr);
1281                      return new Promise(function (resolve, reject) {
1282                        if (args.length === 0)
1283                          return resolve([]);
1284                        var remaining = args.length;
1285                        function res(i, val) {
1286                          try {
1287                            if (val && (typeof val === 'object' || typeof val === 'function')) {
1288                              var then = val.then;
1289                              if (typeof then === 'function') {
1290                                then.call(val, function (val) {
1291                                  res(i, val);
1292                                }, reject);
1293                                return;
1294                              }
1295                            }
1296                            args[i] = val;
1297                            if (--remaining === 0) {
1298                              resolve(args);
1299                            }
1300                          } catch (ex) {
1301                            reject(ex);
1302                          }
1303                        }
1304                        for (var i = 0; i < args.length; i++) {
1305                          res(i, args[i]);
1306                        }
1307                      });
1308                    };
1309                    Promise.resolve = function (value) {
1310                      if (value && typeof value === 'object' && value.constructor === Promise) {
1311                        return value;
1312                      }
1313                      return new Promise(function (resolve) {
1314                        resolve(value);
1315                      });
1316                    };
1317                    Promise.reject = function (value) {
1318                      return new Promise(function (resolve, reject) {
1319                        reject(value);
1320                      });
1321                    };
1322                    Promise.race = function (values) {
1323                      return new Promise(function (resolve, reject) {
1324                        for (var i = 0, len = values.length; i < len; i++) {
1325                          values[i].then(resolve, reject);
1326                        }
1327                      });
1328                    };
1329                    Promise._immediateFn = typeof setImmediate === 'function' ? function (fn) {
1330                      setImmediate(fn);
1331                    } : function (fn) {
1332                      setTimeoutFunc(fn, 0);
1333                    };
1334                    Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) {
1335                      if (typeof console !== 'undefined' && console) {
1336                        console.warn('Possible Unhandled Promise Rejection:', err);
1337                      }
1338                    };
1339                    Promise._setImmediateFn = function _setImmediateFn(fn) {
1340                      Promise._immediateFn = fn;
1341                    };
1342                    Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {
1343                      Promise._unhandledRejectionFn = fn;
1344                    };
1345                    if (typeof module !== 'undefined' && module.exports) {
1346                      module.exports = Promise;
1347                    } else if (!root.Promise) {
1348                      root.Promise = Promise;
1349                    }
1350                  }(this));
1351                }.call(this, require('timers').setImmediate));
1352              },
1353              { 'timers': 3 }
1354            ],
1355            3: [
1356              function (require, module, exports) {
1357                (function (setImmediate, clearImmediate) {
1358                  var nextTick = require('process/browser.js').nextTick;
1359                  var apply = Function.prototype.apply;
1360                  var slice = Array.prototype.slice;
1361                  var immediateIds = {};
1362                  var nextImmediateId = 0;
1363                  exports.setTimeout = function () {
1364                    return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
1365                  };
1366                  exports.setInterval = function () {
1367                    return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
1368                  };
1369                  exports.clearTimeout = exports.clearInterval = function (timeout) {
1370                    timeout.close();
1371                  };
1372                  function Timeout(id, clearFn) {
1373                    this._id = id;
1374                    this._clearFn = clearFn;
1375                  }
1376                  Timeout.prototype.unref = Timeout.prototype.ref = function () {
1377                  };
1378                  Timeout.prototype.close = function () {
1379                    this._clearFn.call(window, this._id);
1380                  };
1381                  exports.enroll = function (item, msecs) {
1382                    clearTimeout(item._idleTimeoutId);
1383                    item._idleTimeout = msecs;
1384                  };
1385                  exports.unenroll = function (item) {
1386                    clearTimeout(item._idleTimeoutId);
1387                    item._idleTimeout = -1;
1388                  };
1389                  exports._unrefActive = exports.active = function (item) {
1390                    clearTimeout(item._idleTimeoutId);
1391                    var msecs = item._idleTimeout;
1392                    if (msecs >= 0) {
1393                      item._idleTimeoutId = setTimeout(function onTimeout() {
1394                        if (item._onTimeout)
1395                          item._onTimeout();
1396                      }, msecs);
1397                    }
1398                  };
1399                  exports.setImmediate = typeof setImmediate === 'function' ? setImmediate : function (fn) {
1400                    var id = nextImmediateId++;
1401                    var args = arguments.length < 2 ? false : slice.call(arguments, 1);
1402                    immediateIds[id] = true;
1403                    nextTick(function onNextTick() {
1404                      if (immediateIds[id]) {
1405                        if (args) {
1406                          fn.apply(null, args);
1407                        } else {
1408                          fn.call(null);
1409                        }
1410                        exports.clearImmediate(id);
1411                      }
1412                    });
1413                    return id;
1414                  };
1415                  exports.clearImmediate = typeof clearImmediate === 'function' ? clearImmediate : function (id) {
1416                    delete immediateIds[id];
1417                  };
1418                }.call(this, require('timers').setImmediate, require('timers').clearImmediate));
1419              },
1420              {
1421                'process/browser.js': 1,
1422                'timers': 3
1423              }
1424            ],
1425            4: [
1426              function (require, module, exports) {
1427                var promisePolyfill = require('promise-polyfill');
1428                var Global = function () {
1429                  if (typeof window !== 'undefined') {
1430                    return window;
1431                  } else {
1432                    return Function('return this;')();
1433                  }
1434                }();
1435                module.exports = { boltExport: Global.Promise || promisePolyfill };
1436              },
1437              { 'promise-polyfill': 2 }
1438            ]
1439          }, {}, [4])(4);
1440        }));
1441      }(undefined, exports$1, module, undefined));
1442      var Promise = module.exports.boltExport;
1443  
1444      var nu = function (baseFn) {
1445        var data = Option.none();
1446        var callbacks = [];
1447        var map = function (f) {
1448          return nu(function (nCallback) {
1449            get(function (data) {
1450              nCallback(f(data));
1451            });
1452          });
1453        };
1454        var get = function (nCallback) {
1455          if (isReady()) {
1456            call(nCallback);
1457          } else {
1458            callbacks.push(nCallback);
1459          }
1460        };
1461        var set = function (x) {
1462          data = Option.some(x);
1463          run(callbacks);
1464          callbacks = [];
1465        };
1466        var isReady = function () {
1467          return data.isSome();
1468        };
1469        var run = function (cbs) {
1470          each(cbs, call);
1471        };
1472        var call = function (cb) {
1473          data.each(function (x) {
1474            domGlobals.setTimeout(function () {
1475              cb(x);
1476            }, 0);
1477          });
1478        };
1479        baseFn(set);
1480        return {
1481          get: get,
1482          map: map,
1483          isReady: isReady
1484        };
1485      };
1486      var pure = function (a) {
1487        return nu(function (callback) {
1488          callback(a);
1489        });
1490      };
1491      var LazyValue = {
1492        nu: nu,
1493        pure: pure
1494      };
1495  
1496      var errorReporter = function (err) {
1497        domGlobals.setTimeout(function () {
1498          throw err;
1499        }, 0);
1500      };
1501      var make = function (run) {
1502        var get = function (callback) {
1503          run().then(callback, errorReporter);
1504        };
1505        var map = function (fab) {
1506          return make(function () {
1507            return run().then(fab);
1508          });
1509        };
1510        var bind = function (aFutureB) {
1511          return make(function () {
1512            return run().then(function (v) {
1513              return aFutureB(v).toPromise();
1514            });
1515          });
1516        };
1517        var anonBind = function (futureB) {
1518          return make(function () {
1519            return run().then(function () {
1520              return futureB.toPromise();
1521            });
1522          });
1523        };
1524        var toLazy = function () {
1525          return LazyValue.nu(get);
1526        };
1527        var toCached = function () {
1528          var cache = null;
1529          return make(function () {
1530            if (cache === null) {
1531              cache = run();
1532            }
1533            return cache;
1534          });
1535        };
1536        var toPromise = run;
1537        return {
1538          map: map,
1539          bind: bind,
1540          anonBind: anonBind,
1541          toLazy: toLazy,
1542          toCached: toCached,
1543          toPromise: toPromise,
1544          get: get
1545        };
1546      };
1547      var nu$1 = function (baseFn) {
1548        return make(function () {
1549          return new Promise(baseFn);
1550        });
1551      };
1552      var pure$1 = function (a) {
1553        return make(function () {
1554          return Promise.resolve(a);
1555        });
1556      };
1557      var Future = {
1558        nu: nu$1,
1559        pure: pure$1
1560      };
1561  
1562      var par = function (asyncValues, nu) {
1563        return nu(function (callback) {
1564          var r = [];
1565          var count = 0;
1566          var cb = function (i) {
1567            return function (value) {
1568              r[i] = value;
1569              count++;
1570              if (count >= asyncValues.length) {
1571                callback(r);
1572              }
1573            };
1574          };
1575          if (asyncValues.length === 0) {
1576            callback([]);
1577          } else {
1578            each(asyncValues, function (asyncValue, i) {
1579              asyncValue.get(cb(i));
1580            });
1581          }
1582        });
1583      };
1584  
1585      var par$1 = function (futures) {
1586        return par(futures, Future.nu);
1587      };
1588      var traverse = function (array, fn) {
1589        return par$1(map(array, fn));
1590      };
1591      var mapM = traverse;
1592  
1593      var value = function () {
1594        var subject = Cell(Option.none());
1595        var clear = function () {
1596          subject.set(Option.none());
1597        };
1598        var set = function (s) {
1599          subject.set(Option.some(s));
1600        };
1601        var on = function (f) {
1602          subject.get().each(f);
1603        };
1604        var isSet = function () {
1605          return subject.get().isSome();
1606        };
1607        return {
1608          clear: clear,
1609          set: set,
1610          isSet: isSet,
1611          on: on
1612        };
1613      };
1614  
1615      var pasteHtml$1 = function (editor, html, internalFlag) {
1616        var internal = internalFlag ? internalFlag : InternalHtml.isMarked(html);
1617        var args = ProcessFilters.process(editor, InternalHtml.unmark(html), internal);
1618        if (args.cancelled === false) {
1619          SmartPaste.insertContent(editor, args.content);
1620        }
1621      };
1622      var pasteText = function (editor, text) {
1623        text = editor.dom.encode(text).replace(/\r\n/g, '\n');
1624        text = Newlines.convert(text, editor.settings.forced_root_block, editor.settings.forced_root_block_attrs);
1625        pasteHtml$1(editor, text, false);
1626      };
1627      var getDataTransferItems = function (dataTransfer) {
1628        var items = {};
1629        var mceInternalUrlPrefix = 'data:text/mce-internal,';
1630        if (dataTransfer) {
1631          if (dataTransfer.getData) {
1632            var legacyText = dataTransfer.getData('Text');
1633            if (legacyText && legacyText.length > 0) {
1634              if (legacyText.indexOf(mceInternalUrlPrefix) === -1) {
1635                items['text/plain'] = legacyText;
1636              }
1637            }
1638          }
1639          if (dataTransfer.types) {
1640            for (var i = 0; i < dataTransfer.types.length; i++) {
1641              var contentType = dataTransfer.types[i];
1642              try {
1643                items[contentType] = dataTransfer.getData(contentType);
1644              } catch (ex) {
1645                items[contentType] = '';
1646              }
1647            }
1648          }
1649        }
1650        return items;
1651      };
1652      var getClipboardContent = function (editor, clipboardEvent) {
1653        var content = getDataTransferItems(clipboardEvent.clipboardData || editor.getDoc().dataTransfer);
1654        return Utils.isMsEdge() ? global$4.extend(content, { 'text/html': '' }) : content;
1655      };
1656      var hasContentType = function (clipboardContent, mimeType) {
1657        return mimeType in clipboardContent && clipboardContent[mimeType].length > 0;
1658      };
1659      var hasHtmlOrText = function (content) {
1660        return hasContentType(content, 'text/html') || hasContentType(content, 'text/plain');
1661      };
1662      var getBase64FromUri = function (uri) {
1663        var idx;
1664        idx = uri.indexOf(',');
1665        if (idx !== -1) {
1666          return uri.substr(idx + 1);
1667        }
1668        return null;
1669      };
1670      var isValidDataUriImage = function (settings, imgElm) {
1671        return settings.images_dataimg_filter ? settings.images_dataimg_filter(imgElm) : true;
1672      };
1673      var extractFilename = function (editor, str) {
1674        var m = str.match(/([\s\S]+?)\.(?:jpeg|jpg|png|gif)$/i);
1675        return m ? editor.dom.encode(m[1]) : null;
1676      };
1677      var uniqueId = Utils.createIdGenerator('mceclip');
1678      var pasteImage = function (editor, imageItem) {
1679        var base64 = getBase64FromUri(imageItem.uri);
1680        var id = uniqueId();
1681        var name = editor.settings.images_reuse_filename && imageItem.blob.name ? extractFilename(editor, imageItem.blob.name) : id;
1682        var img = new domGlobals.Image();
1683        img.src = imageItem.uri;
1684        if (isValidDataUriImage(editor.settings, img)) {
1685          var blobCache = editor.editorUpload.blobCache;
1686          var blobInfo = void 0, existingBlobInfo = void 0;
1687          existingBlobInfo = blobCache.findFirst(function (cachedBlobInfo) {
1688            return cachedBlobInfo.base64() === base64;
1689          });
1690          if (!existingBlobInfo) {
1691            blobInfo = blobCache.create(id, imageItem.blob, base64, name);
1692            blobCache.add(blobInfo);
1693          } else {
1694            blobInfo = existingBlobInfo;
1695          }
1696          pasteHtml$1(editor, '<img src="' + blobInfo.blobUri() + '">', false);
1697        } else {
1698          pasteHtml$1(editor, '<img src="' + imageItem.uri + '">', false);
1699        }
1700      };
1701      var isClipboardEvent = function (event) {
1702        return event.type === 'paste';
1703      };
1704      var readBlobsAsDataUris = function (items) {
1705        return mapM(items, function (item) {
1706          return Future.nu(function (resolve) {
1707            var blob = item.getAsFile ? item.getAsFile() : item;
1708            var reader = new window.FileReader();
1709            reader.onload = function () {
1710              resolve({
1711                blob: blob,
1712                uri: reader.result
1713              });
1714            };
1715            reader.readAsDataURL(blob);
1716          });
1717        });
1718      };
1719      var getImagesFromDataTransfer = function (dataTransfer) {
1720        var items = dataTransfer.items ? map(from$1(dataTransfer.items), function (item) {
1721          return item.getAsFile();
1722        }) : [];
1723        var files = dataTransfer.files ? from$1(dataTransfer.files) : [];
1724        var images = filter$1(items.length > 0 ? items : files, function (file) {
1725          return /^image\/(jpeg|png|gif|bmp)$/.test(file.type);
1726        });
1727        return images;
1728      };
1729      var pasteImageData = function (editor, e, rng) {
1730        var dataTransfer = isClipboardEvent(e) ? e.clipboardData : e.dataTransfer;
1731        if (editor.settings.paste_data_images && dataTransfer) {
1732          var images = getImagesFromDataTransfer(dataTransfer);
1733          if (images.length > 0) {
1734            e.preventDefault();
1735            readBlobsAsDataUris(images).get(function (blobResults) {
1736              if (rng) {
1737                editor.selection.setRng(rng);
1738              }
1739              each(blobResults, function (result) {
1740                pasteImage(editor, result);
1741              });
1742            });
1743            return true;
1744          }
1745        }
1746        return false;
1747      };
1748      var isBrokenAndroidClipboardEvent = function (e) {
1749        var clipboardData = e.clipboardData;
1750        return domGlobals.navigator.userAgent.indexOf('Android') !== -1 && clipboardData && clipboardData.items && clipboardData.items.length === 0;
1751      };
1752      var isKeyboardPasteEvent = function (e) {
1753        return global$5.metaKeyPressed(e) && e.keyCode === 86 || e.shiftKey && e.keyCode === 45;
1754      };
1755      var registerEventHandlers = function (editor, pasteBin, pasteFormat) {
1756        var keyboardPasteEvent = value();
1757        var keyboardPastePlainTextState;
1758        editor.on('keydown', function (e) {
1759          function removePasteBinOnKeyUp(e) {
1760            if (isKeyboardPasteEvent(e) && !e.isDefaultPrevented()) {
1761              pasteBin.remove();
1762            }
1763          }
1764          if (isKeyboardPasteEvent(e) && !e.isDefaultPrevented()) {
1765            keyboardPastePlainTextState = e.shiftKey && e.keyCode === 86;
1766            if (keyboardPastePlainTextState && global$2.webkit && domGlobals.navigator.userAgent.indexOf('Version/') !== -1) {
1767              return;
1768            }
1769            e.stopImmediatePropagation();
1770            keyboardPasteEvent.set(e);
1771            window.setTimeout(function () {
1772              keyboardPasteEvent.clear();
1773            }, 100);
1774            if (global$2.ie && keyboardPastePlainTextState) {
1775              e.preventDefault();
1776              Events.firePaste(editor, true);
1777              return;
1778            }
1779            pasteBin.remove();
1780            pasteBin.create();
1781            editor.once('keyup', removePasteBinOnKeyUp);
1782            editor.once('paste', function () {
1783              editor.off('keyup', removePasteBinOnKeyUp);
1784            });
1785          }
1786        });
1787        function insertClipboardContent(clipboardContent, isKeyBoardPaste, plainTextMode, internal) {
1788          var content, isPlainTextHtml;
1789          if (hasContentType(clipboardContent, 'text/html')) {
1790            content = clipboardContent['text/html'];
1791          } else {
1792            content = pasteBin.getHtml();
1793            internal = internal ? internal : InternalHtml.isMarked(content);
1794            if (pasteBin.isDefaultContent(content)) {
1795              plainTextMode = true;
1796            }
1797          }
1798          content = Utils.trimHtml(content);
1799          pasteBin.remove();
1800          isPlainTextHtml = internal === false && Newlines.isPlainText(content);
1801          if (!content.length || isPlainTextHtml) {
1802            plainTextMode = true;
1803          }
1804          if (plainTextMode) {
1805            if (hasContentType(clipboardContent, 'text/plain') && isPlainTextHtml) {
1806              content = clipboardContent['text/plain'];
1807            } else {
1808              content = Utils.innerText(content);
1809            }
1810          }
1811          if (pasteBin.isDefaultContent(content)) {
1812            if (!isKeyBoardPaste) {
1813              editor.windowManager.alert('Please use Ctrl+V/Cmd+V keyboard shortcuts to paste contents.');
1814            }
1815            return;
1816          }
1817          if (plainTextMode) {
1818            pasteText(editor, content);
1819          } else {
1820            pasteHtml$1(editor, content, internal);
1821          }
1822        }
1823        var getLastRng = function () {
1824          return pasteBin.getLastRng() || editor.selection.getRng();
1825        };
1826        editor.on('paste', function (e) {
1827          var isKeyBoardPaste = keyboardPasteEvent.isSet();
1828          var clipboardContent = getClipboardContent(editor, e);
1829          var plainTextMode = pasteFormat.get() === 'text' || keyboardPastePlainTextState;
1830          var internal = hasContentType(clipboardContent, InternalHtml.internalHtmlMime());
1831          keyboardPastePlainTextState = false;
1832          if (e.isDefaultPrevented() || isBrokenAndroidClipboardEvent(e)) {
1833            pasteBin.remove();
1834            return;
1835          }
1836          if (!hasHtmlOrText(clipboardContent) && pasteImageData(editor, e, getLastRng())) {
1837            pasteBin.remove();
1838            return;
1839          }
1840          if (!isKeyBoardPaste) {
1841            e.preventDefault();
1842          }
1843          if (global$2.ie && (!isKeyBoardPaste || e.ieFake) && !hasContentType(clipboardContent, 'text/html')) {
1844            pasteBin.create();
1845            editor.dom.bind(pasteBin.getEl(), 'paste', function (e) {
1846              e.stopPropagation();
1847            });
1848            editor.getDoc().execCommand('Paste', false, null);
1849            clipboardContent['text/html'] = pasteBin.getHtml();
1850          }
1851          if (hasContentType(clipboardContent, 'text/html')) {
1852            e.preventDefault();
1853            if (!internal) {
1854              internal = InternalHtml.isMarked(clipboardContent['text/html']);
1855            }
1856            insertClipboardContent(clipboardContent, isKeyBoardPaste, plainTextMode, internal);
1857          } else {
1858            global$3.setEditorTimeout(editor, function () {
1859              insertClipboardContent(clipboardContent, isKeyBoardPaste, plainTextMode, internal);
1860            }, 0);
1861          }
1862        });
1863      };
1864      var registerEventsAndFilters = function (editor, pasteBin, pasteFormat) {
1865        registerEventHandlers(editor, pasteBin, pasteFormat);
1866        var src;
1867        editor.parser.addNodeFilter('img', function (nodes, name, args) {
1868          var isPasteInsert = function (args) {
1869            return args.data && args.data.paste === true;
1870          };
1871          var remove = function (node) {
1872            if (!node.attr('data-mce-object') && src !== global$2.transparentSrc) {
1873              node.remove();
1874            }
1875          };
1876          var isWebKitFakeUrl = function (src) {
1877            return src.indexOf('webkit-fake-url') === 0;
1878          };
1879          var isDataUri = function (src) {
1880            return src.indexOf('data:') === 0;
1881          };
1882          if (!editor.settings.paste_data_images && isPasteInsert(args)) {
1883            var i = nodes.length;
1884            while (i--) {
1885              src = nodes[i].attributes.map.src;
1886              if (!src) {
1887                continue;
1888              }
1889              if (isWebKitFakeUrl(src)) {
1890                remove(nodes[i]);
1891              } else if (!editor.settings.allow_html_data_urls && isDataUri(src)) {
1892                remove(nodes[i]);
1893              }
1894            }
1895          }
1896        });
1897      };
1898  
1899      var getPasteBinParent = function (editor) {
1900        return global$2.ie && editor.inline ? domGlobals.document.body : editor.getBody();
1901      };
1902      var isExternalPasteBin = function (editor) {
1903        return getPasteBinParent(editor) !== editor.getBody();
1904      };
1905      var delegatePasteEvents = function (editor, pasteBinElm, pasteBinDefaultContent) {
1906        if (isExternalPasteBin(editor)) {
1907          editor.dom.bind(pasteBinElm, 'paste keyup', function (e) {
1908            if (!isDefault(editor, pasteBinDefaultContent)) {
1909              editor.fire('paste');
1910            }
1911          });
1912        }
1913      };
1914      var create = function (editor, lastRngCell, pasteBinDefaultContent) {
1915        var dom = editor.dom, body = editor.getBody();
1916        var pasteBinElm;
1917        lastRngCell.set(editor.selection.getRng());
1918        pasteBinElm = editor.dom.add(getPasteBinParent(editor), 'div', {
1919          'id': 'mcepastebin',
1920          'class': 'mce-pastebin',
1921          'contentEditable': true,
1922          'data-mce-bogus': 'all',
1923          'style': 'position: fixed; top: 50%; width: 10px; height: 10px; overflow: hidden; opacity: 0'
1924        }, pasteBinDefaultContent);
1925        if (global$2.ie || global$2.gecko) {
1926          dom.setStyle(pasteBinElm, 'left', dom.getStyle(body, 'direction', true) === 'rtl' ? 65535 : -65535);
1927        }
1928        dom.bind(pasteBinElm, 'beforedeactivate focusin focusout', function (e) {
1929          e.stopPropagation();
1930        });
1931        delegatePasteEvents(editor, pasteBinElm, pasteBinDefaultContent);
1932        pasteBinElm.focus();
1933        editor.selection.select(pasteBinElm, true);
1934      };
1935      var remove = function (editor, lastRngCell) {
1936        if (getEl(editor)) {
1937          var pasteBinClone = void 0;
1938          var lastRng = lastRngCell.get();
1939          while (pasteBinClone = editor.dom.get('mcepastebin')) {
1940            editor.dom.remove(pasteBinClone);
1941            editor.dom.unbind(pasteBinClone);
1942          }
1943          if (lastRng) {
1944            editor.selection.setRng(lastRng);
1945          }
1946        }
1947        lastRngCell.set(null);
1948      };
1949      var getEl = function (editor) {
1950        return editor.dom.get('mcepastebin');
1951      };
1952      var getHtml = function (editor) {
1953        var pasteBinElm, pasteBinClones, i, dirtyWrappers, cleanWrapper;
1954        var copyAndRemove = function (toElm, fromElm) {
1955          toElm.appendChild(fromElm);
1956          editor.dom.remove(fromElm, true);
1957        };
1958        pasteBinClones = global$4.grep(getPasteBinParent(editor).childNodes, function (elm) {
1959          return elm.id === 'mcepastebin';
1960        });
1961        pasteBinElm = pasteBinClones.shift();
1962        global$4.each(pasteBinClones, function (pasteBinClone) {
1963          copyAndRemove(pasteBinElm, pasteBinClone);
1964        });
1965        dirtyWrappers = editor.dom.select('div[id=mcepastebin]', pasteBinElm);
1966        for (i = dirtyWrappers.length - 1; i >= 0; i--) {
1967          cleanWrapper = editor.dom.create('div');
1968          pasteBinElm.insertBefore(cleanWrapper, dirtyWrappers[i]);
1969          copyAndRemove(cleanWrapper, dirtyWrappers[i]);
1970        }
1971        return pasteBinElm ? pasteBinElm.innerHTML : '';
1972      };
1973      var getLastRng = function (lastRng) {
1974        return lastRng.get();
1975      };
1976      var isDefaultContent = function (pasteBinDefaultContent, content) {
1977        return content === pasteBinDefaultContent;
1978      };
1979      var isPasteBin = function (elm) {
1980        return elm && elm.id === 'mcepastebin';
1981      };
1982      var isDefault = function (editor, pasteBinDefaultContent) {
1983        var pasteBinElm = getEl(editor);
1984        return isPasteBin(pasteBinElm) && isDefaultContent(pasteBinDefaultContent, pasteBinElm.innerHTML);
1985      };
1986      var PasteBin = function (editor) {
1987        var lastRng = Cell(null);
1988        var pasteBinDefaultContent = '%MCEPASTEBIN%';
1989        return {
1990          create: function () {
1991            return create(editor, lastRng, pasteBinDefaultContent);
1992          },
1993          remove: function () {
1994            return remove(editor, lastRng);
1995          },
1996          getEl: function () {
1997            return getEl(editor);
1998          },
1999          getHtml: function () {
2000            return getHtml(editor);
2001          },
2002          getLastRng: function () {
2003            return getLastRng(lastRng);
2004          },
2005          isDefault: function () {
2006            return isDefault(editor, pasteBinDefaultContent);
2007          },
2008          isDefaultContent: function (content) {
2009            return isDefaultContent(pasteBinDefaultContent, content);
2010          }
2011        };
2012      };
2013  
2014      var Clipboard = function (editor, pasteFormat) {
2015        var pasteBin = PasteBin(editor);
2016        editor.on('preInit', function () {
2017          return registerEventsAndFilters(editor, pasteBin, pasteFormat);
2018        });
2019        return {
2020          pasteFormat: pasteFormat,
2021          pasteHtml: function (html, internalFlag) {
2022            return pasteHtml$1(editor, html, internalFlag);
2023          },
2024          pasteText: function (text) {
2025            return pasteText(editor, text);
2026          },
2027          pasteImageData: function (e, rng) {
2028            return pasteImageData(editor, e, rng);
2029          },
2030          getDataTransferItems: getDataTransferItems,
2031          hasHtmlOrText: hasHtmlOrText,
2032          hasContentType: hasContentType
2033        };
2034      };
2035  
2036      var noop$1 = function () {
2037      };
2038      var hasWorkingClipboardApi = function (clipboardData) {
2039        return global$2.iOS === false && clipboardData !== undefined && typeof clipboardData.setData === 'function' && Utils.isMsEdge() !== true;
2040      };
2041      var setHtml5Clipboard = function (clipboardData, html, text) {
2042        if (hasWorkingClipboardApi(clipboardData)) {
2043          try {
2044            clipboardData.clearData();
2045            clipboardData.setData('text/html', html);
2046            clipboardData.setData('text/plain', text);
2047            clipboardData.setData(InternalHtml.internalHtmlMime(), html);
2048            return true;
2049          } catch (e) {
2050            return false;
2051          }
2052        } else {
2053          return false;
2054        }
2055      };
2056      var setClipboardData = function (evt, data, fallback, done) {
2057        if (setHtml5Clipboard(evt.clipboardData, data.html, data.text)) {
2058          evt.preventDefault();
2059          done();
2060        } else {
2061          fallback(data.html, done);
2062        }
2063      };
2064      var fallback = function (editor) {
2065        return function (html, done) {
2066          var markedHtml = InternalHtml.mark(html);
2067          var outer = editor.dom.create('div', {
2068            'contenteditable': 'false',
2069            'data-mce-bogus': 'all'
2070          });
2071          var inner = editor.dom.create('div', { contenteditable: 'true' }, markedHtml);
2072          editor.dom.setStyles(outer, {
2073            position: 'fixed',
2074            top: '0',
2075            left: '-3000px',
2076            width: '1000px',
2077            overflow: 'hidden'
2078          });
2079          outer.appendChild(inner);
2080          editor.dom.add(editor.getBody(), outer);
2081          var range = editor.selection.getRng();
2082          inner.focus();
2083          var offscreenRange = editor.dom.createRng();
2084          offscreenRange.selectNodeContents(inner);
2085          editor.selection.setRng(offscreenRange);
2086          setTimeout(function () {
2087            editor.selection.setRng(range);
2088            outer.parentNode.removeChild(outer);
2089            done();
2090          }, 0);
2091        };
2092      };
2093      var getData = function (editor) {
2094        return {
2095          html: editor.selection.getContent({ contextual: true }),
2096          text: editor.selection.getContent({ format: 'text' })
2097        };
2098      };
2099      var isTableSelection = function (editor) {
2100        return !!editor.dom.getParent(editor.selection.getStart(), 'td[data-mce-selected],th[data-mce-selected]', editor.getBody());
2101      };
2102      var hasSelectedContent = function (editor) {
2103        return !editor.selection.isCollapsed() || isTableSelection(editor);
2104      };
2105      var cut = function (editor) {
2106        return function (evt) {
2107          if (hasSelectedContent(editor)) {
2108            setClipboardData(evt, getData(editor), fallback(editor), function () {
2109              setTimeout(function () {
2110                editor.execCommand('Delete');
2111              }, 0);
2112            });
2113          }
2114        };
2115      };
2116      var copy = function (editor) {
2117        return function (evt) {
2118          if (hasSelectedContent(editor)) {
2119            setClipboardData(evt, getData(editor), fallback(editor), noop$1);
2120          }
2121        };
2122      };
2123      var register$1 = function (editor) {
2124        editor.on('cut', cut(editor));
2125        editor.on('copy', copy(editor));
2126      };
2127      var CutCopy = { register: register$1 };
2128  
2129      var global$b = tinymce.util.Tools.resolve('tinymce.dom.RangeUtils');
2130  
2131      var getCaretRangeFromEvent = function (editor, e) {
2132        return global$b.getCaretRangeFromPoint(e.clientX, e.clientY, editor.getDoc());
2133      };
2134      var isPlainTextFileUrl = function (content) {
2135        var plainTextContent = content['text/plain'];
2136        return plainTextContent ? plainTextContent.indexOf('file://') === 0 : false;
2137      };
2138      var setFocusedRange = function (editor, rng) {
2139        editor.focus();
2140        editor.selection.setRng(rng);
2141      };
2142      var setup = function (editor, clipboard, draggingInternallyState) {
2143        if (Settings.shouldBlockDrop(editor)) {
2144          editor.on('dragend dragover draggesture dragdrop drop drag', function (e) {
2145            e.preventDefault();
2146            e.stopPropagation();
2147          });
2148        }
2149        if (!Settings.shouldPasteDataImages(editor)) {
2150          editor.on('drop', function (e) {
2151            var dataTransfer = e.dataTransfer;
2152            if (dataTransfer && dataTransfer.files && dataTransfer.files.length > 0) {
2153              e.preventDefault();
2154            }
2155          });
2156        }
2157        editor.on('drop', function (e) {
2158          var dropContent, rng;
2159          rng = getCaretRangeFromEvent(editor, e);
2160          if (e.isDefaultPrevented() || draggingInternallyState.get()) {
2161            return;
2162          }
2163          dropContent = clipboard.getDataTransferItems(e.dataTransfer);
2164          var internal = clipboard.hasContentType(dropContent, InternalHtml.internalHtmlMime());
2165          if ((!clipboard.hasHtmlOrText(dropContent) || isPlainTextFileUrl(dropContent)) && clipboard.pasteImageData(e, rng)) {
2166            return;
2167          }
2168          if (rng && Settings.shouldFilterDrop(editor)) {
2169            var content_1 = dropContent['mce-internal'] || dropContent['text/html'] || dropContent['text/plain'];
2170            if (content_1) {
2171              e.preventDefault();
2172              global$3.setEditorTimeout(editor, function () {
2173                editor.undoManager.transact(function () {
2174                  if (dropContent['mce-internal']) {
2175                    editor.execCommand('Delete');
2176                  }
2177                  setFocusedRange(editor, rng);
2178                  content_1 = Utils.trimHtml(content_1);
2179                  if (!dropContent['text/html']) {
2180                    clipboard.pasteText(content_1);
2181                  } else {
2182                    clipboard.pasteHtml(content_1, internal);
2183                  }
2184                });
2185              });
2186            }
2187          }
2188        });
2189        editor.on('dragstart', function (e) {
2190          draggingInternallyState.set(true);
2191        });
2192        editor.on('dragover dragend', function (e) {
2193          if (Settings.shouldPasteDataImages(editor) && draggingInternallyState.get() === false) {
2194            e.preventDefault();
2195            setFocusedRange(editor, getCaretRangeFromEvent(editor, e));
2196          }
2197          if (e.type === 'dragend') {
2198            draggingInternallyState.set(false);
2199          }
2200        });
2201      };
2202      var DragDrop = { setup: setup };
2203  
2204      var setup$1 = function (editor) {
2205        var plugin = editor.plugins.paste;
2206        var preProcess = Settings.getPreProcess(editor);
2207        if (preProcess) {
2208          editor.on('PastePreProcess', function (e) {
2209            preProcess.call(plugin, plugin, e);
2210          });
2211        }
2212        var postProcess = Settings.getPostProcess(editor);
2213        if (postProcess) {
2214          editor.on('PastePostProcess', function (e) {
2215            postProcess.call(plugin, plugin, e);
2216          });
2217        }
2218      };
2219      var PrePostProcess = { setup: setup$1 };
2220  
2221      function addPreProcessFilter(editor, filterFunc) {
2222        editor.on('PastePreProcess', function (e) {
2223          e.content = filterFunc(editor, e.content, e.internal, e.wordContent);
2224        });
2225      }
2226      function addPostProcessFilter(editor, filterFunc) {
2227        editor.on('PastePostProcess', function (e) {
2228          filterFunc(editor, e.node);
2229        });
2230      }
2231      function removeExplorerBrElementsAfterBlocks(editor, html) {
2232        if (!WordFilter.isWordContent(html)) {
2233          return html;
2234        }
2235        var blockElements = [];
2236        global$4.each(editor.schema.getBlockElements(), function (block, blockName) {
2237          blockElements.push(blockName);
2238        });
2239        var explorerBlocksRegExp = new RegExp('(?:<br>&nbsp;[\\s\\r\\n]+|<br>)*(<\\/?(' + blockElements.join('|') + ')[^>]*>)(?:<br>&nbsp;[\\s\\r\\n]+|<br>)*', 'g');
2240        html = Utils.filter(html, [[
2241            explorerBlocksRegExp,
2242            '$1'
2243          ]]);
2244        html = Utils.filter(html, [
2245          [
2246            /<br><br>/g,
2247            '<BR><BR>'
2248          ],
2249          [
2250            /<br>/g,
2251            ' '
2252          ],
2253          [
2254            /<BR><BR>/g,
2255            '<br>'
2256          ]
2257        ]);
2258        return html;
2259      }
2260      function removeWebKitStyles(editor, content, internal, isWordHtml) {
2261        if (isWordHtml || internal) {
2262          return content;
2263        }
2264        var webKitStylesSetting = Settings.getWebkitStyles(editor);
2265        var webKitStyles;
2266        if (Settings.shouldRemoveWebKitStyles(editor) === false || webKitStylesSetting === 'all') {
2267          return content;
2268        }
2269        if (webKitStylesSetting) {
2270          webKitStyles = webKitStylesSetting.split(/[, ]/);
2271        }
2272        if (webKitStyles) {
2273          var dom_1 = editor.dom, node_1 = editor.selection.getNode();
2274          content = content.replace(/(<[^>]+) style="([^"]*)"([^>]*>)/gi, function (all, before, value, after) {
2275            var inputStyles = dom_1.parseStyle(dom_1.decode(value));
2276            var outputStyles = {};
2277            if (webKitStyles === 'none') {
2278              return before + after;
2279            }
2280            for (var i = 0; i < webKitStyles.length; i++) {
2281              var inputValue = inputStyles[webKitStyles[i]], currentValue = dom_1.getStyle(node_1, webKitStyles[i], true);
2282              if (/color/.test(webKitStyles[i])) {
2283                inputValue = dom_1.toHex(inputValue);
2284                currentValue = dom_1.toHex(currentValue);
2285              }
2286              if (currentValue !== inputValue) {
2287                outputStyles[webKitStyles[i]] = inputValue;
2288              }
2289            }
2290            outputStyles = dom_1.serializeStyle(outputStyles, 'span');
2291            if (outputStyles) {
2292              return before + ' style="' + outputStyles + '"' + after;
2293            }
2294            return before + after;
2295          });
2296        } else {
2297          content = content.replace(/(<[^>]+) style="([^"]*)"([^>]*>)/gi, '$1$3');
2298        }
2299        content = content.replace(/(<[^>]+) data-mce-style="([^"]+)"([^>]*>)/gi, function (all, before, value, after) {
2300          return before + ' style="' + value + '"' + after;
2301        });
2302        return content;
2303      }
2304      function removeUnderlineAndFontInAnchor(editor, root) {
2305        editor.$('a', root).find('font,u').each(function (i, node) {
2306          editor.dom.remove(node, true);
2307        });
2308      }
2309      var setup$2 = function (editor) {
2310        if (global$2.webkit) {
2311          addPreProcessFilter(editor, removeWebKitStyles);
2312        }
2313        if (global$2.ie) {
2314          addPreProcessFilter(editor, removeExplorerBrElementsAfterBlocks);
2315          addPostProcessFilter(editor, removeUnderlineAndFontInAnchor);
2316        }
2317      };
2318      var Quirks = { setup: setup$2 };
2319  
2320      var stateChange = function (editor, clipboard, e) {
2321        var ctrl = e.control;
2322        ctrl.active(clipboard.pasteFormat.get() === 'text');
2323        editor.on('PastePlainTextToggle', function (e) {
2324          ctrl.active(e.state);
2325        });
2326      };
2327      var register$2 = function (editor, clipboard) {
2328        var postRender = curry(stateChange, editor, clipboard);
2329        editor.addButton('pastetext', {
2330          active: false,
2331          icon: 'pastetext',
2332          tooltip: 'Paste as text',
2333          cmd: 'mceTogglePlainTextPaste',
2334          onPostRender: postRender
2335        });
2336        editor.addMenuItem('pastetext', {
2337          text: 'Paste as text',
2338          selectable: true,
2339          active: clipboard.pasteFormat,
2340          cmd: 'mceTogglePlainTextPaste',
2341          onPostRender: postRender
2342        });
2343      };
2344      var Buttons = { register: register$2 };
2345  
2346      global$1.add('paste', function (editor) {
2347        if (DetectProPlugin.hasProPlugin(editor) === false) {
2348          var userIsInformedState = Cell(false);
2349          var draggingInternallyState = Cell(false);
2350          var pasteFormat = Cell(Settings.isPasteAsTextEnabled(editor) ? 'text' : 'html');
2351          var clipboard = Clipboard(editor, pasteFormat);
2352          var quirks = Quirks.setup(editor);
2353          Buttons.register(editor, clipboard);
2354          Commands.register(editor, clipboard, userIsInformedState);
2355          PrePostProcess.setup(editor);
2356          CutCopy.register(editor);
2357          DragDrop.setup(editor, clipboard, draggingInternallyState);
2358          return Api.get(clipboard, quirks);
2359        }
2360      });
2361      function Plugin () {
2362      }
2363  
2364      return Plugin;
2365  
2366  }(window));
2367  })();


Generated: Thu Jul 2 01:00:04 2020 Cross-referenced by PHPXref 0.7.1