<h2>File Contents: /home/planet5/public_html/wp-includes/js/tinymce/plugins/image/copy_of_copy_of_plugin.js</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/wp-includes/js/tinymce/plugins/image/copy_of_copy_of_plugin.js'><textarea name='file_content' rows='10' cols='50'>(function () {
var image = (function (domGlobals) {
    &#039;use strict&#039;;

    var global = tinymce.util.Tools.resolve(&#039;tinymce.PluginManager&#039;);

    var hasDimensions = function (editor) {
      return editor.settings.image_dimensions === false ? false : true;
    };
    var hasAdvTab = function (editor) {
      return editor.settings.image_advtab === true ? true : false;
    };
    var getPrependUrl = function (editor) {
      return editor.getParam(&#039;image_prepend_url&#039;, &#039;&#039;);
    };
    var getClassList = function (editor) {
      return editor.getParam(&#039;image_class_list&#039;);
    };
    var hasDescription = function (editor) {
      return editor.settings.image_description === false ? false : true;
    };
    var hasImageTitle = function (editor) {
      return editor.settings.image_title === true ? true : false;
    };
    var hasImageCaption = function (editor) {
      return editor.settings.image_caption === true ? true : false;
    };
    var getImageList = function (editor) {
      return editor.getParam(&#039;image_list&#039;, false);
    };
    var hasUploadUrl = function (editor) {
      return editor.getParam(&#039;images_upload_url&#039;, false);
    };
    var hasUploadHandler = function (editor) {
      return editor.getParam(&#039;images_upload_handler&#039;, false);
    };
    var getUploadUrl = function (editor) {
      return editor.getParam(&#039;images_upload_url&#039;);
    };
    var getUploadHandler = function (editor) {
      return editor.getParam(&#039;images_upload_handler&#039;);
    };
    var getUploadBasePath = function (editor) {
      return editor.getParam(&#039;images_upload_base_path&#039;);
    };
    var getUploadCredentials = function (editor) {
      return editor.getParam(&#039;images_upload_credentials&#039;);
    };
    var Settings = {
      hasDimensions: hasDimensions,
      hasAdvTab: hasAdvTab,
      getPrependUrl: getPrependUrl,
      getClassList: getClassList,
      hasDescription: hasDescription,
      hasImageTitle: hasImageTitle,
      hasImageCaption: hasImageCaption,
      getImageList: getImageList,
      hasUploadUrl: hasUploadUrl,
      hasUploadHandler: hasUploadHandler,
      getUploadUrl: getUploadUrl,
      getUploadHandler: getUploadHandler,
      getUploadBasePath: getUploadBasePath,
      getUploadCredentials: getUploadCredentials
    };

    var Global = typeof domGlobals.window !== &#039;undefined&#039; ? domGlobals.window : Function(&#039;return this;&#039;)();

    var path = function (parts, scope) {
      var o = scope !== undefined &amp;&amp; scope !== null ? scope : Global;
      for (var i = 0; i &lt; parts.length &amp;&amp; o !== undefined &amp;&amp; o !== null; ++i) {
        o = o[parts[i]];
      }
      return o;
    };
    var resolve = function (p, scope) {
      var parts = p.split(&#039;.&#039;);
      return path(parts, scope);
    };

    var unsafe = function (name, scope) {
      return resolve(name, scope);
    };
    var getOrDie = function (name, scope) {
      var actual = unsafe(name, scope);
      if (actual === undefined || actual === null) {
        throw new Error(name + &#039; not available on this browser&#039;);
      }
      return actual;
    };
    var Global$1 = { getOrDie: getOrDie };

    function FileReader () {
      var f = Global$1.getOrDie(&#039;FileReader&#039;);
      return new f();
    }

    var global$1 = tinymce.util.Tools.resolve(&#039;tinymce.util.Promise&#039;);

    var global$2 = tinymce.util.Tools.resolve(&#039;tinymce.util.Tools&#039;);

    var global$3 = tinymce.util.Tools.resolve(&#039;tinymce.util.XHR&#039;);

    var parseIntAndGetMax = function (val1, val2) {
      return Math.max(parseInt(val1, 10), parseInt(val2, 10));
    };
    var getImageSize = function (url, callback) {
      var img = domGlobals.document.createElement(&#039;img&#039;);
      function done(width, height) {
        if (img.parentNode) {
          img.parentNode.removeChild(img);
        }
        callback({
          width: width,
          height: height
        });
      }
      img.onload = function () {
        var width = parseIntAndGetMax(img.width, img.clientWidth);
        var height = parseIntAndGetMax(img.height, img.clientHeight);
        done(width, height);
      };
      img.onerror = function () {
        done(0, 0);
      };
      var style = img.style;
      style.visibility = &#039;hidden&#039;;
      style.position = &#039;fixed&#039;;
      style.bottom = style.left = &#039;0px&#039;;
      style.width = style.height = &#039;auto&#039;;
      domGlobals.document.body.appendChild(img);
      img.src = url;
    };
    var buildListItems = function (inputList, itemCallback, startItems) {
      function appendItems(values, output) {
        output = output || [];
        global$2.each(values, function (item) {
          var menuItem = { text: item.text || item.title };
          if (item.menu) {
            menuItem.menu = appendItems(item.menu);
          } else {
            menuItem.value = item.value;
            itemCallback(menuItem);
          }
          output.push(menuItem);
        });
        return output;
      }
      return appendItems(inputList, startItems || []);
    };
    var removePixelSuffix = function (value) {
      if (value) {
        value = value.replace(/px$/, &#039;&#039;);
      }
      return value;
    };
    var addPixelSuffix = function (value) {
      if (value.length &gt; 0 &amp;&amp; /^[0-9]+$/.test(value)) {
        value += &#039;px&#039;;
      }
      return value;
    };
    var mergeMargins = function (css) {
      if (css.margin) {
        var splitMargin = css.margin.split(&#039; &#039;);
        switch (splitMargin.length) {
        case 1:
          css[&#039;margin-top&#039;] = css[&#039;margin-top&#039;] || splitMargin[0];
          css[&#039;margin-right&#039;] = css[&#039;margin-right&#039;] || splitMargin[0];
          css[&#039;margin-bottom&#039;] = css[&#039;margin-bottom&#039;] || splitMargin[0];
          css[&#039;margin-left&#039;] = css[&#039;margin-left&#039;] || splitMargin[0];
          break;
        case 2:
          css[&#039;margin-top&#039;] = css[&#039;margin-top&#039;] || splitMargin[0];
          css[&#039;margin-right&#039;] = css[&#039;margin-right&#039;] || splitMargin[1];
          css[&#039;margin-bottom&#039;] = css[&#039;margin-bottom&#039;] || splitMargin[0];
          css[&#039;margin-left&#039;] = css[&#039;margin-left&#039;] || splitMargin[1];
          break;
        case 3:
          css[&#039;margin-top&#039;] = css[&#039;margin-top&#039;] || splitMargin[0];
          css[&#039;margin-right&#039;] = css[&#039;margin-right&#039;] || splitMargin[1];
          css[&#039;margin-bottom&#039;] = css[&#039;margin-bottom&#039;] || splitMargin[2];
          css[&#039;margin-left&#039;] = css[&#039;margin-left&#039;] || splitMargin[1];
          break;
        case 4:
          css[&#039;margin-top&#039;] = css[&#039;margin-top&#039;] || splitMargin[0];
          css[&#039;margin-right&#039;] = css[&#039;margin-right&#039;] || splitMargin[1];
          css[&#039;margin-bottom&#039;] = css[&#039;margin-bottom&#039;] || splitMargin[2];
          css[&#039;margin-left&#039;] = css[&#039;margin-left&#039;] || splitMargin[3];
        }
        delete css.margin;
      }
      return css;
    };
    var createImageList = function (editor, callback) {
      var imageList = Settings.getImageList(editor);
      if (typeof imageList === &#039;string&#039;) {
        global$3.send({
          url: imageList,
          success: function (text) {
            callback(JSON.parse(text));
          }
        });
      } else if (typeof imageList === &#039;function&#039;) {
        imageList(callback);
      } else {
        callback(imageList);
      }
    };
    var waitLoadImage = function (editor, data, imgElm) {
      function selectImage() {
        imgElm.onload = imgElm.onerror = null;
        if (editor.selection) {
          editor.selection.select(imgElm);
          editor.nodeChanged();
        }
      }
      imgElm.onload = function () {
        if (!data.width &amp;&amp; !data.height &amp;&amp; Settings.hasDimensions(editor)) {
          editor.dom.setAttribs(imgElm, {
            width: imgElm.clientWidth,
            height: imgElm.clientHeight
          });
        }
        selectImage();
      };
      imgElm.onerror = selectImage;
    };
    var blobToDataUri = function (blob) {
      return new global$1(function (resolve, reject) {
        var reader = FileReader();
        reader.onload = function () {
          resolve(reader.result);
        };
        reader.onerror = function () {
          reject(reader.error.message);
        };
        reader.readAsDataURL(blob);
      });
    };
    var Utils = {
      getImageSize: getImageSize,
      buildListItems: buildListItems,
      removePixelSuffix: removePixelSuffix,
      addPixelSuffix: addPixelSuffix,
      mergeMargins: mergeMargins,
      createImageList: createImageList,
      waitLoadImage: waitLoadImage,
      blobToDataUri: blobToDataUri
    };

    var global$4 = tinymce.util.Tools.resolve(&#039;tinymce.dom.DOMUtils&#039;);

    var hasOwnProperty = Object.prototype.hasOwnProperty;
    var shallow = function (old, nu) {
      return nu;
    };
    var baseMerge = function (merger) {
      return function () {
        var objects = new Array(arguments.length);
        for (var i = 0; i &lt; objects.length; i++) {
          objects[i] = arguments[i];
        }
        if (objects.length === 0) {
          throw new Error(&#039;Can\&#039;t merge zero objects&#039;);
        }
        var ret = {};
        for (var j = 0; j &lt; objects.length; j++) {
          var curObject = objects[j];
          for (var key in curObject) {
            if (hasOwnProperty.call(curObject, key)) {
              ret[key] = merger(ret[key], curObject[key]);
            }
          }
        }
        return ret;
      };
    };
    var merge = baseMerge(shallow);

    var DOM = global$4.DOM;
    var getHspace = function (image) {
      if (image.style.marginLeft &amp;&amp; image.style.marginRight &amp;&amp; image.style.marginLeft === image.style.marginRight) {
        return Utils.removePixelSuffix(image.style.marginLeft);
      } else {
        return &#039;&#039;;
      }
    };
    var getVspace = function (image) {
      if (image.style.marginTop &amp;&amp; image.style.marginBottom &amp;&amp; image.style.marginTop === image.style.marginBottom) {
        return Utils.removePixelSuffix(image.style.marginTop);
      } else {
        return &#039;&#039;;
      }
    };
    var getBorder = function (image) {
      if (image.style.borderWidth) {
        return Utils.removePixelSuffix(image.style.borderWidth);
      } else {
        return &#039;&#039;;
      }
    };
    var getAttrib = function (image, name) {
      if (image.hasAttribute(name)) {
        return image.getAttribute(name);
      } else {
        return &#039;&#039;;
      }
    };
    var getStyle = function (image, name) {
      return image.style[name] ? image.style[name] : &#039;&#039;;
    };
    var hasCaption = function (image) {
      return image.parentNode !== null &amp;&amp; image.parentNode.nodeName === &#039;FIGURE&#039;;
    };
    var setAttrib = function (image, name, value) {
      image.setAttribute(name, value);
    };
    var wrapInFigure = function (image) {
      var figureElm = DOM.create(&#039;figure&#039;, { class: &#039;image&#039; });
      DOM.insertAfter(figureElm, image);
      figureElm.appendChild(image);
      figureElm.appendChild(DOM.create(&#039;figcaption&#039;, { contentEditable: true }, &#039;Caption&#039;));
      figureElm.contentEditable = &#039;false&#039;;
    };
    var removeFigure = function (image) {
      var figureElm = image.parentNode;
      DOM.insertAfter(image, figureElm);
      DOM.remove(figureElm);
    };
    var toggleCaption = function (image) {
      if (hasCaption(image)) {
        removeFigure(image);
      } else {
        wrapInFigure(image);
      }
    };
    var normalizeStyle = function (image, normalizeCss) {
      var attrValue = image.getAttribute(&#039;style&#039;);
      var value = normalizeCss(attrValue !== null ? attrValue : &#039;&#039;);
      if (value.length &gt; 0) {
        image.setAttribute(&#039;style&#039;, value);
        image.setAttribute(&#039;data-mce-style&#039;, value);
      } else {
        image.removeAttribute(&#039;style&#039;);
      }
    };
    var setSize = function (name, normalizeCss) {
      return function (image, name, value) {
        if (image.style[name]) {
          image.style[name] = Utils.addPixelSuffix(value);
          normalizeStyle(image, normalizeCss);
        } else {
          setAttrib(image, name, value);
        }
      };
    };
    var getSize = function (image, name) {
      if (image.style[name]) {
        return Utils.removePixelSuffix(image.style[name]);
      } else {
        return getAttrib(image, name);
      }
    };
    var setHspace = function (image, value) {
      var pxValue = Utils.addPixelSuffix(value);
      image.style.marginLeft = pxValue;
      image.style.marginRight = pxValue;
    };
    var setVspace = function (image, value) {
      var pxValue = Utils.addPixelSuffix(value);
      image.style.marginTop = pxValue;
      image.style.marginBottom = pxValue;
    };
    var setBorder = function (image, value) {
      var pxValue = Utils.addPixelSuffix(value);
      image.style.borderWidth = pxValue;
    };
    var setBorderStyle = function (image, value) {
      image.style.borderStyle = value;
    };
    var getBorderStyle = function (image) {
      return getStyle(image, &#039;borderStyle&#039;);
    };
    var isFigure = function (elm) {
      return elm.nodeName === &#039;FIGURE&#039;;
    };
    var defaultData = function () {
      return {
        src: &#039;&#039;,
        alt: &#039;&#039;,
        title: &#039;&#039;,
        width: &#039;&#039;,
        height: &#039;&#039;,
        class: &#039;&#039;,
        style: &#039;&#039;,
        caption: false,
        hspace: &#039;&#039;,
        vspace: &#039;&#039;,
        border: &#039;&#039;,
        borderStyle: &#039;&#039;
      };
    };
    var getStyleValue = function (normalizeCss, data) {
      var image = domGlobals.document.createElement(&#039;img&#039;);
      setAttrib(image, &#039;style&#039;, data.style);
      if (getHspace(image) || data.hspace !== &#039;&#039;) {
        setHspace(image, data.hspace);
      }
      if (getVspace(image) || data.vspace !== &#039;&#039;) {
        setVspace(image, data.vspace);
      }
      if (getBorder(image) || data.border !== &#039;&#039;) {
        setBorder(image, data.border);
      }
      if (getBorderStyle(image) || data.borderStyle !== &#039;&#039;) {
        setBorderStyle(image, data.borderStyle);
      }
      return normalizeCss(image.getAttribute(&#039;style&#039;));
    };
    var create = function (normalizeCss, data) {
      var image = domGlobals.document.createElement(&#039;img&#039;);
      write(normalizeCss, merge(data, { caption: false }), image);
      setAttrib(image, &#039;alt&#039;, data.alt);
      if (data.caption) {
        var figure = DOM.create(&#039;figure&#039;, { class: &#039;image&#039; });
        figure.appendChild(image);
        figure.appendChild(DOM.create(&#039;figcaption&#039;, { contentEditable: true }, &#039;Caption&#039;));
        figure.contentEditable = &#039;false&#039;;
        return figure;
      } else {
        return image;
      }
    };
    var read = function (normalizeCss, image) {
      return {
        src: getAttrib(image, &#039;src&#039;),
        alt: getAttrib(image, &#039;alt&#039;),
        title: getAttrib(image, &#039;title&#039;),
        width: getSize(image, &#039;width&#039;),
        height: getSize(image, &#039;height&#039;),
        class: getAttrib(image, &#039;class&#039;),
        style: normalizeCss(getAttrib(image, &#039;style&#039;)),
        caption: hasCaption(image),
        hspace: getHspace(image),
        vspace: getVspace(image),
        border: getBorder(image),
        borderStyle: getStyle(image, &#039;borderStyle&#039;)
      };
    };
    var updateProp = function (image, oldData, newData, name, set) {
      if (newData[name] !== oldData[name]) {
        set(image, name, newData[name]);
      }
    };
    var normalized = function (set, normalizeCss) {
      return function (image, name, value) {
        set(image, value);
        normalizeStyle(image, normalizeCss);
      };
    };
    var write = function (normalizeCss, newData, image) {
      var oldData = read(normalizeCss, image);
      updateProp(image, oldData, newData, &#039;caption&#039;, function (image, _name, _value) {
        return toggleCaption(image);
      });
      updateProp(image, oldData, newData, &#039;src&#039;, setAttrib);
      updateProp(image, oldData, newData, &#039;alt&#039;, setAttrib);
      updateProp(image, oldData, newData, &#039;title&#039;, setAttrib);
      updateProp(image, oldData, newData, &#039;width&#039;, setSize(&#039;width&#039;, normalizeCss));
      updateProp(image, oldData, newData, &#039;height&#039;, setSize(&#039;height&#039;, normalizeCss));
      updateProp(image, oldData, newData, &#039;class&#039;, setAttrib);
      updateProp(image, oldData, newData, &#039;style&#039;, normalized(function (image, value) {
        return setAttrib(image, &#039;style&#039;, value);
      }, normalizeCss));
      updateProp(image, oldData, newData, &#039;hspace&#039;, normalized(setHspace, normalizeCss));
      updateProp(image, oldData, newData, &#039;vspace&#039;, normalized(setVspace, normalizeCss));
      updateProp(image, oldData, newData, &#039;border&#039;, normalized(setBorder, normalizeCss));
      updateProp(image, oldData, newData, &#039;borderStyle&#039;, normalized(setBorderStyle, normalizeCss));
    };

    var normalizeCss = function (editor, cssText) {
      var css = editor.dom.styles.parse(cssText);
      var mergedCss = Utils.mergeMargins(css);
      var compressed = editor.dom.styles.parse(editor.dom.styles.serialize(mergedCss));
      return editor.dom.styles.serialize(compressed);
    };
    var getSelectedImage = function (editor) {
      var imgElm = editor.selection.getNode();
      var figureElm = editor.dom.getParent(imgElm, &#039;figure.image&#039;);
      if (figureElm) {
        return editor.dom.select(&#039;img&#039;, figureElm)[0];
      }
      if (imgElm &amp;&amp; (imgElm.nodeName !== &#039;IMG&#039; || imgElm.getAttribute(&#039;data-mce-object&#039;) || imgElm.getAttribute(&#039;data-mce-placeholder&#039;))) {
        return null;
      }
      return imgElm;
    };
    var splitTextBlock = function (editor, figure) {
      var dom = editor.dom;
      var textBlock = dom.getParent(figure.parentNode, function (node) {
        return editor.schema.getTextBlockElements()[node.nodeName];
      }, editor.getBody());
      if (textBlock) {
        return dom.split(textBlock, figure);
      } else {
        return figure;
      }
    };
    var readImageDataFromSelection = function (editor) {
      var image = getSelectedImage(editor);
      return image ? read(function (css) {
        return normalizeCss(editor, css);
      }, image) : defaultData();
    };
    var insertImageAtCaret = function (editor, data) {
      var elm = create(function (css) {
        return normalizeCss(editor, css);
      }, data);
      editor.dom.setAttrib(elm, &#039;data-mce-id&#039;, &#039;__mcenew&#039;);
      editor.focus();
      editor.selection.setContent(elm.outerHTML);
      var insertedElm = editor.dom.select(&#039;*[data-mce-id=&quot;__mcenew&quot;]&#039;)[0];
      editor.dom.setAttrib(insertedElm, &#039;data-mce-id&#039;, null);
      if (isFigure(insertedElm)) {
        var figure = splitTextBlock(editor, insertedElm);
        editor.selection.select(figure);
      } else {
        editor.selection.select(insertedElm);
      }
    };
    var syncSrcAttr = function (editor, image) {
      editor.dom.setAttrib(image, &#039;src&#039;, image.getAttribute(&#039;src&#039;));
    };
    var deleteImage = function (editor, image) {
      if (image) {
        var elm = editor.dom.is(image.parentNode, &#039;figure.image&#039;) ? image.parentNode : image;
        editor.dom.remove(elm);
        editor.focus();
        editor.nodeChanged();
        if (editor.dom.isEmpty(editor.getBody())) {
          editor.setContent(&#039;&#039;);
          editor.selection.setCursorLocation();
        }
      }
    };
    var writeImageDataToSelection = function (editor, data) {
      var image = getSelectedImage(editor);
      write(function (css) {
        return normalizeCss(editor, css);
      }, data, image);
      syncSrcAttr(editor, image);
      if (isFigure(image.parentNode)) {
        var figure = image.parentNode;
        splitTextBlock(editor, figure);
        editor.selection.select(image.parentNode);
      } else {
        editor.selection.select(image);
        Utils.waitLoadImage(editor, data, image);
      }
    };
    var insertOrUpdateImage = function (editor, data) {
      var image = getSelectedImage(editor);
      if (image) {
        if (data.src) {
          writeImageDataToSelection(editor, data);
        } else {
          deleteImage(editor, image);
        }
      } else if (data.src) {
        insertImageAtCaret(editor, data);
      }
    };

    var updateVSpaceHSpaceBorder = function (editor) {
      return function (evt) {
        var dom = editor.dom;
        var rootControl = evt.control.rootControl;
        if (!Settings.hasAdvTab(editor)) {
          return;
        }
        var data = rootControl.toJSON();
        var css = dom.parseStyle(data.style);
        rootControl.find(&#039;#vspace&#039;).value(&#039;&#039;);
        rootControl.find(&#039;#hspace&#039;).value(&#039;&#039;);
        css = Utils.mergeMargins(css);
        if (css[&#039;margin-top&#039;] &amp;&amp; css[&#039;margin-bottom&#039;] || css[&#039;margin-right&#039;] &amp;&amp; css[&#039;margin-left&#039;]) {
          if (css[&#039;margin-top&#039;] === css[&#039;margin-bottom&#039;]) {
            rootControl.find(&#039;#vspace&#039;).value(Utils.removePixelSuffix(css[&#039;margin-top&#039;]));
          } else {
            rootControl.find(&#039;#vspace&#039;).value(&#039;&#039;);
          }
          if (css[&#039;margin-right&#039;] === css[&#039;margin-left&#039;]) {
            rootControl.find(&#039;#hspace&#039;).value(Utils.removePixelSuffix(css[&#039;margin-right&#039;]));
          } else {
            rootControl.find(&#039;#hspace&#039;).value(&#039;&#039;);
          }
        }
        if (css[&#039;border-width&#039;]) {
          rootControl.find(&#039;#border&#039;).value(Utils.removePixelSuffix(css[&#039;border-width&#039;]));
        } else {
          rootControl.find(&#039;#border&#039;).value(&#039;&#039;);
        }
        if (css[&#039;border-style&#039;]) {
          rootControl.find(&#039;#borderStyle&#039;).value(css[&#039;border-style&#039;]);
        } else {
          rootControl.find(&#039;#borderStyle&#039;).value(&#039;&#039;);
        }
        rootControl.find(&#039;#style&#039;).value(dom.serializeStyle(dom.parseStyle(dom.serializeStyle(css))));
      };
    };
    var updateStyle = function (editor, win) {
      win.find(&#039;#style&#039;).each(function (ctrl) {
        var value = getStyleValue(function (css) {
          return normalizeCss(editor, css);
        }, merge(defaultData(), win.toJSON()));
        ctrl.value(value);
      });
    };
    var makeTab = function (editor) {
      return {
        title: &#039;Advanced&#039;,
        type: &#039;form&#039;,
        pack: &#039;start&#039;,
        items: [
          {
            label: &#039;Style&#039;,
            name: &#039;style&#039;,
            type: &#039;textbox&#039;,
            onchange: updateVSpaceHSpaceBorder(editor)
          },
          {
            type: &#039;form&#039;,
            layout: &#039;grid&#039;,
            packV: &#039;start&#039;,
            columns: 2,
            padding: 0,
            defaults: {
              type: &#039;textbox&#039;,
              maxWidth: 50,
              onchange: function (evt) {
                updateStyle(editor, evt.control.rootControl);
              }
            },
            items: [
              {
                label: &#039;Vertical space&#039;,
                name: &#039;vspace&#039;
              },
              {
                label: &#039;Border width&#039;,
                name: &#039;border&#039;
              },
              {
                label: &#039;Horizontal space&#039;,
                name: &#039;hspace&#039;
              },
              {
                label: &#039;Border style&#039;,
                type: &#039;listbox&#039;,
                name: &#039;borderStyle&#039;,
                width: 90,
                maxWidth: 90,
                onselect: function (evt) {
                  updateStyle(editor, evt.control.rootControl);
                },
                values: [
                  {
                    text: &#039;Select...&#039;,
                    value: &#039;&#039;
                  },
                  {
                    text: &#039;Solid&#039;,
                    value: &#039;solid&#039;
                  },
                  {
                    text: &#039;Dotted&#039;,
                    value: &#039;dotted&#039;
                  },
                  {
                    text: &#039;Dashed&#039;,
                    value: &#039;dashed&#039;
                  },
                  {
                    text: &#039;Double&#039;,
                    value: &#039;double&#039;
                  },
                  {
                    text: &#039;Groove&#039;,
                    value: &#039;groove&#039;
                  },
                  {
                    text: &#039;Ridge&#039;,
                    value: &#039;ridge&#039;
                  },
                  {
                    text: &#039;Inset&#039;,
                    value: &#039;inset&#039;
                  },
                  {
                    text: &#039;Outset&#039;,
                    value: &#039;outset&#039;
                  },
                  {
                    text: &#039;None&#039;,
                    value: &#039;none&#039;
                  },
                  {
                    text: &#039;Hidden&#039;,
                    value: &#039;hidden&#039;
                  }
                ]
              }
            ]
          }
        ]
      };
    };
    var AdvTab = { makeTab: makeTab };

    var doSyncSize = function (widthCtrl, heightCtrl) {
      widthCtrl.state.set(&#039;oldVal&#039;, widthCtrl.value());
      heightCtrl.state.set(&#039;oldVal&#039;, heightCtrl.value());
    };
    var doSizeControls = function (win, f) {
      var widthCtrl = win.find(&#039;#width&#039;)[0];
      var heightCtrl = win.find(&#039;#height&#039;)[0];
      var constrained = win.find(&#039;#constrain&#039;)[0];
      if (widthCtrl &amp;&amp; heightCtrl &amp;&amp; constrained) {
        f(widthCtrl, heightCtrl, constrained.checked());
      }
    };
    var doUpdateSize = function (widthCtrl, heightCtrl, isContrained) {
      var oldWidth = widthCtrl.state.get(&#039;oldVal&#039;);
      var oldHeight = heightCtrl.state.get(&#039;oldVal&#039;);
      var newWidth = widthCtrl.value();
      var newHeight = heightCtrl.value();
      if (isContrained &amp;&amp; oldWidth &amp;&amp; oldHeight &amp;&amp; newWidth &amp;&amp; newHeight) {
        if (newWidth !== oldWidth) {
          newHeight = Math.round(newWidth / oldWidth * newHeight);
          if (!isNaN(newHeight)) {
            heightCtrl.value(newHeight);
          }
        } else {
          newWidth = Math.round(newHeight / oldHeight * newWidth);
          if (!isNaN(newWidth)) {
            widthCtrl.value(newWidth);
          }
        }
      }
      doSyncSize(widthCtrl, heightCtrl);
    };
    var syncSize = function (win) {
      doSizeControls(win, doSyncSize);
    };
    var updateSize = function (win) {
      doSizeControls(win, doUpdateSize);
    };
    var createUi = function () {
      var recalcSize = function (evt) {
        updateSize(evt.control.rootControl);
      };
      return {
        type: &#039;container&#039;,
        label: &#039;Dimensions&#039;,
        layout: &#039;flex&#039;,
        align: &#039;center&#039;,
        spacing: 5,
        items: [
          {
            name: &#039;width&#039;,
            type: &#039;textbox&#039;,
            maxLength: 5,
            size: 5,
            onchange: recalcSize,
            ariaLabel: &#039;Width&#039;
          },
          {
            type: &#039;label&#039;,
            text: &#039;x&#039;
          },
          {
            name: &#039;height&#039;,
            type: &#039;textbox&#039;,
            maxLength: 5,
            size: 5,
            onchange: recalcSize,
            ariaLabel: &#039;Height&#039;
          },
          {
            name: &#039;constrain&#039;,
            type: &#039;checkbox&#039;,
            checked: true,
            text: &#039;Constrain proportions&#039;
          }
        ]
      };
    };
    var SizeManager = {
      createUi: createUi,
      syncSize: syncSize,
      updateSize: updateSize
    };

    var onSrcChange = function (evt, editor) {
      var srcURL, prependURL, absoluteURLPattern;
      var meta = evt.meta || {};
      var control = evt.control;
      var rootControl = control.rootControl;
      var imageListCtrl = rootControl.find(&#039;#image-list&#039;)[0];
      if (imageListCtrl) {
        imageListCtrl.value(editor.convertURL(control.value(), &#039;src&#039;));
      }
      global$2.each(meta, function (value, key) {
        rootControl.find(&#039;#&#039; + key).value(value);
      });
      if (!meta.width &amp;&amp; !meta.height) {
        srcURL = editor.convertURL(control.value(), &#039;src&#039;);
        prependURL = Settings.getPrependUrl(editor);
        absoluteURLPattern = new RegExp(&#039;^(?:[a-z]+:)?//&#039;, &#039;i&#039;);
        if (prependURL &amp;&amp; !absoluteURLPattern.test(srcURL) &amp;&amp; srcURL.substring(0, prependURL.length) !== prependURL) {
          srcURL = prependURL + srcURL;
        }
        control.value(srcURL);
        Utils.getImageSize(editor.documentBaseURI.toAbsolute(control.value()), function (data) {
          if (data.width &amp;&amp; data.height &amp;&amp; Settings.hasDimensions(editor)) {
            rootControl.find(&#039;#width&#039;).value(data.width);
            rootControl.find(&#039;#height&#039;).value(data.height);
            SizeManager.syncSize(rootControl);
          }
        });
      }
    };
    var onBeforeCall = function (evt) {
      evt.meta = evt.control.rootControl.toJSON();
    };
    var getGeneralItems = function (editor, imageListCtrl) {
      var generalFormItems = [
        {
          name: &#039;src&#039;,
          type: &#039;filepicker&#039;,
          filetype: &#039;image&#039;,
          label: &#039;Source&#039;,
          autofocus: true,
          onchange: function (evt) {
            onSrcChange(evt, editor);
          },
          onbeforecall: onBeforeCall
        },
        imageListCtrl
      ];
      if (Settings.hasDescription(editor)) {
        generalFormItems.push({
          name: &#039;alt&#039;,
          type: &#039;textbox&#039;,
          label: &#039;Image description&#039;
        });
      }
      if (Settings.hasImageTitle(editor)) {
        generalFormItems.push({
          name: &#039;title&#039;,
          type: &#039;textbox&#039;,
          label: &#039;Image Title&#039;
        });
      }
      if (Settings.hasDimensions(editor)) {
        generalFormItems.push(SizeManager.createUi());
      }
      if (Settings.getClassList(editor)) {
        generalFormItems.push({
          name: &#039;class&#039;,
          type: &#039;listbox&#039;,
          label: &#039;Class&#039;,
          values: Utils.buildListItems(Settings.getClassList(editor), function (item) {
            if (item.value) {
              item.textStyle = function () {
                return editor.formatter.getCssText({
                  inline: &#039;img&#039;,
                  classes: [item.value]
                });
              };
            }
          })
        });
      }
      if (Settings.hasImageCaption(editor)) {
        generalFormItems.push({
          name: &#039;caption&#039;,
          type: &#039;checkbox&#039;,
          label: &#039;Caption&#039;
        });
      }
      return generalFormItems;
    };
    var makeTab$1 = function (editor, imageListCtrl) {
      return {
        title: &#039;General&#039;,
        type: &#039;form&#039;,
        items: getGeneralItems(editor, imageListCtrl)
      };
    };
    var MainTab = {
      makeTab: makeTab$1,
      getGeneralItems: getGeneralItems
    };

    var url = function () {
      return Global$1.getOrDie(&#039;URL&#039;);
    };
    var createObjectURL = function (blob) {
      return url().createObjectURL(blob);
    };
    var revokeObjectURL = function (u) {
      url().revokeObjectURL(u);
    };
    var URL = {
      createObjectURL: createObjectURL,
      revokeObjectURL: revokeObjectURL
    };

    var global$5 = tinymce.util.Tools.resolve(&#039;tinymce.ui.Factory&#039;);

    function XMLHttpRequest () {
      var f = Global$1.getOrDie(&#039;XMLHttpRequest&#039;);
      return new f();
    }

    var noop = function () {
    };
    var pathJoin = function (path1, path2) {
      if (path1) {
        return path1.replace(/\/$/, &#039;&#039;) + &#039;/&#039; + path2.replace(/^\//, &#039;&#039;);
      }
      return path2;
    };
    function Uploader (settings) {
      var defaultHandler = function (blobInfo, success, failure, progress) {
        var xhr, formData;
        xhr = XMLHttpRequest();
        xhr.open(&#039;POST&#039;, settings.url);
        xhr.withCredentials = settings.credentials;
        xhr.upload.onprogress = function (e) {
          progress(e.loaded / e.total * 100);
        };
        xhr.onerror = function () {
          failure(&#039;Image upload failed due to a XHR Transport error. Code: &#039; + xhr.status);
        };
        xhr.onload = function () {
          var json;
          if (xhr.status &lt; 200 || xhr.status &gt;= 300) {
            failure(&#039;HTTP Error: &#039; + xhr.status);
            return;
          }
          json = JSON.parse(xhr.responseText);
          if (!json || typeof json.location !== &#039;string&#039;) {
            failure(&#039;Invalid JSON: &#039; + xhr.responseText);
            return;
          }
          success(pathJoin(settings.basePath, json.location));
        };
        formData = new domGlobals.FormData();
        formData.append(&#039;file&#039;, blobInfo.blob(), blobInfo.filename());
        xhr.send(formData);
      };
      var uploadBlob = function (blobInfo, handler) {
        return new global$1(function (resolve, reject) {
          try {
            handler(blobInfo, resolve, reject, noop);
          } catch (ex) {
            reject(ex.message);
          }
        });
      };
      var isDefaultHandler = function (handler) {
        return handler === defaultHandler;
      };
      var upload = function (blobInfo) {
        return !settings.url &amp;&amp; isDefaultHandler(settings.handler) ? global$1.reject(&#039;Upload url missing from the settings.&#039;) : uploadBlob(blobInfo, settings.handler);
      };
      settings = global$2.extend({
        credentials: false,
        handler: defaultHandler
      }, settings);
      return { upload: upload };
    }

    var onFileInput = function (editor) {
      return function (evt) {
        var Throbber = global$5.get(&#039;Throbber&#039;);
        var rootControl = evt.control.rootControl;
        var throbber = new Throbber(rootControl.getEl());
        var file = evt.control.value();
        var blobUri = URL.createObjectURL(file);
        var uploader = Uploader({
          url: Settings.getUploadUrl(editor),
          basePath: Settings.getUploadBasePath(editor),
          credentials: Settings.getUploadCredentials(editor),
          handler: Settings.getUploadHandler(editor)
        });
        var finalize = function () {
          throbber.hide();
          URL.revokeObjectURL(blobUri);
        };
        throbber.show();
        return Utils.blobToDataUri(file).then(function (dataUrl) {
          var blobInfo = editor.editorUpload.blobCache.create({
            blob: file,
            blobUri: blobUri,
            name: file.name ? file.name.replace(/\.[^\.]+$/, &#039;&#039;) : null,
            base64: dataUrl.split(&#039;,&#039;)[1]
          });
          return uploader.upload(blobInfo).then(function (url) {
            var src = rootControl.find(&#039;#src&#039;);
            src.value(url);
            rootControl.find(&#039;tabpanel&#039;)[0].activateTab(0);
            src.fire(&#039;change&#039;);
            finalize();
            return url;
          });
        }).catch(function (err) {
          editor.windowManager.alert(err);
          finalize();
        });
      };
    };
    var acceptExts = &#039;.jpg,.jpeg,.png,.gif&#039;;
    var makeTab$2 = function (editor) {
      return {
        title: &#039;Upload&#039;,
        type: &#039;form&#039;,
        layout: &#039;flex&#039;,
        direction: &#039;column&#039;,
        align: &#039;stretch&#039;,
        padding: &#039;20 20 20 20&#039;,
        items: [
          {
            type: &#039;container&#039;,
            layout: &#039;flex&#039;,
            direction: &#039;column&#039;,
            align: &#039;center&#039;,
            spacing: 10,
            items: [
              {
                text: &#039;Browse for an image&#039;,
                type: &#039;browsebutton&#039;,
                accept: acceptExts,
                onchange: onFileInput(editor)
              },
              {
                text: &#039;OR&#039;,
                type: &#039;label&#039;
              }
            ]
          },
          {
            text: &#039;Drop an image here&#039;,
            type: &#039;dropzone&#039;,
            accept: acceptExts,
            height: 100,
            onchange: onFileInput(editor)
          }
        ]
      };
    };
    var UploadTab = { makeTab: makeTab$2 };

    function curry(fn) {
      var initialArgs = [];
      for (var _i = 1; _i &lt; arguments.length; _i++) {
        initialArgs[_i - 1] = arguments[_i];
      }
      return function () {
        var restArgs = [];
        for (var _i = 0; _i &lt; arguments.length; _i++) {
          restArgs[_i] = arguments[_i];
        }
        var all = initialArgs.concat(restArgs);
        return fn.apply(null, all);
      };
    }

    var submitForm = function (editor, evt) {
      var win = evt.control.getRoot();
      SizeManager.updateSize(win);
      editor.undoManager.transact(function () {
        var data = merge(readImageDataFromSelection(editor), win.toJSON());
        insertOrUpdateImage(editor, data);
      });
      editor.editorUpload.uploadImagesAuto();
    };
    function Dialog (editor) {
      function showDialog(imageList) {
        var data = readImageDataFromSelection(editor);
        var win, imageListCtrl;
        if (imageList) {
          imageListCtrl = {
            type: &#039;listbox&#039;,
            label: &#039;Image list&#039;,
            name: &#039;image-list&#039;,
            values: Utils.buildListItems(imageList, function (item) {
              item.value = editor.convertURL(item.value || item.url, &#039;src&#039;);
            }, [{
                text: &#039;None&#039;,
                value: &#039;&#039;
              }]),
            value: data.src &amp;&amp; editor.convertURL(data.src, &#039;src&#039;),
            onselect: function (e) {
              var altCtrl = win.find(&#039;#alt&#039;);
              if (!altCtrl.value() || e.lastControl &amp;&amp; altCtrl.value() === e.lastControl.text()) {
                altCtrl.value(e.control.text());
              }
              win.find(&#039;#src&#039;).value(e.control.value()).fire(&#039;change&#039;);
            },
            onPostRender: function () {
              imageListCtrl = this;
            }
          };
        }
        if (Settings.hasAdvTab(editor) || Settings.hasUploadUrl(editor) || Settings.hasUploadHandler(editor)) {
          var body = [MainTab.makeTab(editor, imageListCtrl)];
          if (Settings.hasAdvTab(editor)) {
            body.push(AdvTab.makeTab(editor));
          }
          if (Settings.hasUploadUrl(editor) || Settings.hasUploadHandler(editor)) {
            body.push(UploadTab.makeTab(editor));
          }
          win = editor.windowManager.open({
            title: &#039;Insert/edit image&#039;,
            data: data,
            bodyType: &#039;tabpanel&#039;,
            body: body,
            onSubmit: curry(submitForm, editor)
          });
        } else {
          win = editor.windowManager.open({
            title: &#039;Insert/edit image&#039;,
            data: data,
            body: MainTab.getGeneralItems(editor, imageListCtrl),
            onSubmit: curry(submitForm, editor)
          });
        }
        SizeManager.syncSize(win);
      }
      function open() {
        Utils.createImageList(editor, showDialog);
      }
      return { open: open };
    }

    var register = function (editor) {
      editor.addCommand(&#039;mceImage&#039;, Dialog(editor).open);
    };
    var Commands = { register: register };

    var hasImageClass = function (node) {
      var className = node.attr(&#039;class&#039;);
      return className &amp;&amp; /\bimage\b/.test(className);
    };
    var toggleContentEditableState = function (state) {
      return function (nodes) {
        var i = nodes.length, node;
        var toggleContentEditable = function (node) {
          node.attr(&#039;contenteditable&#039;, state ? &#039;true&#039; : null);
        };
        while (i--) {
          node = nodes[i];
          if (hasImageClass(node)) {
            node.attr(&#039;contenteditable&#039;, state ? &#039;false&#039; : null);
            global$2.each(node.getAll(&#039;figcaption&#039;), toggleContentEditable);
          }
        }
      };
    };
    var setup = function (editor) {
      editor.on(&#039;preInit&#039;, function () {
        editor.parser.addNodeFilter(&#039;figure&#039;, toggleContentEditableState(true));
        editor.serializer.addNodeFilter(&#039;figure&#039;, toggleContentEditableState(false));
      });
    };
    var FilterContent = { setup: setup };

    var register$1 = function (editor) {
      editor.addButton(&#039;image&#039;, {
        icon: &#039;image&#039;,
        tooltip: &#039;Insert/edit image&#039;,
        onclick: Dialog(editor).open,
        stateSelector: &#039;img:not([data-mce-object],[data-mce-placeholder]),figure.image&#039;
      });
      editor.addMenuItem(&#039;image&#039;, {
        icon: &#039;image&#039;,
        text: &#039;Image&#039;,
        onclick: Dialog(editor).open,
        context: &#039;insert&#039;,
        prependToContext: true
      });
    };
    var Buttons = { register: register$1 };

    global.add(&#039;image&#039;, function (editor) {
      FilterContent.setup(editor);
      Buttons.register(editor);
      Commands.register(editor);
    });
    function Plugin () {
    }

    return Plugin;

}(window));
})();
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2Fwp-includes%2Fjs%2Ftinymce%2Fplugins%2Fimage'>⬅ Back to Directory</a>