+    var os;

+    os = {};

+    if (/Mac/.test(navigator.appVersion)) {

+      os.mac = true;

+    } else if (/Linux/.test(navigator.appVersion)) {

+      os.linux = true;

+    } else if (/Win/.test(navigator.appVersion)) {

+      os.win = true;

+    } else if (/X11/.test(navigator.appVersion)) {

+      os.unix = true;

+    }

+    if (/Mobi/.test(navigator.appVersion)) {

+      os.mobile = true;

+    }

+    return os;

+  })();

+

+  Util.prototype.browser = (function() {

+    var chrome, edge, firefox, ie, ref, ref1, ref2, ref3, ref4, safari, ua;

+    ua = navigator.userAgent;

+    ie = /(msie|trident)/i.test(ua);

+    chrome = /chrome|crios/i.test(ua);

+    safari = /safari/i.test(ua) && !chrome;

+    firefox = /firefox/i.test(ua);

+    edge = /edge/i.test(ua);

+    if (ie) {

+      return {

+        msie: true,

+        version: ((ref = ua.match(/(msie |rv:)(\d+(\.\d+)?)/i)) != null ? ref[2] : void 0) * 1

+      };

+    } else if (edge) {

+      return {

+        edge: true,

+        webkit: true,

+        version: ((ref1 = ua.match(/edge\/(\d+(\.\d+)?)/i)) != null ? ref1[1] : void 0) * 1

+      };

+    } else if (chrome) {

+      return {

+        webkit: true,

+        chrome: true,

+        version: ((ref2 = ua.match(/(?:chrome|crios)\/(\d+(\.\d+)?)/i)) != null ? ref2[1] : void 0) * 1

+      };

+    } else if (safari) {

+      return {

+        webkit: true,

+        safari: true,

+        version: ((ref3 = ua.match(/version\/(\d+(\.\d+)?)/i)) != null ? ref3[1] : void 0) * 1

+      };

+    } else if (firefox) {

+      return {

+        mozilla: true,

+        firefox: true,

+        version: ((ref4 = ua.match(/firefox\/(\d+(\.\d+)?)/i)) != null ? ref4[1] : void 0) * 1

+      };

+    } else {

+      return {};

+    }

+  })();

+

+  Util.prototype.support = (function() {

+    return {

+      onselectionchange: (function() {

+        var e, onselectionchange;

+        onselectionchange = document.onselectionchange;

+        if (onselectionchange !== void 0) {

+          try {

+            document.onselectionchange = 0;

+            return document.onselectionchange === null;

+          } catch (_error) {

+            e = _error;

+          } finally {

+            document.onselectionchange = onselectionchange;

+          }

+        }

+        return false;

+      })(),

+      oninput: (function() {

+        return !/(msie|trident)/i.test(navigator.userAgent);

+      })()

+    };

+  })();

+

+  Util.prototype.reflow = function(el) {

+    if (el == null) {

+      el = document;

+    }

+    return $(el)[0].offsetHeight;

+  };

+

+  Util.prototype.metaKey = function(e) {

+    var isMac;

+    isMac = /Mac/.test(navigator.userAgent);

+    if (isMac) {

+      return e.metaKey;

+    } else {

+      return e.ctrlKey;

+    }

+  };

+

+  Util.prototype.isEmptyNode = function(node) {

+    var $node;

+    $node = $(node);

+    return $node.is(':empty') || (!$node.text() && !$node.find(':not(br, span, div)').length);

+  };

+

+  Util.prototype.isDecoratedNode = function(node) {

+    return $(node).is('[class^="simditor-"]');

+  };

+

+  Util.prototype.blockNodes = ["div", "p", "ul", "ol", "li", "blockquote", "hr", "pre", "h1", "h2", "h3", "h4", "h5", "table"];

+

+  Util.prototype.isBlockNode = function(node) {

+    node = $(node)[0];

+    if (!node || node.nodeType === 3) {

+      return false;

+    }

+    return new RegExp("^(" + (this.blockNodes.join('|')) + ")$").test(node.nodeName.toLowerCase());

+  };

+

+  Util.prototype.getNodeLength = function(node) {

+    node = $(node)[0];

+    switch (node.nodeType) {

+      case 7:

+      case 10:

+        return 0;

+      case 3:

+      case 8:

+        return node.length;

+      default:

+        return node.childNodes.length;

+    }

+  };

+

+  Util.prototype.dataURLtoBlob = function(dataURL) {

+    var BlobBuilder, arrayBuffer, bb, blobArray, byteString, hasArrayBufferViewSupport, hasBlobConstructor, i, intArray, k, mimeString, ref, supportBlob;

+    hasBlobConstructor = window.Blob && (function() {

+      var e;

+      try {

+        return Boolean(new Blob());

+      } catch (_error) {

+        e = _error;

+        return false;

+      }

+    })();

+    hasArrayBufferViewSupport = hasBlobConstructor && window.Uint8Array && (function() {

+      var e;

+      try {

+        return new Blob([new Uint8Array(100)]).size === 100;

+      } catch (_error) {

+        e = _error;

+        return false;

+      }

+    })();

+    BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;

+    supportBlob = hasBlobConstructor || BlobBuilder;

+    if (!(supportBlob && window.atob && window.ArrayBuffer && window.Uint8Array)) {

+      return false;

+    }

+    if (dataURL.split(',')[0].indexOf('base64') >= 0) {

+      byteString = atob(dataURL.split(',')[1]);

+    } else {

+      byteString = decodeURIComponent(dataURL.split(',')[1]);

+    }

+    arrayBuffer = new ArrayBuffer(byteString.length);

+    intArray = new Uint8Array(arrayBuffer);

+    for (i = k = 0, ref = byteString.length; 0 <= ref ? k <= ref : k >= ref; i = 0 <= ref ? ++k : --k) {

+      intArray[i] = byteString.charCodeAt(i);

+    }

+    mimeString = dataURL.split(',')[0].split(':')[1].split(';')[0];

+    if (hasBlobConstructor) {

+      blobArray = hasArrayBufferViewSupport ? intArray : arrayBuffer;

+      return new Blob([blobArray], {

+        type: mimeString

+      });

+    }

+    bb = new BlobBuilder();

+    bb.append(arrayBuffer);

+    return bb.getBlob(mimeString);

+  };

+

+  Util.prototype.throttle = function(func, wait) {

+    var args, call, ctx, last, rtn, throttled, timeoutID;

+    last = 0;

+    timeoutID = 0;

+    ctx = args = rtn = null;

+    call = function() {

+      timeoutID = 0;

+      last = +new Date();

+      rtn = func.apply(ctx, args);

+      ctx = null;

+      return args = null;

+    };

+    throttled = function() {

+      var delta;

+      ctx = this;

+      args = arguments;

+      delta = new Date() - last;

+      if (!timeoutID) {

+        if (delta >= wait) {

+          call();

+        } else {

+          timeoutID = setTimeout(call, wait - delta);

+        }

+      }

+      return rtn;

+    };

+    throttled.clear = function() {

+      if (!timeoutID) {

+        return;

+      }

+      clearTimeout(timeoutID);

+      return call();

+    };

+    return throttled;

+  };

+

+  Util.prototype.formatHTML = function(html) {

+    var cursor, indentString, lastMatch, level, match, re, repeatString, result, str;

+    re = /<(\/?)(.+?)(\/?)>/g;

+    result = '';

+    level = 0;

+    lastMatch = null;

+    indentString = '  ';

+    repeatString = function(str, n) {

+      return new Array(n + 1).join(str);

+    };

+    while ((match = re.exec(html)) !== null) {

+      match.isBlockNode = $.inArray(match[2], this.blockNodes) > -1;

+      match.isStartTag = match[1] !== '/' && match[3] !== '/';

+      match.isEndTag = match[1] === '/' || match[3] === '/';

+      cursor = lastMatch ? lastMatch.index + lastMatch[0].length : 0;

+      if ((str = html.substring(cursor, match.index)).length > 0 && $.trim(str)) {

+        result += str;

+      }

+      if (match.isBlockNode && match.isEndTag && !match.isStartTag) {

+        level -= 1;

+      }

+      if (match.isBlockNode && match.isStartTag) {

+        if (!(lastMatch && lastMatch.isBlockNode && lastMatch.isEndTag)) {

+          result += '\n';

+        }

+        result += repeatString(indentString, level);

+      }

+      result += match[0];

+      if (match.isBlockNode && match.isEndTag) {

+        result += '\n';

+      }

+      if (match.isBlockNode && match.isStartTag) {

+        level += 1;

+      }

+      lastMatch = match;

+    }

+    return $.trim(result);

+  };

+

+  return Util;

+

+})(SimpleModule);

+

+Toolbar = (function(superClass) {

+  extend(Toolbar, superClass);

+

+  function Toolbar() {

+    return Toolbar.__super__.constructor.apply(this, arguments);

+  }

+

+  Toolbar.pluginName = 'Toolbar';

+

+  Toolbar.prototype.opts = {

+    toolbar: true,

+    toolbarFloat: true,

+    toolbarHidden: false,

+    toolbarFloatOffset: 0

+  };

+

+  Toolbar.prototype._tpl = {

+    wrapper: '<div class="simditor-toolbar"><ul></ul></div>',

+    separator: '<li><span class="separator"></span></li>'

+  };

+

+  Toolbar.prototype._init = function() {

+    var floatInitialized, initToolbarFloat, toolbarHeight;

+    this.editor = this._module;

+    if (!this.opts.toolbar) {

+      return;

+    }

+    if (!$.isArray(this.opts.toolbar)) {

+      this.opts.toolbar = ['bold', 'italic', 'underline', 'strikethrough', '|', 'ol', 'ul', 'blockquote', 'code', '|', 'link', 'image', '|', 'indent', 'outdent'];

+    }

+    this._render();

+    this.list.on('click', function(e) {

+      return false;

+    });

+    this.wrapper.on('mousedown', (function(_this) {

+      return function(e) {

+        return _this.list.find('.menu-on').removeClass('.menu-on');

+      };

+    })(this));

+    $(document).on('mousedown.simditor' + this.editor.id, (function(_this) {

+      return function(e) {

+        return _this.list.find('.menu-on').removeClass('.menu-on');

+      };

+    })(this));

+    if (!this.opts.toolbarHidden && this.opts.toolbarFloat) {

+      this.wrapper.css('top', this.opts.toolbarFloatOffset);

+      toolbarHeight = 0;

+      initToolbarFloat = (function(_this) {

+        return function() {

+          _this.wrapper.css('position', 'static');

+          _this.wrapper.width('auto');

+          _this.editor.util.reflow(_this.wrapper);

+          _this.wrapper.width(_this.wrapper.outerWidth());

+          _this.wrapper.css('left', _this.editor.util.os.mobile ? _this.wrapper.position().left : _this.wrapper.offset().left);

+          _this.wrapper.css('position', '');

+

+          _this.editor.wrapper.width(_this.wrapper.outerWidth());

+

+          toolbarHeight = _this.wrapper.outerHeight();

+          _this.editor.placeholderEl.css('top', toolbarHeight);

+          return true;

+        };

+      })(this);

+      floatInitialized = null;

+      $(window).on('resize.simditor-' + this.editor.id, function(e) {

+        return floatInitialized = initToolbarFloat();

+      });

+      $(window).on('scroll.simditor-' + this.editor.id, (function(_this) {

+        return function(e) {

+          var bottomEdge, scrollTop, topEdge;

+          if (!_this.wrapper.is(':visible')) {

+            return;

+          }

+          topEdge = _this.editor.wrapper.offset().top;

+          bottomEdge = topEdge + _this.editor.wrapper.outerHeight() - 80;

+          scrollTop = $(document).scrollTop() + _this.opts.toolbarFloatOffset;

+          if (scrollTop <= topEdge || scrollTop >= bottomEdge) {

+            _this.editor.wrapper.removeClass('toolbar-floating').css('padding-top', '');

+            if (_this.editor.util.os.mobile) {

+              return _this.wrapper.css('top', _this.opts.toolbarFloatOffset);

+            }

+          } else {

+            floatInitialized || (floatInitialized = initToolbarFloat());

+            _this.editor.wrapper.addClass('toolbar-floating').css('padding-top', toolbarHeight);

+            if (_this.editor.util.os.mobile) {

+              return _this.wrapper.css('top', scrollTop - topEdge + _this.opts.toolbarFloatOffset);

+            }

+          }

+        };

+      })(this));

+    }

+    this.editor.on('destroy', (function(_this) {

+      return function() {

+        return _this.buttons.length = 0;

+      };

+    })(this));

+    return $(document).on("mousedown.simditor-" + this.editor.id, (function(_this) {

+      return function(e) {

+        return _this.list.find('li.menu-on').removeClass('menu-on');

+      };

+    })(this));

+  };

+

+  Toolbar.prototype._render = function() {

+    var k, len, name, ref;

+    this.buttons = [];

+    this.wrapper = $(this._tpl.wrapper).prependTo(this.editor.wrapper);

+    this.list = this.wrapper.find('ul');

+    ref = this.opts.toolbar;

+    for (k = 0, len = ref.length; k < len; k++) {

+      name = ref[k];

+      if (name === '|') {

+        $(this._tpl.separator).appendTo(this.list);

+        continue;

+      }

+      if (!this.constructor.buttons[name]) {

+        throw new Error("simditor: invalid toolbar button " + name);

+        continue;

+      }

+      this.buttons.push(new this.constructor.buttons[name]({

+        editor: this.editor

+      }));

+    }

+    if (this.opts.toolbarHidden) {

+      return this.wrapper.hide();

+    }

+  };

+

+  Toolbar.prototype.findButton = function(name) {

+    var button;

+    button = this.list.find('.toolbar-item-' + name).data('button');

+    return button != null ? button : null;

+  };

+

+  Toolbar.addButton = function(btn) {

+    return this.buttons[btn.prototype.name] = btn;

+  };

+

+  Toolbar.buttons = {};

+

+  return Toolbar;

+

+})(SimpleModule);

+

+Indentation = (function(superClass) {

+  extend(Indentation, superClass);

+

+  function Indentation() {

+    return Indentation.__super__.constructor.apply(this, arguments);

+  }

+

+  Indentation.pluginName = 'Indentation';

+

+  Indentation.prototype.opts = {

+    tabIndent: true

+  };

+

+  Indentation.prototype._init = function() {

+    this.editor = this._module;

+    return this.editor.keystroke.add('tab', '*', (function(_this) {

+      return function(e) {

+        var codeButton;

+        codeButton = _this.editor.toolbar.findButton('code');

+        if (!(_this.opts.tabIndent || (codeButton && codeButton.active))) {

+          return;

+        }

+        return _this.indent(e.shiftKey);

+      };

+    })(this));

+  };

+

+  Indentation.prototype.indent = function(isBackward) {

+    var $blockNodes, $endNodes, $startNodes, nodes, result;

+    $startNodes = this.editor.selection.startNodes();

+    $endNodes = this.editor.selection.endNodes();

+    $blockNodes = this.editor.selection.blockNodes();

+    nodes = [];

+    $blockNodes = $blockNodes.each(function(i, node) {

+      var include, j, k, len, n;

+      include = true;

+      for (j = k = 0, len = nodes.length; k < len; j = ++k) {

+        n = nodes[j];

+        if ($.contains(node, n)) {

+          include = false;

+          break;

+        } else if ($.contains(n, node)) {

+          nodes.splice(j, 1, node);

+          include = false;

+          break;

+        }

+      }

+      if (include) {

+        return nodes.push(node);

+      }

+    });

+    $blockNodes = $(nodes);

+    result = false;

+    $blockNodes.each((function(_this) {

+      return function(i, blockEl) {

+        var r;

+        r = isBackward ? _this.outdentBlock(blockEl) : _this.indentBlock(blockEl);

+        if (r) {

+          return result = r;

+        }

+      };

+    })(this));

+    return result;

+  };

+

+  Indentation.prototype.indentBlock = function(blockEl) {

+    var $blockEl, $childList, $nextTd, $nextTr, $parentLi, $pre, $td, $tr, marginLeft, tagName;

+    $blockEl = $(blockEl);

+    if (!$blockEl.length) {

+      return;

+    }

+    if ($blockEl.is('pre')) {

+      $pre = this.editor.selection.containerNode();

+      if (!($pre.is($blockEl) || $pre.closest('pre').is($blockEl))) {

+        return;

+      }

+      this.indentText(this.editor.selection.range());

+    } else if ($blockEl.is('li')) {

+      $parentLi = $blockEl.prev('li');

+      if ($parentLi.length < 1) {

+        return;

+      }

+      this.editor.selection.save();

+      tagName = $blockEl.parent()[0].tagName;

+      $childList = $parentLi.children('ul, ol');

+      if ($childList.length > 0) {

+        $childList.append($blockEl);

+      } else {

+        $('<' + tagName + '/>').append($blockEl).appendTo($parentLi);

+      }

+      this.editor.selection.restore();

+    } else if ($blockEl.is('p, h1, h2, h3, h4')) {

+      marginLeft = parseInt($blockEl.css('margin-left')) || 0;

+      marginLeft = (Math.round(marginLeft / this.opts.indentWidth) + 1) * this.opts.indentWidth;

+      $blockEl.css('margin-left', marginLeft);

+    } else if ($blockEl.is('table') || $blockEl.is('.simditor-table')) {

+      $td = this.editor.selection.containerNode().closest('td, th');

+      $nextTd = $td.next('td, th');

+      if (!($nextTd.length > 0)) {

+        $tr = $td.parent('tr');

+        $nextTr = $tr.next('tr');

+        if ($nextTr.length < 1 && $tr.parent().is('thead')) {

+          $nextTr = $tr.parent('thead').next('tbody').find('tr:first');

+        }

+        $nextTd = $nextTr.find('td:first, th:first');

+      }

+      if (!($td.length > 0 && $nextTd.length > 0)) {

+        return;

+      }

+      this.editor.selection.setRangeAtEndOf($nextTd);

+    } else {

+      return false;

+    }

+    return true;

+  };

+

+  Indentation.prototype.indentText = function(range) {

+    var text, textNode;

+    text = range.toString().replace(/^(?=.+)/mg, '\u00A0\u00A0');

+    textNode = document.createTextNode(text || '\u00A0\u00A0');

+    range.deleteContents();

+    range.insertNode(textNode);

+    if (text) {

+      range.selectNode(textNode);

+      return this.editor.selection.range(range);

+    } else {

+      return this.editor.selection.setRangeAfter(textNode);

+    }

+  };

+

+  Indentation.prototype.outdentBlock = function(blockEl) {

+    var $blockEl, $parent, $parentLi, $pre, $prevTd, $prevTr, $td, $tr, marginLeft, range;

+    $blockEl = $(blockEl);

+    if (!($blockEl && $blockEl.length > 0)) {

+      return;

+    }

+    if ($blockEl.is('pre')) {

+      $pre = this.editor.selection.containerNode();

+      if (!($pre.is($blockEl) || $pre.closest('pre').is($blockEl))) {

+        return;

+      }

+      this.outdentText(range);

+    } else if ($blockEl.is('li')) {

+      $parent = $blockEl.parent();

+      $parentLi = $parent.parent('li');

+      this.editor.selection.save();

+      if ($parentLi.length < 1) {

+        range = document.createRange();

+        range.setStartBefore($parent[0]);

+        range.setEndBefore($blockEl[0]);

+        $parent.before(range.extractContents());

+        $('<p/>').insertBefore($parent).after($blockEl.children('ul, ol')).append($blockEl.contents());

+        $blockEl.remove();

+      } else {

+        if ($blockEl.next('li').length > 0) {

+          $('<' + $parent[0].tagName + '/>').append($blockEl.nextAll('li')).appendTo($blockEl);

+        }

+        $blockEl.insertAfter($parentLi);

+        if ($parent.children('li').length < 1) {

+          $parent.remove();

+        }

+      }

+      this.editor.selection.restore();

+    } else if ($blockEl.is('p, h1, h2, h3, h4')) {

+      marginLeft = parseInt($blockEl.css('margin-left')) || 0;

+      marginLeft = Math.max(Math.round(marginLeft / this.opts.indentWidth) - 1, 0) * this.opts.indentWidth;

+      $blockEl.css('margin-left', marginLeft === 0 ? '' : marginLeft);

+    } else if ($blockEl.is('table') || $blockEl.is('.simditor-table')) {

+      $td = this.editor.selection.containerNode().closest('td, th');

+      $prevTd = $td.prev('td, th');

+      if (!($prevTd.length > 0)) {

+        $tr = $td.parent('tr');

+        $prevTr = $tr.prev('tr');

+        if ($prevTr.length < 1 && $tr.parent().is('tbody')) {

+          $prevTr = $tr.parent('tbody').prev('thead').find('tr:first');

+        }

+        $prevTd = $prevTr.find('td:last, th:last');

+      }

+      if (!($td.length > 0 && $prevTd.length > 0)) {

+        return;

+      }

+      this.editor.selection.setRangeAtEndOf($prevTd);

+    } else {

+      return false;

+    }

+    return true;

+  };

+

+  Indentation.prototype.outdentText = function(range) {};

+

+  return Indentation;

+

+})(SimpleModule);

+

+Clipboard = (function(superClass) {

+  extend(Clipboard, superClass);

+

+  function Clipboard() {

+    return Clipboard.__super__.constructor.apply(this, arguments);

+  }

+

+  Clipboard.pluginName = 'Clipboard';

+

+  Clipboard.prototype.opts = {

+    pasteImage: false,

+    cleanPaste: false

+  };

+

+  Clipboard.prototype._init = function() {

+    this.editor = this._module;

+    if (this.opts.pasteImage && typeof this.opts.pasteImage !== 'string') {

+      this.opts.pasteImage = 'inline';

+    }

+    return this.editor.body.on('paste', (function(_this) {

+      return function(e) {

+        var range;

+        if (_this.pasting || _this._pasteBin) {

+          return;

+        }

+        if (_this.editor.triggerHandler(e) === false) {

+          return false;

+        }

+        range = _this.editor.selection.deleteRangeContents();

+        if (_this.editor.body.html()) {

+          if (!range.collapsed) {

+            range.collapse(true);

+          }

+        } else {

+          _this.editor.formatter.format();

+          _this.editor.selection.setRangeAtStartOf(_this.editor.body.find('p:first'));

+        }

+        if (_this._processPasteByClipboardApi(e)) {

+          return false;

+        }

+        _this.editor.inputManager.throttledValueChanged.clear();

+        _this.editor.inputManager.throttledSelectionChanged.clear();

+        _this.editor.undoManager.throttledPushState.clear();

+        _this.editor.selection.reset();

+        _this.editor.undoManager.resetCaretPosition();

+        _this.pasting = true;

+        return _this._getPasteContent(function(pasteContent) {

+          _this._processPasteContent(pasteContent);

+          _this._pasteInBlockEl = null;

+          _this._pastePlainText = null;

+          return _this.pasting = false;

+        });

+      };

+    })(this));

+  };

+

+  Clipboard.prototype._processPasteByClipboardApi = function(e) {

+    var imageFile, pasteItem, ref, uploadOpt;

+    if (this.editor.util.browser.edge) {

+      return;

+    }

+    if (e.originalEvent.clipboardData && e.originalEvent.clipboardData.items && e.originalEvent.clipboardData.items.length > 0) {

+      pasteItem = e.originalEvent.clipboardData.items[0];

+      if (/^image\//.test(pasteItem.type)) {

+        imageFile = pasteItem.getAsFile();

+        if (!((imageFile != null) && this.opts.pasteImage)) {

+          return;

+        }

+        if (!imageFile.name) {

+          imageFile.name = "Clipboard Image.png";

+        }

+        if (this.editor.triggerHandler('pasting', [imageFile]) === false) {

+          return;

+        }

+        uploadOpt = {};

+        uploadOpt[this.opts.pasteImage] = true;

+        if ((ref = this.editor.uploader) != null) {

+          ref.upload(imageFile, uploadOpt);

+        }

+        return true;

+      }

+    }

+  };

+

+  Clipboard.prototype._getPasteContent = function(callback) {

+    var state;

+    this._pasteBin = $('<div contenteditable="true" />').addClass('simditor-paste-bin').attr('tabIndex', '-1').appendTo(this.editor.el);

+    state = {

+      html: this.editor.body.html(),

+      caret: this.editor.undoManager.caretPosition()

+    };

+    this._pasteBin.focus();

+    return setTimeout((function(_this) {

+      return function() {

+        var pasteContent;

+        _this.editor.hidePopover();

+        _this.editor.body.get(0).innerHTML = state.html;

+        _this.editor.undoManager.caretPosition(state.caret);

+        _this.editor.body.focus();

+        _this.editor.selection.reset();

+        _this.editor.selection.range();

+        _this._pasteInBlockEl = _this.editor.selection.blockNodes().last();

+        _this._pastePlainText = _this.opts.cleanPaste || _this._pasteInBlockEl.is('pre, table');

+        if (_this._pastePlainText) {

+          pasteContent = _this.editor.formatter.clearHtml(_this._pasteBin.html(), true);

+        } else {

+          pasteContent = $('<div/>').append(_this._pasteBin.contents());

+          pasteContent.find('table colgroup').remove();

+          _this.editor.formatter.format(pasteContent);

+          _this.editor.formatter.decorate(pasteContent);

+          _this.editor.formatter.beautify(pasteContent.children());

+          pasteContent = pasteContent.contents();

+        }

+        _this._pasteBin.remove();

+        _this._pasteBin = null;

+        return callback(pasteContent);

+      };

+    })(this), 0);

+  };

+

+  Clipboard.prototype._processPasteContent = function(pasteContent) {

+    var $blockEl, $img, blob, children, insertPosition, k, l, lastLine, len, len1, len2, len3, len4, line, lines, m, node, o, q, ref, ref1, ref2, uploadOpt;

+    if (this.editor.triggerHandler('pasting', [pasteContent]) === false) {

+      return;

+    }

+    $blockEl = this._pasteInBlockEl;

+    if (!pasteContent) {

+      return;

+    } else if (this._pastePlainText) {

+      if ($blockEl.is('table')) {

+        lines = pasteContent.split('\n');

+        lastLine = lines.pop();

+        for (k = 0, len = lines.length; k < len; k++) {

+          line = lines[k];

+          this.editor.selection.insertNode(document.createTextNode(line));

+          this.editor.selection.insertNode($('<br/>'));

+        }

+        this.editor.selection.insertNode(document.createTextNode(lastLine));

+      } else {

+        pasteContent = $('<div/>').text(pasteContent);

+        ref = pasteContent.contents();

+        for (l = 0, len1 = ref.length; l < len1; l++) {

+          node = ref[l];

+          this.editor.selection.insertNode($(node)[0]);

+        }

+      }

+    } else if ($blockEl.is(this.editor.body)) {

+      for (m = 0, len2 = pasteContent.length; m < len2; m++) {

+        node = pasteContent[m];

+        this.editor.selection.insertNode(node);

+      }

+    } else if (pasteContent.length < 1) {

+      return;

+    } else if (pasteContent.length === 1) {

+      if (pasteContent.is('p')) {

+        children = pasteContent.contents();

+        if (children.length === 1 && children.is('img')) {

+          $img = children;

+          if (/^data:image/.test($img.attr('src'))) {

+            if (!this.opts.pasteImage) {

+              return;

+            }

+            blob = this.editor.util.dataURLtoBlob($img.attr("src"));

+            blob.name = "Clipboard Image.png";

+            uploadOpt = {};

+            uploadOpt[this.opts.pasteImage] = true;

+            if ((ref1 = this.editor.uploader) != null) {

+              ref1.upload(blob, uploadOpt);

+            }

+            return;

+          } else if ($img.is('img[src^="webkit-fake-url://"]')) {

+            return;

+          }

+        }

+        for (o = 0, len3 = children.length; o < len3; o++) {

+          node = children[o];

+          this.editor.selection.insertNode(node);

+        }

+      } else if ($blockEl.is('p') && this.editor.util.isEmptyNode($blockEl)) {

+        $blockEl.replaceWith(pasteContent);

+        this.editor.selection.setRangeAtEndOf(pasteContent);

+      } else if (pasteContent.is('ul, ol')) {

+        if (pasteContent.find('li').length === 1) {

+          pasteContent = $('<div/>').text(pasteContent.text());

+          ref2 = pasteContent.contents();

+          for (q = 0, len4 = ref2.length; q < len4; q++) {

+            node = ref2[q];

+            this.editor.selection.insertNode($(node)[0]);

+          }

+        } else if ($blockEl.is('li')) {

+          $blockEl.parent().after(pasteContent);

+          this.editor.selection.setRangeAtEndOf(pasteContent);

+        } else {

+          $blockEl.after(pasteContent);

+          this.editor.selection.setRangeAtEndOf(pasteContent);

+        }

+      } else {

+        $blockEl.after(pasteContent);

+        this.editor.selection.setRangeAtEndOf(pasteContent);

+      }

+    } else {

+      if ($blockEl.is('li')) {

+        $blockEl = $blockEl.parent();

+      }

+      if (this.editor.selection.rangeAtStartOf($blockEl)) {

+        insertPosition = 'before';

+      } else if (this.editor.selection.rangeAtEndOf($blockEl)) {

+        insertPosition = 'after';

+      } else {

+        this.editor.selection.breakBlockEl($blockEl);

+        insertPosition = 'before';

+      }

+      $blockEl[insertPosition](pasteContent);

+      this.editor.selection.setRangeAtEndOf(pasteContent.last());

+    }

+    return this.editor.inputManager.throttledValueChanged();

+  };

+

+  return Clipboard;

+

+})(SimpleModule);

+

+Simditor = (function(superClass) {

+  extend(Simditor, superClass);

+

+  function Simditor() {

+    return Simditor.__super__.constructor.apply(this, arguments);

+  }

+

+  Simditor.connect(Util);

+

+  Simditor.connect(InputManager);

+

+  Simditor.connect(Selection);

+

+  Simditor.connect(UndoManager);

+

+  Simditor.connect(Keystroke);

+

+  Simditor.connect(Formatter);

+

+  Simditor.connect(Toolbar);

+

+  Simditor.connect(Indentation);

+

+  Simditor.connect(Clipboard);

+

+  Simditor.count = 0;

+

+  Simditor.prototype.opts = {

+    textarea: null,

+    placeholder: '',

+    defaultImage: 'images/image.png',

+    params: {},

+    upload: false,

+    indentWidth: 40

+  };

+

+  Simditor.prototype._init = function() {

+    var e, editor, form, uploadOpts;

+    this.textarea = $(this.opts.textarea);

+    this.opts.placeholder = this.opts.placeholder || this.textarea.attr('placeholder');

+    if (!this.textarea.length) {

+      throw new Error('simditor: param textarea is required.');

+      return;

+    }

+    editor = this.textarea.data('simditor');

+    if (editor != null) {

+      editor.destroy();

+    }

+    this.id = ++Simditor.count;

+    this._render();

+    if (simpleHotkeys) {

+      this.hotkeys = simpleHotkeys({

+        el: this.body

+      });

+    } else {

+      throw new Error('simditor: simple-hotkeys is required.');

+      return;

+    }

+    if (this.opts.upload && simpleUploader) {

+      uploadOpts = typeof this.opts.upload === 'object' ? this.opts.upload : {};

+      this.uploader = simpleUploader(uploadOpts);

+    }

+    form = this.textarea.closest('form');

+    if (form.length) {

+      form.on('submit.simditor-' + this.id, (function(_this) {

+        return function() {

+          return _this.sync();

+        };

+      })(this));

+      form.on('reset.simditor-' + this.id, (function(_this) {

+        return function() {

+          return _this.setValue('');

+        };

+      })(this));

+    }

+    this.on('initialized', (function(_this) {

+      return function() {

+        if (_this.opts.placeholder) {

+          _this.on('valuechanged', function() {

+            return _this._placeholder();

+          });

+        }

+        _this.setValue(_this.textarea.val().trim() || '');

+        if (_this.textarea.attr('autofocus')) {

+          return _this.focus();

+        }

+      };

+    })(this));

+    if (this.util.browser.mozilla) {

+      this.util.reflow();

+      try {

+        document.execCommand('enableObjectResizing', false, false);

+        return document.execCommand('enableInlineTableEditing', false, false);

+      } catch (_error) {

+        e = _error;

+      }

+    }

+  };

+

+  Simditor.prototype._tpl = "<div class=\"simditor\">\n  <div class=\"simditor-wrapper\">\n    <div class=\"simditor-placeholder\"></div>\n    <div class=\"simditor-body\" contenteditable=\"true\">\n    </div>\n  </div>\n</div>";

+

+  Simditor.prototype._render = function() {

+    var key, ref, results, val;

+    this.el = $(this._tpl).insertBefore(this.textarea);

+    this.wrapper = this.el.find('.simditor-wrapper');

+    this.body = this.wrapper.find('.simditor-body');

+    this.placeholderEl = this.wrapper.find('.simditor-placeholder').append(this.opts.placeholder);

+    this.el.data('simditor', this);

+    this.wrapper.append(this.textarea);

+    this.textarea.data('simditor', this).blur();

+    this.body.attr('tabindex', this.textarea.attr('tabindex'));

+    if (this.util.os.mac) {

+      this.el.addClass('simditor-mac');

+    } else if (this.util.os.linux) {

+      this.el.addClass('simditor-linux');

+    }

+    if (this.util.os.mobile) {

+      this.el.addClass('simditor-mobile');

+    }

+    if (this.opts.params) {

+      ref = this.opts.params;

+      results = [];

+      for (key in ref) {

+        val = ref[key];

+        results.push($('<input/>', {

+          type: 'hidden',

+          name: key,

+          value: val

+        }).insertAfter(this.textarea));

+      }

+      return results;

+    }

+  };

+

+  Simditor.prototype._placeholder = function() {

+    var children;

+    children = this.body.children();

+    if (children.length === 0 || (children.length === 1 && this.util.isEmptyNode(children) && parseInt(children.css('margin-left') || 0) < this.opts.indentWidth)) {

+      return this.placeholderEl.show();

+    } else {

+      return this.placeholderEl.hide();

+    }

+  };

+

+  Simditor.prototype.setValue = function(val) {

+    this.hidePopover();

+    this.textarea.val(val);

+    this.body.get(0).innerHTML = val;

+    this.formatter.format();

+    this.formatter.decorate();

+    this.util.reflow(this.body);

+    this.inputManager.lastCaretPosition = null;

+    return this.trigger('valuechanged');

+  };

+

+  Simditor.prototype.getValue = function() {

+    return this.sync();

+  };

+

+  Simditor.prototype.sync = function() {

+    var children, cloneBody, emptyP, firstP, lastP, val;

+    cloneBody = this.body.clone();

+    this.formatter.undecorate(cloneBody);

+    this.formatter.format(cloneBody);

+    this.formatter.autolink(cloneBody);

+    children = cloneBody.children();

+    lastP = children.last('p');

+    firstP = children.first('p');

+    while (lastP.is('p') && this.util.isEmptyNode(lastP)) {

+      emptyP = lastP;

+      lastP = lastP.prev('p');

+      emptyP.remove();

+    }

+    while (firstP.is('p') && this.util.isEmptyNode(firstP)) {

+      emptyP = firstP;

+      firstP = lastP.next('p');

+      emptyP.remove();

+    }

+    cloneBody.find('img.uploading').remove();

+    val = $.trim(cloneBody.html());

+    this.textarea.val(val);

+    return val;

+  };

+

+  Simditor.prototype.focus = function() {

+    var $blockEl, range;

+    if (!(this.body.is(':visible') && this.body.is('[contenteditable]'))) {

+      this.el.find('textarea:visible').focus();

+      return;

+    }

+    if (this.inputManager.lastCaretPosition) {

+      this.undoManager.caretPosition(this.inputManager.lastCaretPosition);

+      return this.inputManager.lastCaretPosition = null;

+    } else {

+      $blockEl = this.body.children().last();

+      if (!$blockEl.is('p')) {

+        $blockEl = $('<p/>').append(this.util.phBr).appendTo(this.body);

+      }

+      range = document.createRange();

+      return this.selection.setRangeAtEndOf($blockEl, range);

+    }

+  };

+

+  Simditor.prototype.blur = function() {

+    if (this.body.is(':visible') && this.body.is('[contenteditable]')) {

+      return this.body.blur();

+    } else {

+      return this.body.find('textarea:visible').blur();

+    }

+  };

+

+  Simditor.prototype.hidePopover = function() {

+    return this.el.find('.simditor-popover').each(function(i, popover) {

+      popover = $(popover).data('popover');

+      if (popover.active) {

+        return popover.hide();

+      }

+    });

+  };

+

+  Simditor.prototype.destroy = function() {

+    this.triggerHandler('destroy');

+    this.textarea.closest('form').off('.simditor .simditor-' + this.id);

+    this.selection.clear();

+    this.inputManager.focused = false;

+    this.textarea.insertBefore(this.el).hide().val('').removeData('simditor');

+    this.el.remove();

+    $(document).off('.simditor-' + this.id);

+    $(window).off('.simditor-' + this.id);

+    return this.off();

+  };

+

+  return Simditor;

+

+})(SimpleModule);

+

+Simditor.i18n = {

+  'zh-CN': {

+    'blockquote': '引用',

+    'bold': '加粗文字',

+    'code': '插入代码',

+    'color': '文字颜色',

+    'coloredText': '彩色文字',

+    'hr': '分隔线',

+    'image': '插入图片',

+    'externalImage': '外链图片',

+    'uploadImage': '上传图片',

+    'uploadFailed': '上传失败了',

+    'uploadError': '上传出错了',

+    'imageUrl': '图片地址',

+    'imageSize': '图片尺寸',

+    'imageAlt': '图片描述',

+    'restoreImageSize': '还原图片尺寸',

+    'uploading': '正在上传',

+    'indent': '向右缩进',

+    'outdent': '向左缩进',

+    'italic': '斜体文字',

+    'link': '插入链接',

+    'linkText': '链接文字',

+    'linkUrl': '链接地址',

+    'linkTarget': '打开方式',

+    'openLinkInCurrentWindow': '在新窗口中打开',

+    'openLinkInNewWindow': '在当前窗口中打开',

+    'removeLink': '移除链接',

+    'ol': '有序列表',

+    'ul': '无序列表',

+    'strikethrough': '删除线文字',

+    'table': '表格',

+    'deleteRow': '删除行',

+    'insertRowAbove': '在上面插入行',

+    'insertRowBelow': '在下面插入行',

+    'deleteColumn': '删除列',

+    'insertColumnLeft': '在左边插入列',

+    'insertColumnRight': '在右边插入列',

+    'deleteTable': '删除表格',

+    'title': '标题',

+    'normalText': '普通文本',

+    'underline': '下划线文字',

+    'alignment': '水平对齐',

+    'alignCenter': '居中',

+    'alignLeft': '居左',

+    'alignRight': '居右',

+    'selectLanguage': '选择程序语言',

+    'fontScale': '字体大小',

+    'fontScaleXLarge': '超大字体',

+    'fontScaleLarge': '大号字体',

+    'fontScaleNormal': '正常大小',

+    'fontScaleSmall': '小号字体',

+    'fontScaleXSmall': '超小字体'

+  },

+  'en-US': {

+    'blockquote': 'Block Quote',

+    'bold': 'Bold',

+    'code': 'Code',

+    'color': 'Text Color',

+    'coloredText': 'Colored Text',

+    'hr': 'Horizontal Line',

+    'image': 'Insert Image',

+    'externalImage': 'External Image',

+    'uploadImage': 'Upload Image',

+    'uploadFailed': 'Upload failed',

+    'uploadError': 'Error occurs during upload',

+    'imageUrl': 'Url',

+    'imageSize': 'Size',

+    'imageAlt': 'Alt',

+    'restoreImageSize': 'Restore Origin Size',

+    'uploading': 'Uploading',

+    'indent': 'Indent',

+    'outdent': 'Outdent',

+    'italic': 'Italic',

+    'link': 'Insert Link',

+    'linkText': 'Text',

+    'linkUrl': 'Url',

+    'linkTarget': 'Target',

+    'openLinkInCurrentWindow': 'Open link in current window',

+    'openLinkInNewWindow': 'Open link in new window',

+    'removeLink': 'Remove Link',

+    'ol': 'Ordered List',

+    'ul': 'Unordered List',

+    'strikethrough': 'Strikethrough',

+    'table': 'Table',

+    'deleteRow': 'Delete Row',

+    'insertRowAbove': 'Insert Row Above',

+    'insertRowBelow': 'Insert Row Below',

+    'deleteColumn': 'Delete Column',

+    'insertColumnLeft': 'Insert Column Left',

+    'insertColumnRight': 'Insert Column Right',

+    'deleteTable': 'Delete Table',

+    'title': 'Title',

+    'normalText': 'Text',

+    'underline': 'Underline',

+    'alignment': 'Alignment',

+    'alignCenter': 'Align Center',

+    'alignLeft': 'Align Left',

+    'alignRight': 'Align Right',

+    'selectLanguage': 'Select Language',

+    'fontScale': 'Font Size',

+    'fontScaleXLarge': 'X Large Size',

+    'fontScaleLarge': 'Large Size',

+    'fontScaleNormal': 'Normal Size',

+    'fontScaleSmall': 'Small Size',

+    'fontScaleXSmall': 'X Small Size'

+  }

+};

+

+Button = (function(superClass) {

+  extend(Button, superClass);

+

+  Button.prototype._tpl = {

+    item: '<li><a tabindex="-1" unselectable="on" class="toolbar-item" href="javascript:;"><span></span></a></li>',

+    menuWrapper: '<div class="toolbar-menu"></div>',

+    menuItem: '<li><a tabindex="-1" unselectable="on" class="menu-item" href="javascript:;"><span></span></a></li>',

+    separator: '<li><span class="separator"></span></li>'

+  };

+

+  Button.prototype.name = '';

+

+  Button.prototype.icon = '';

+

+  Button.prototype.title = '';

+

+  Button.prototype.text = '';

+

+  Button.prototype.htmlTag = '';

+

+  Button.prototype.disableTag = '';

+

+  Button.prototype.menu = false;

+

+  Button.prototype.active = false;

+

+  Button.prototype.disabled = false;

+

+  Button.prototype.needFocus = true;

+

+  Button.prototype.shortcut = null;

+

+  function Button(opts) {

+    this.editor = opts.editor;

+    this.title = this._t(this.name);

+    Button.__super__.constructor.call(this, opts);

+  }

+

+  Button.prototype._init = function() {

+    var k, len, ref, tag;

+    this.render();

+    this.el.on('mousedown', (function(_this) {

+      return function(e) {

+        var exceed, noFocus, param;

+        e.preventDefault();

+        noFocus = _this.needFocus && !_this.editor.inputManager.focused;

+        if (_this.el.hasClass('disabled') || noFocus) {

+          return false;

+        }

+        if (_this.menu) {

+          _this.wrapper.toggleClass('menu-on').siblings('li').removeClass('menu-on');

+          if (_this.wrapper.is('.menu-on')) {

+            exceed = _this.menuWrapper.offset().left + _this.menuWrapper.outerWidth() + 5 - _this.editor.wrapper.offset().left - _this.editor.wrapper.outerWidth();

+            if (exceed > 0) {

+              _this.menuWrapper.css({

+                'left': 'auto',

+                'right': 0

+              });

+            }

+            _this.trigger('menuexpand');

+          }

+          return false;

+        }

+        param = _this.el.data('param');

+        _this.command(param);

+        return false;

+      };

+    })(this));

+    this.wrapper.on('click', 'a.menu-item', (function(_this) {

+      return function(e) {

+        var btn, noFocus, param;

+        e.preventDefault();

+        btn = $(e.currentTarget);

+        _this.wrapper.removeClass('menu-on');

+        noFocus = _this.needFocus && !_this.editor.inputManager.focused;

+        if (btn.hasClass('disabled') || noFocus) {

+          return false;

+        }

+        _this.editor.toolbar.wrapper.removeClass('menu-on');

+        param = btn.data('param');

+        _this.command(param);

+        return false;

+      };

+    })(this));

+    this.wrapper.on('mousedown', 'a.menu-item', function(e) {

+      return false;

+    });

+    this.editor.on('blur', (function(_this) {

+      return function() {

+        var editorActive;

+        editorActive = _this.editor.body.is(':visible') && _this.editor.body.is('[contenteditable]');

+        if (!(editorActive && !_this.editor.clipboard.pasting)) {

+          return;

+        }

+        _this.setActive(false);

+        return _this.setDisabled(false);

+      };

+    })(this));

+    if (this.shortcut != null) {

+      this.editor.hotkeys.add(this.shortcut, (function(_this) {

+        return function(e) {

+          _this.el.mousedown();

+          return false;

+        };

+      })(this));

+    }

+    ref = this.htmlTag.split(',');

+    for (k = 0, len = ref.length; k < len; k++) {

+      tag = ref[k];

+      tag = $.trim(tag);

+      if (tag && $.inArray(tag, this.editor.formatter._allowedTags) < 0) {

+        this.editor.formatter._allowedTags.push(tag);

+      }

+    }

+    return this.editor.on('selectionchanged', (function(_this) {

+      return function(e) {

+        if (_this.editor.inputManager.focused) {

+          return _this._status();

+        }

+      };

+    })(this));

+  };

+

+  Button.prototype.iconClassOf = function(icon) {

+    if (icon) {

+      return "simditor-icon simditor-icon-" + icon;

+    } else {

+      return '';

+    }

+  };

+

+  Button.prototype.setIcon = function(icon) {

+    return this.el.find('span').removeClass().addClass(this.iconClassOf(icon)).text(this.text);

+  };

+

+  Button.prototype.render = function() {

+    this.wrapper = $(this._tpl.item).appendTo(this.editor.toolbar.list);

+    this.el = this.wrapper.find('a.toolbar-item');

+    this.el.attr('title', this.title).addClass("toolbar-item-" + this.name).data('button', this);

+    this.setIcon(this.icon);

+    if (!this.menu) {

+      return;

+    }

+    this.menuWrapper = $(this._tpl.menuWrapper).appendTo(this.wrapper);

+    this.menuWrapper.addClass("toolbar-menu-" + this.name);

+    return this.renderMenu();

+  };

+

+  Button.prototype.renderMenu = function() {

+    var $menuBtnEl, $menuItemEl, k, len, menuItem, ref, ref1, results;

+    if (!$.isArray(this.menu)) {

+      return;

+    }

+    this.menuEl = $('<ul/>').appendTo(this.menuWrapper);

+    ref = this.menu;

+    results = [];

+    for (k = 0, len = ref.length; k < len; k++) {

+      menuItem = ref[k];

+      if (menuItem === '|') {

+        $(this._tpl.separator).appendTo(this.menuEl);

+        continue;

+      }

+      $menuItemEl = $(this._tpl.menuItem).appendTo(this.menuEl);

+      $menuBtnEl = $menuItemEl.find('a.menu-item').attr({

+        'title': (ref1 = menuItem.title) != null ? ref1 : menuItem.text,

+        'data-param': menuItem.param

+      }).addClass('menu-item-' + menuItem.name);

+      if (menuItem.icon) {

+        results.push($menuBtnEl.find('span').addClass(this.iconClassOf(menuItem.icon)));

+      } else {

+        results.push($menuBtnEl.find('span').text(menuItem.text));

+      }

+    }

+    return results;

+  };

+

+  Button.prototype.setActive = function(active) {

+    if (active === this.active) {

+      return;

+    }

+    this.active = active;

+    return this.el.toggleClass('active', this.active);

+  };

+

+  Button.prototype.setDisabled = function(disabled) {

+    if (disabled === this.disabled) {

+      return;

+    }

+    this.disabled = disabled;

+    return this.el.toggleClass('disabled', this.disabled);

+  };

+

+  Button.prototype._disableStatus = function() {

+    var disabled, endNodes, startNodes;

+    startNodes = this.editor.selection.startNodes();

+    endNodes = this.editor.selection.endNodes();

+    disabled = startNodes.filter(this.disableTag).length > 0 || endNodes.filter(this.disableTag).length > 0;

+    this.setDisabled(disabled);

+    if (this.disabled) {

+      this.setActive(false);

+    }

+    return this.disabled;

+  };

+

+  Button.prototype._activeStatus = function() {

+    var active, endNode, endNodes, startNode, startNodes;

+    startNodes = this.editor.selection.startNodes();

+    endNodes = this.editor.selection.endNodes();

+    startNode = startNodes.filter(this.htmlTag);

+    endNode = endNodes.filter(this.htmlTag);

+    active = startNode.length > 0 && endNode.length > 0 && startNode.is(endNode);

+    this.node = active ? startNode : null;

+    this.setActive(active);

+    return this.active;

+  };

+

+  Button.prototype._status = function() {

+    this._disableStatus();

+    if (this.disabled) {

+      return;

+    }

+    return this._activeStatus();

+  };

+

+  Button.prototype.command = function(param) {};

+

+  Button.prototype._t = function() {

+    var args, ref, result;

+    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];

+    result = Button.__super__._t.apply(this, args);

+    if (!result) {

+      result = (ref = this.editor)._t.apply(ref, args);

+    }

+    return result;

+  };

+

+  return Button;

+

+})(SimpleModule);

+

+Simditor.Button = Button;

+

+Popover = (function(superClass) {

+  extend(Popover, superClass);

+

+  Popover.prototype.offset = {

+    top: 4,

+    left: 0

+  };

+

+  Popover.prototype.target = null;

+

+  Popover.prototype.active = false;

+

+  function Popover(opts) {

+    this.button = opts.button;

+    this.editor = opts.button.editor;

+    Popover.__super__.constructor.call(this, opts);

+  }

+

+  Popover.prototype._init = function() {

+    this.el = $('<div class="simditor-popover"></div>').appendTo(this.editor.el).data('popover', this);

+    this.render();

+    this.el.on('mouseenter', (function(_this) {

+      return function(e) {

+        return _this.el.addClass('hover');

+      };

+    })(this));

+    return this.el.on('mouseleave', (function(_this) {

+      return function(e) {

+        return _this.el.removeClass('hover');

+      };

+    })(this));

+  };

+

+  Popover.prototype.render = function() {};

+

+  Popover.prototype._initLabelWidth = function() {

+    var $fields;

+    $fields = this.el.find('.settings-field');

+    if (!($fields.length > 0)) {

+      return;

+    }

+    this._labelWidth = 0;

+    $fields.each((function(_this) {

+      return function(i, field) {

+        var $field, $label;

+        $field = $(field);

+        $label = $field.find('label');

+        if (!($label.length > 0)) {

+          return;

+        }

+        return _this._labelWidth = Math.max(_this._labelWidth, $label.width());

+      };

+    })(this));

+    return $fields.find('label').width(this._labelWidth);

+  };

+

+  Popover.prototype.show = function($target, position) {

+    if (position == null) {

+      position = 'bottom';

+    }

+    if ($target == null) {

+      return;

+    }

+    this.el.siblings('.simditor-popover').each(function(i, popover) {

+      popover = $(popover).data('popover');

+      if (popover.active) {

+        return popover.hide();

+      }

+    });

+    if (this.active && this.target) {

+      this.target.removeClass('selected');

+    }

+    this.target = $target.addClass('selected');

+    if (this.active) {

+      this.refresh(position);

+      return this.trigger('popovershow');

+    } else {

+      this.active = true;

+      this.el.css({

+        left: -9999

+      }).show();

+      if (!this._labelWidth) {

+        this._initLabelWidth();

+      }

+      this.editor.util.reflow();

+      this.refresh(position);

+      return this.trigger('popovershow');

+    }

+  };

+

+  Popover.prototype.hide = function() {

+    if (!this.active) {

+      return;

+    }

+    if (this.target) {

+      this.target.removeClass('selected');

+    }

+    this.target = null;

+    this.active = false;

+    this.el.hide();

+    return this.trigger('popoverhide');

+  };

+

+  Popover.prototype.refresh = function(position) {

+    var editorOffset, left, maxLeft, targetH, targetOffset, top;

+    if (position == null) {

+      position = 'bottom';

+    }

+    if (!this.active) {

+      return;

+    }

+    editorOffset = this.editor.el.offset();

+    targetOffset = this.target.offset();

+    targetH = this.target.outerHeight();

+    if (position === 'bottom') {

+      top = targetOffset.top - editorOffset.top + targetH;

+    } else if (position === 'top') {

+      top = targetOffset.top - editorOffset.top - this.el.height();

+    }

+    maxLeft = this.editor.wrapper.width() - this.el.outerWidth() - 10;

+    left = Math.min(targetOffset.left - editorOffset.left, maxLeft);

+    return this.el.css({

+      top: top + this.offset.top,

+      left: left + this.offset.left

+    });

+  };

+

+  Popover.prototype.destroy = function() {

+    this.target = null;

+    this.active = false;

+    this.editor.off('.linkpopover');

+    return this.el.remove();

+  };

+

+  Popover.prototype._t = function() {

+    var args, ref, result;

+    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];

+    result = Popover.__super__._t.apply(this, args);

+    if (!result) {

+      result = (ref = this.button)._t.apply(ref, args);

+    }

+    return result;

+  };

+

+  return Popover;

+

+})(SimpleModule);

+

+Simditor.Popover = Popover;

+

+TitleButton = (function(superClass) {

+  extend(TitleButton, superClass);

+

+  function TitleButton() {

+    return TitleButton.__super__.constructor.apply(this, arguments);

+  }

+

+  TitleButton.prototype.name = 'title';

+

+  TitleButton.prototype.htmlTag = 'h1, h2, h3, h4, h5';

+

+  TitleButton.prototype.disableTag = 'pre, table';

+

+  TitleButton.prototype._init = function() {

+    this.menu = [

+      {

+        name: 'normal',

+        text: this._t('normalText'),

+        param: 'p'

+      }, '|', {

+        name: 'h1',

+        text: this._t('title') + ' 1',

+        param: 'h1'

+      }, {

+        name: 'h2',

+        text: this._t('title') + ' 2',

+        param: 'h2'

+      }, {

+        name: 'h3',

+        text: this._t('title') + ' 3',

+        param: 'h3'

+      }, {

+        name: 'h4',

+        text: this._t('title') + ' 4',

+        param: 'h4'

+      }, {

+        name: 'h5',

+        text: this._t('title') + ' 5',

+        param: 'h5'

+      }

+    ];

+    return TitleButton.__super__._init.call(this);

+  };

+

+  TitleButton.prototype.setActive = function(active, param) {

+    TitleButton.__super__.setActive.call(this, active);

+    if (active) {

+      param || (param = this.node[0].tagName.toLowerCase());

+    }

+    this.el.removeClass('active-p active-h1 active-h2 active-h3 active-h4 active-h5');

+    if (active) {

+      return this.el.addClass('active active-' + param);

+    }

+  };

+

+  TitleButton.prototype.command = function(param) {

+    var $rootNodes;

+    $rootNodes = this.editor.selection.rootNodes();

+    this.editor.selection.save();

+    $rootNodes.each((function(_this) {

+      return function(i, node) {

+        var $node;

+        $node = $(node);

+        if ($node.is('blockquote') || $node.is(param) || $node.is(_this.disableTag) || _this.editor.util.isDecoratedNode($node)) {

+          return;

+        }

+        return $('<' + param + '/>').append($node.contents()).replaceAll($node);

+      };

+    })(this));

+    this.editor.selection.restore();

+    return this.editor.trigger('valuechanged');

+  };

+

+  return TitleButton;

+

+})(Button);

+

+Simditor.Toolbar.addButton(TitleButton);

+

+FontScaleButton = (function(superClass) {

+  extend(FontScaleButton, superClass);

+

+  function FontScaleButton() {

+    return FontScaleButton.__super__.constructor.apply(this, arguments);

+  }

+

+  FontScaleButton.prototype.name = 'fontScale';

+

+  FontScaleButton.prototype.icon = 'font';

+

+  FontScaleButton.prototype.disableTag = 'pre';

+

+  FontScaleButton.prototype.htmlTag = 'span';

+

+  FontScaleButton.prototype.sizeMap = {

+    'x-large': '1.5em',

+    'large': '1.25em',

+    'small': '.75em',

+    'x-small': '.5em'

+  };

+

+  FontScaleButton.prototype._init = function() {

+    this.menu = [

+      {

+        name: '150%',

+        text: this._t('fontScaleXLarge'),

+        param: '5'

+      }, {

+        name: '125%',

+        text: this._t('fontScaleLarge'),

+        param: '4'

+      }, {

+        name: '100%',

+        text: this._t('fontScaleNormal'),

+        param: '3'

+      }, {

+        name: '75%',

+        text: this._t('fontScaleSmall'),

+        param: '2'

+      }, {

+        name: '50%',

+        text: this._t('fontScaleXSmall'),

+        param: '1'

+      }

+    ];

+    return FontScaleButton.__super__._init.call(this);

+  };

+

+  FontScaleButton.prototype._activeStatus = function() {

+    var active, endNode, endNodes, range, startNode, startNodes;

+    range = this.editor.selection.range();

+    startNodes = this.editor.selection.startNodes();

+    endNodes = this.editor.selection.endNodes();

+    startNode = startNodes.filter('span[style*="font-size"]');

+    endNode = endNodes.filter('span[style*="font-size"]');

+    active = startNodes.length > 0 && endNodes.length > 0 && startNode.is(endNode);

+    this.setActive(active);

+    return this.active;

+  };

+

+  FontScaleButton.prototype.command = function(param) {

+    var $scales, containerNode, range;

+    range = this.editor.selection.range();

+    if (range.collapsed) {

+      return;

+    }

+    document.execCommand('styleWithCSS', false, true);

+    document.execCommand('fontSize', false, param);

+    document.execCommand('styleWithCSS', false, false);

+    this.editor.selection.reset();

+    this.editor.selection.range();

+    containerNode = this.editor.selection.containerNode();

+    if (containerNode[0].nodeType === Node.TEXT_NODE) {

+      $scales = containerNode.closest('span[style*="font-size"]');

+    } else {

+      $scales = containerNode.find('span[style*="font-size"]');

+    }

+    $scales.each((function(_this) {

+      return function(i, n) {

+        var $span, size;

+        $span = $(n);

+        size = n.style.fontSize;

+        if (/large|x-large|small|x-small/.test(size)) {

+          return $span.css('fontSize', _this.sizeMap[size]);

+        } else if (size === 'medium') {

+          return $span.replaceWith($span.contents());

+        }

+      };

+    })(this));

+    return this.editor.trigger('valuechanged');

+  };

+

+  return FontScaleButton;

+

+})(Button);

+

+Simditor.Toolbar.addButton(FontScaleButton);

+

+BoldButton = (function(superClass) {

+  extend(BoldButton, superClass);

+

+  function BoldButton() {

+    return BoldButton.__super__.constructor.apply(this, arguments);

+  }

+

+  BoldButton.prototype.name = 'bold';

+

+  BoldButton.prototype.icon = 'bold';

+

+  BoldButton.prototype.htmlTag = 'b, strong';

+

+  BoldButton.prototype.disableTag = 'pre';

+

+  BoldButton.prototype.shortcut = 'cmd+b';

+

+  BoldButton.prototype._init = function() {

+    if (this.editor.util.os.mac) {

+      this.title = this.title + ' ( Cmd + b )';

+    } else {

+      this.title = this.title + ' ( Ctrl + b )';

+      this.shortcut = 'ctrl+b';

+    }

+    return BoldButton.__super__._init.call(this);

+  };

+

+  BoldButton.prototype._activeStatus = function() {

+    var active;

+    active = document.queryCommandState('bold') === true;

+    this.setActive(active);

+    return this.active;

+  };

+

+  BoldButton.prototype.command = function() {

+    document.execCommand('bold');

+    if (!this.editor.util.support.oninput) {

+      this.editor.trigger('valuechanged');

+    }

+    return $(document).trigger('selectionchange');

+  };

+

+  return BoldButton;

+

+})(Button);

+

+Simditor.Toolbar.addButton(BoldButton);

+

+ItalicButton = (function(superClass) {

+  extend(ItalicButton, superClass);

+

+  function ItalicButton() {

+    return ItalicButton.__super__.constructor.apply(this, arguments);

+  }

+

+  ItalicButton.prototype.name = 'italic';

+

+  ItalicButton.prototype.icon = 'italic';

+

+  ItalicButton.prototype.htmlTag = 'i';

+

+  ItalicButton.prototype.disableTag = 'pre';

+

+  ItalicButton.prototype.shortcut = 'cmd+i';

+

+  ItalicButton.prototype._init = function() {

+    if (this.editor.util.os.mac) {

+      this.title = this.title + " ( Cmd + i )";

+    } else {

+      this.title = this.title + " ( Ctrl + i )";

+      this.shortcut = 'ctrl+i';

+    }

+    return ItalicButton.__super__._init.call(this);

+  };

+

+  ItalicButton.prototype._activeStatus = function() {

+    var active;

+    active = document.queryCommandState('italic') === true;

+    this.setActive(active);

+    return this.active;

+  };

+

+  ItalicButton.prototype.command = function() {

+    document.execCommand('italic');

+    if (!this.editor.util.support.oninput) {

+      this.editor.trigger('valuechanged');

+    }

+    return $(document).trigger('selectionchange');

+  };

+

+  return ItalicButton;

+

+})(Button);

+

+Simditor.Toolbar.addButton(ItalicButton);

+

+UnderlineButton = (function(superClass) {

+  extend(UnderlineButton, superClass);

+

+  function UnderlineButton() {

+    return UnderlineButton.__super__.constructor.apply(this, arguments);

+  }

+

+  UnderlineButton.prototype.name = 'underline';

+

+  UnderlineButton.prototype.icon = 'underline';

+

+  UnderlineButton.prototype.htmlTag = 'u';

+

+  UnderlineButton.prototype.disableTag = 'pre';

+

+  UnderlineButton.prototype.shortcut = 'cmd+u';

+

+  UnderlineButton.prototype.render = function() {

+    if (this.editor.util.os.mac) {

+      this.title = this.title + ' ( Cmd + u )';

+    } else {

+      this.title = this.title + ' ( Ctrl + u )';

+      this.shortcut = 'ctrl+u';

+    }

+    return UnderlineButton.__super__.render.call(this);

+  };

+

+  UnderlineButton.prototype._activeStatus = function() {

+    var active;

+    active = document.queryCommandState('underline') === true;

+    this.setActive(active);

+    return this.active;

+  };

+

+  UnderlineButton.prototype.command = function() {

+    document.execCommand('underline');

+    if (!this.editor.util.support.oninput) {

+      this.editor.trigger('valuechanged');

+    }

+    return $(document).trigger('selectionchange');

+  };

+

+  return UnderlineButton;

+

+})(Button);

+

+Simditor.Toolbar.addButton(UnderlineButton);

+

+ColorButton = (function(superClass) {

+  extend(ColorButton, superClass);

+

+  function ColorButton() {

+    return ColorButton.__super__.constructor.apply(this, arguments);

+  }

+

+  ColorButton.prototype.name = 'color';

+

+  ColorButton.prototype.icon = 'tint';

+

+  ColorButton.prototype.disableTag = 'pre';

+

+  ColorButton.prototype.menu = true;

+

+  ColorButton.prototype.render = function() {

+    var args;

+    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];

+    return ColorButton.__super__.render.apply(this, args);

+  };

+

+  ColorButton.prototype.renderMenu = function() {

+    $('<ul class="color-list">\n  <li><a href="javascript:;" class="font-color font-color-1"></a></li>\n  <li><a href="javascript:;" class="font-color font-color-2"></a></li>\n  <li><a href="javascript:;" class="font-color font-color-3"></a></li>\n  <li><a href="javascript:;" class="font-color font-color-4"></a></li>\n  <li><a href="javascript:;" class="font-color font-color-5"></a></li>\n  <li><a href="javascript:;" class="font-color font-color-6"></a></li>\n  <li><a href="javascript:;" class="font-color font-color-7"></a></li>\n  <li><a href="javascript:;" class="font-color font-color-default"></a></li>\n</ul>').appendTo(this.menuWrapper);

+    this.menuWrapper.on('mousedown', '.color-list', function(e) {

+      return false;

+    });

+    return this.menuWrapper.on('click', '.font-color', (function(_this) {

+      return function(e) {

+        var $link, $p, hex, range, rgb, textNode;

+        _this.wrapper.removeClass('menu-on');

+        $link = $(e.currentTarget);

+        if ($link.hasClass('font-color-default')) {

+          $p = _this.editor.body.find('p, li');

+          if (!($p.length > 0)) {

+            return;

+          }

+          rgb = window.getComputedStyle($p[0], null).getPropertyValue('color');

+          hex = _this._convertRgbToHex(rgb);

+        } else {

+          rgb = window.getComputedStyle($link[0], null).getPropertyValue('background-color');

+          hex = _this._convertRgbToHex(rgb);

+        }

+        if (!hex) {

+          return;

+        }

+        range = _this.editor.selection.range();

+        if (!$link.hasClass('font-color-default') && range.collapsed) {

+          textNode = document.createTextNode(_this._t('coloredText'));

+          range.insertNode(textNode);

+          range.selectNodeContents(textNode);

+          _this.editor.selection.range(range);

+        }

+        document.execCommand('styleWithCSS', false, true);

+        document.execCommand('foreColor', false, hex);

+        document.execCommand('styleWithCSS', false, false);

+        if (!_this.editor.util.support.oninput) {

+          return _this.editor.trigger('valuechanged');

+        }

+      };

+    })(this));

+  };

+

+  ColorButton.prototype._convertRgbToHex = function(rgb) {

+    var match, re, rgbToHex;

+    re = /rgb\((\d+),\s?(\d+),\s?(\d+)\)/g;

+    match = re.exec(rgb);

+    if (!match) {

+      return '';

+    }

+    rgbToHex = function(r, g, b) {

+      var componentToHex;

+      componentToHex = function(c) {

+        var hex;

+        hex = c.toString(16);

+        if (hex.length === 1) {

+          return '0' + hex;

+        } else {

+          return hex;

+        }

+      };

+      return "#" + componentToHex(r) + componentToHex(g) + componentToHex(b);

+    };

+    return rgbToHex(match[1] * 1, match[2] * 1, match[3] * 1);

+  };

+

+  return ColorButton;

+

+})(Button);

+

+Simditor.Toolbar.addButton(ColorButton);

+

+ListButton = (function(superClass) {

+  extend(ListButton, superClass);

+

+  function ListButton() {

+    return ListButton.__super__.constructor.apply(this, arguments);

+  }

+

+  ListButton.prototype.type = '';

+

+  ListButton.prototype.disableTag = 'pre, table';

+

+  ListButton.prototype.command = function(param) {

+    var $list, $rootNodes, anotherType;

+    $rootNodes = this.editor.selection.blockNodes();

+    anotherType = this.type === 'ul' ? 'ol' : 'ul';

+    this.editor.selection.save();

+    $list = null;

+    $rootNodes.each((function(_this) {

+      return function(i, node) {

+        var $node;

+        $node = $(node);

+        if ($node.is('blockquote, li') || $node.is(_this.disableTag) || _this.editor.util.isDecoratedNode($node) || !$.contains(document, node)) {

+          return;

+        }

+        if ($node.is(_this.type)) {

+          $node.children('li').each(function(i, li) {

+            var $childList, $li;

+            $li = $(li);

+            $childList = $li.children('ul, ol').insertAfter($node);

+            return $('<p/>').append($(li).html() || _this.editor.util.phBr).insertBefore($node);

+          });

+          return $node.remove();

+        } else if ($node.is(anotherType)) {

+          return $('<' + _this.type + '/>').append($node.contents()).replaceAll($node);

+        } else if ($list && $node.prev().is($list)) {

+          $('<li/>').append($node.html() || _this.editor.util.phBr).appendTo($list);

+          return $node.remove();

+        } else {

+          $list = $("<" + _this.type + "><li></li></" + _this.type + ">");

+          $list.find('li').append($node.html() || _this.editor.util.phBr);

+          return $list.replaceAll($node);

+        }

+      };

+    })(this));

+    this.editor.selection.restore();

+    return this.editor.trigger('valuechanged');

+  };

+

+  return ListButton;

+

+})(Button);

+

+OrderListButton = (function(superClass) {

+  extend(OrderListButton, superClass);

+

+  function OrderListButton() {

+    return OrderListButton.__super__.constructor.apply(this, arguments);

+  }

+

+  OrderListButton.prototype.type = 'ol';

+

+  OrderListButton.prototype.name = 'ol';

+

+  OrderListButton.prototype.icon = 'list-ol';

+

+  OrderListButton.prototype.htmlTag = 'ol';

+

+  OrderListButton.prototype.shortcut = 'cmd+/';

+

+  OrderListButton.prototype._init = function() {

+    if (this.editor.util.os.mac) {

+      this.title = this.title + ' ( Cmd + / )';

+    } else {

+      this.title = this.title + ' ( ctrl + / )';

+      this.shortcut = 'ctrl+/';

+    }

+    return OrderListButton.__super__._init.call(this);

+  };

+

+  return OrderListButton;

+

+})(ListButton);

+

+UnorderListButton = (function(superClass) {

+  extend(UnorderListButton, superClass);

+

+  function UnorderListButton() {

+    return UnorderListButton.__super__.constructor.apply(this, arguments);

+  }

+

+  UnorderListButton.prototype.type = 'ul';

+

+  UnorderListButton.prototype.name = 'ul';

+

+  UnorderListButton.prototype.icon = 'list-ul';

+

+  UnorderListButton.prototype.htmlTag = 'ul';

+

+  UnorderListButton.prototype.shortcut = 'cmd+.';

+

+  UnorderListButton.prototype._init = function() {

+    if (this.editor.util.os.mac) {

+      this.title = this.title + ' ( Cmd + . )';

+    } else {

+      this.title = this.title + ' ( Ctrl + . )';

+      this.shortcut = 'ctrl+.';

+    }

+    return UnorderListButton.__super__._init.call(this);

+  };

+

+  return UnorderListButton;

+

+})(ListButton);

+

+Simditor.Toolbar.addButton(OrderListButton);

+

+Simditor.Toolbar.addButton(UnorderListButton);

+

+BlockquoteButton = (function(superClass) {

+  extend(BlockquoteButton, superClass);

+

+  function BlockquoteButton() {

+    return BlockquoteButton.__super__.constructor.apply(this, arguments);

+  }

+

+  BlockquoteButton.prototype.name = 'blockquote';

+

+  BlockquoteButton.prototype.icon = 'quote-left';

+

+  BlockquoteButton.prototype.htmlTag = 'blockquote';

+

+  BlockquoteButton.prototype.disableTag = 'pre, table';

+

+  BlockquoteButton.prototype.command = function() {

+    var $rootNodes, clearCache, nodeCache;

+    $rootNodes = this.editor.selection.rootNodes();

+    $rootNodes = $rootNodes.filter(function(i, node) {

+      return !$(node).parent().is('blockquote');

+    });

+    this.editor.selection.save();

+    nodeCache = [];

+    clearCache = (function(_this) {

+      return function() {

+        if (nodeCache.length > 0) {

+          $("<" + _this.htmlTag + "/>").insertBefore(nodeCache[0]).append(nodeCache);

+          return nodeCache.length = 0;

+        }

+      };

+    })(this);

+    $rootNodes.each((function(_this) {

+      return function(i, node) {

+        var $node;

+        $node = $(node);

+        if (!$node.parent().is(_this.editor.body)) {

+          return;

+        }

+        if ($node.is(_this.htmlTag)) {

+          clearCache();

+          return $node.children().unwrap();

+        } else if ($node.is(_this.disableTag) || _this.editor.util.isDecoratedNode($node)) {

+          return clearCache();

+        } else {

+          return nodeCache.push(node);

+        }

+      };

+    })(this));

+    clearCache();

+    this.editor.selection.restore();

+    return this.editor.trigger('valuechanged');

+  };

+

+  return BlockquoteButton;

+

+})(Button);

+

+Simditor.Toolbar.addButton(BlockquoteButton);

+

+CodeButton = (function(superClass) {

+  extend(CodeButton, superClass);

+

+  function CodeButton() {

+    return CodeButton.__super__.constructor.apply(this, arguments);

+  }

+

+  CodeButton.prototype.name = 'code';

+

+  CodeButton.prototype.icon = 'code';

+

+  CodeButton.prototype.htmlTag = 'pre';

+

+  CodeButton.prototype.disableTag = 'ul, ol, table';

+

+  CodeButton.prototype._init = function() {

+    CodeButton.__super__._init.call(this);

+    this.editor.on('decorate', (function(_this) {

+      return function(e, $el) {

+        return $el.find('pre').each(function(i, pre) {

+          return _this.decorate($(pre));

+        });

+      };

+    })(this));

+    return this.editor.on('undecorate', (function(_this) {

+      return function(e, $el) {

+        return $el.find('pre').each(function(i, pre) {

+          return _this.undecorate($(pre));

+        });

+      };

+    })(this));

+  };

+

+  CodeButton.prototype.render = function() {

+    var args;

+    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];

+    CodeButton.__super__.render.apply(this, args);

+    return this.popover = new CodePopover({

+      button: this

+    });

+  };

+

+  CodeButton.prototype._checkMode = function() {

+    var $blockNodes, range;

+    range = this.editor.selection.range();

+    if (($blockNodes = $(range.cloneContents()).find(this.editor.util.blockNodes.join(','))) > 0 || (range.collapsed && this.editor.selection.startNodes().filter('code').length === 0)) {

+      this.inlineMode = false;

+      return this.htmlTag = 'pre';

+    } else {

+      this.inlineMode = true;

+      return this.htmlTag = 'code';

+    }

+  };

+

+  CodeButton.prototype._status = function() {

+    this._checkMode();

+    CodeButton.__super__._status.call(this);

+    if (this.inlineMode) {

+      return;

+    }

+    if (this.active) {

+      return this.popover.show(this.node);

+    } else {

+      return this.popover.hide();

+    }

+  };

+

+  CodeButton.prototype.decorate = function($pre) {

+    var $code, lang, ref, ref1;

+    $code = $pre.find('> code');

+    if ($code.length > 0) {

+      lang = (ref = $code.attr('class')) != null ? (ref1 = ref.match(/lang-(\S+)/)) != null ? ref1[1] : void 0 : void 0;

+      $code.contents().unwrap();

+      if (lang) {

+        return $pre.attr('data-lang', lang);

+      }

+    }

+  };

+

+  CodeButton.prototype.undecorate = function($pre) {

+    var $code, lang;

+    lang = $pre.attr('data-lang');

+    $code = $('<code/>');

+    if (lang && lang !== -1) {

+      $code.addClass('lang-' + lang);

+    }

+    return $pre.wrapInner($code).removeAttr('data-lang');

+  };

+

+  CodeButton.prototype.command = function() {

+    if (this.inlineMode) {

+      return this._inlineCommand();

+    } else {

+      return this._blockCommand();

+    }

+  };

+

+  CodeButton.prototype._blockCommand = function() {

+    var $rootNodes, clearCache, nodeCache, resultNodes;

+    $rootNodes = this.editor.selection.rootNodes();

+    nodeCache = [];

+    resultNodes = [];

+    clearCache = (function(_this) {

+      return function() {

+        var $pre;

+        if (!(nodeCache.length > 0)) {

+          return;

+        }

+        $pre = $("<" + _this.htmlTag + "/>").insertBefore(nodeCache[0]).text(_this.editor.formatter.clearHtml(nodeCache));

+        resultNodes.push($pre[0]);

+        return nodeCache.length = 0;

+      };

+    })(this);

+    $rootNodes.each((function(_this) {

+      return function(i, node) {

+        var $node, $p;

+        $node = $(node);

+        if ($node.is(_this.htmlTag)) {

+          clearCache();

+          $p = $('<p/>').append($node.html().replace('\n', '<br/>')).replaceAll($node);

+          return resultNodes.push($p[0]);

+        } else if ($node.is(_this.disableTag) || _this.editor.util.isDecoratedNode($node) || $node.is('blockquote')) {

+          return clearCache();

+        } else {

+          return nodeCache.push(node);

+        }

+      };

+    })(this));

+    clearCache();

+    this.editor.selection.setRangeAtEndOf($(resultNodes).last());

+    return this.editor.trigger('valuechanged');

+  };

+

+  CodeButton.prototype._inlineCommand = function() {

+    var $code, $contents, range;

+    range = this.editor.selection.range();

+    if (this.active) {

+      range.selectNodeContents(this.node[0]);

+      this.editor.selection.save(range);

+      this.node.contents().unwrap();

+      this.editor.selection.restore();

+    } else {

+      $contents = $(range.extractContents());

+      $code = $("<" + this.htmlTag + "/>").append($contents.contents());

+      range.insertNode($code[0]);

+      range.selectNodeContents($code[0]);

+      this.editor.selection.range(range);

+    }

+    return this.editor.trigger('valuechanged');

+  };

+

+  return CodeButton;

+

+})(Button);

+

+CodePopover = (function(superClass) {

+  extend(CodePopover, superClass);

+

+  function CodePopover() {

+    return CodePopover.__super__.constructor.apply(this, arguments);

+  }

+

+  CodePopover.prototype.render = function() {

+    var $option, k, lang, len, ref;

+    this._tpl = "<div class=\"code-settings\">\n  <div class=\"settings-field\">\n    <select class=\"select-lang\">\n      <option value=\"-1\">" + (this._t('selectLanguage')) + "</option>\n    </select>\n  </div>\n</div>";

+    this.langs = this.editor.opts.codeLanguages || [

+      {

+        name: 'Bash',

+        value: 'bash'

+      }, {

+        name: 'C++',

+        value: 'c++'

+      }, {

+        name: 'C#',

+        value: 'cs'

+      }, {

+        name: 'CSS',

+        value: 'css'

+      }, {

+        name: 'Erlang',

+        value: 'erlang'

+      }, {

+        name: 'Less',

+        value: 'less'

+      }, {

+        name: 'Sass',

+        value: 'sass'

+      }, {

+        name: 'Diff',

+        value: 'diff'

+      }, {

+        name: 'CoffeeScript',

+        value: 'coffeescript'

+      }, {

+        name: 'HTML,XML',

+        value: 'html'

+      }, {

+        name: 'JSON',

+        value: 'json'

+      }, {

+        name: 'Java',

+        value: 'java'

+      }, {

+        name: 'JavaScript',

+        value: 'js'

+      }, {

+        name: 'Markdown',

+        value: 'markdown'

+      }, {

+        name: 'Objective C',

+        value: 'oc'

+      }, {

+        name: 'PHP',

+        value: 'php'

+      }, {

+        name: 'Perl',

+        value: 'parl'

+      }, {

+        name: 'Python',

+        value: 'python'

+      }, {

+        name: 'Ruby',

+        value: 'ruby'

+      }, {

+        name: 'SQL',

+        value: 'sql'

+      }

+    ];

+    this.el.addClass('code-popover').append(this._tpl);

+    this.selectEl = this.el.find('.select-lang');

+    ref = this.langs;

+    for (k = 0, len = ref.length; k < len; k++) {

+      lang = ref[k];

+      $option = $('<option/>', {

+        text: lang.name,

+        value: lang.value

+      }).appendTo(this.selectEl);

+    }

+    this.selectEl.on('change', (function(_this) {

+      return function(e) {

+        var selected;

+        _this.lang = _this.selectEl.val();

+        selected = _this.target.hasClass('selected');

+        _this.target.removeClass().removeAttr('data-lang');

+        if (_this.lang !== -1) {

+          _this.target.attr('data-lang', _this.lang);

+        }

+        if (selected) {

+          _this.target.addClass('selected');

+        }

+        return _this.editor.trigger('valuechanged');

+      };

+    })(this));

+    return this.editor.on('valuechanged', (function(_this) {

+      return function(e) {

+        if (_this.active) {

+          return _this.refresh();

+        }

+      };

+    })(this));

+  };

+

+  CodePopover.prototype.show = function() {

+    var args;

+    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];

+    CodePopover.__super__.show.apply(this, args);

+    this.lang = this.target.attr('data-lang');

+    if (this.lang != null) {

+      return this.selectEl.val(this.lang);

+    } else {

+      return this.selectEl.val(-1);

+    }

+  };

+

+  return CodePopover;

+

+})(Popover);

+

+Simditor.Toolbar.addButton(CodeButton);

+

+LinkButton = (function(superClass) {

+  extend(LinkButton, superClass);

+

+  function LinkButton() {

+    return LinkButton.__super__.constructor.apply(this, arguments);

+  }

+

+  LinkButton.prototype.name = 'link';

+

+  LinkButton.prototype.icon = 'link';

+

+  LinkButton.prototype.htmlTag = 'a';

+

+  LinkButton.prototype.disableTag = 'pre';

+

+  LinkButton.prototype.render = function() {

+    var args;

+    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];

+    LinkButton.__super__.render.apply(this, args);

+    return this.popover = new LinkPopover({

+      button: this

+    });

+  };

+

+  LinkButton.prototype._status = function() {

+    LinkButton.__super__._status.call(this);

+    if (this.active && !this.editor.selection.rangeAtEndOf(this.node)) {

+      return this.popover.show(this.node);

+    } else {

+      return this.popover.hide();

+    }

+  };

+

+  LinkButton.prototype.command = function() {

+    var $contents, $link, $newBlock, linkText, range, txtNode;

+    range = this.editor.selection.range();

+    if (this.active) {

+      txtNode = document.createTextNode(this.node.text());

+      this.node.replaceWith(txtNode);

+      range.selectNode(txtNode);

+    } else {

+      $contents = $(range.extractContents());

+      linkText = this.editor.formatter.clearHtml($contents.contents(), false);

+      $link = $('<a/>', {

+        href: 'http://www.example.com',

+        target: '_blank',

+        text: linkText || this._t('linkText')

+      });

+      if (this.editor.selection.blockNodes().length > 0) {

+        range.insertNode($link[0]);

+      } else {

+        $newBlock = $('<p/>').append($link);

+        range.insertNode($newBlock[0]);

+      }

+      range.selectNodeContents($link[0]);

+      this.popover.one('popovershow', (function(_this) {

+        return function() {

+          if (linkText) {

+            _this.popover.urlEl.focus();

+            return _this.popover.urlEl[0].select();

+          } else {

+            _this.popover.textEl.focus();

+            return _this.popover.textEl[0].select();

+          }

+        };

+      })(this));

+    }

+    this.editor.selection.range(range);

+    return this.editor.trigger('valuechanged');

+  };

+

+  return LinkButton;

+

+})(Button);

+

+LinkPopover = (function(superClass) {

+  extend(LinkPopover, superClass);

+

+  function LinkPopover() {

+    return LinkPopover.__super__.constructor.apply(this, arguments);

+  }

+

+  LinkPopover.prototype.render = function() {

+    var tpl;

+    tpl = "<div class=\"link-settings\">\n  <div class=\"settings-field\">\n    <label>" + (this._t('linkText')) + "</label>\n    <input class=\"link-text\" type=\"text\"/>\n    <a class=\"btn-unlink\" href=\"javascript:;\" title=\"" + (this._t('removeLink')) + "\"\n      tabindex=\"-1\">\n      <span class=\"simditor-icon simditor-icon-unlink\"></span>\n    </a>\n  </div>\n  <div class=\"settings-field\">\n    <label>" + (this._t('linkUrl')) + "</label>\n    <input class=\"link-url\" type=\"text\"/>\n  </div>\n  <div class=\"settings-field\">\n    <label>" + (this._t('linkTarget')) + "</label>\n    <select class=\"link-target\">\n      <option value=\"_blank\">" + (this._t('openLinkInNewWindow')) + " (_blank)</option>\n      <option value=\"_self\">" + (this._t('openLinkInCurrentWindow')) + " (_self)</option>\n    </select>\n  </div>\n</div>";

+    this.el.addClass('link-popover').append(tpl);

+    this.textEl = this.el.find('.link-text');

+    this.urlEl = this.el.find('.link-url');

+    this.unlinkEl = this.el.find('.btn-unlink');

+    this.selectTarget = this.el.find('.link-target');

+    this.textEl.on('keyup', (function(_this) {

+      return function(e) {

+        if (e.which === 13) {

+          return;

+        }

+        _this.target.text(_this.textEl.val());

+        return _this.editor.inputManager.throttledValueChanged();

+      };

+    })(this));

+    this.urlEl.on('keyup', (function(_this) {

+      return function(e) {

+        var val;

+        if (e.which === 13) {

+          return;

+        }

+        val = _this.urlEl.val();

+        if (!(/https?:\/\/|^\//ig.test(val) || !val)) {

+          val = 'http://' + val;

+        }

+        _this.target.attr('href', val);

+        return _this.editor.inputManager.throttledValueChanged();

+      };

+    })(this));

+    $([this.urlEl[0], this.textEl[0]]).on('keydown', (function(_this) {

+      return function(e) {

+        var range;

+        if (e.which === 13 || e.which === 27 || (!e.shiftKey && e.which === 9 && $(e.target).hasClass('link-url'))) {

+          e.preventDefault();

+          range = document.createRange();

+          _this.editor.selection.setRangeAfter(_this.target, range);

+          _this.hide();

+          return _this.editor.inputManager.throttledValueChanged();

+        }

+      };

+    })(this));

+    this.unlinkEl.on('click', (function(_this) {

+      return function(e) {

+        var range, txtNode;

+        txtNode = document.createTextNode(_this.target.text());

+        _this.target.replaceWith(txtNode);

+        _this.hide();

+        range = document.createRange();

+        _this.editor.selection.setRangeAfter(txtNode, range);

+        return _this.editor.inputManager.throttledValueChanged();

+      };

+    })(this));

+    return this.selectTarget.on('change', (function(_this) {

+      return function(e) {

+        _this.target.attr('target', _this.selectTarget.val());

+        return _this.editor.inputManager.throttledValueChanged();

+      };

+    })(this));

+  };

+

+  LinkPopover.prototype.show = function() {

+    var args;

+    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];

+    LinkPopover.__super__.show.apply(this, args);

+    this.textEl.val(this.target.text());

+    return this.urlEl.val(this.target.attr('href'));

+  };

+

+  return LinkPopover;

+

+})(Popover);

+

+Simditor.Toolbar.addButton(LinkButton);

+

+ImageButton = (function(superClass) {

+  extend(ImageButton, superClass);

+

+  function ImageButton() {

+    return ImageButton.__super__.constructor.apply(this, arguments);

+  }

+

+  ImageButton.prototype.name = 'image';

+

+  ImageButton.prototype.icon = 'picture-o';

+

+  ImageButton.prototype.htmlTag = 'img';

+

+  ImageButton.prototype.disableTag = 'pre, table';

+

+  ImageButton.prototype.defaultImage = '';

+

+  ImageButton.prototype.needFocus = false;

+

+  ImageButton.prototype._init = function() {

+    var item, k, len, ref;

+    if (this.editor.opts.imageButton) {

+      if (Array.isArray(this.editor.opts.imageButton)) {

+        this.menu = [];

+        ref = this.editor.opts.imageButton;

+        for (k = 0, len = ref.length; k < len; k++) {

+          item = ref[k];

+          this.menu.push({

+            name: item + '-image',

+            text: this._t(item + 'Image')

+          });

+        }

+      } else {

+        this.menu = false;

+      }

+    } else {

+      if (this.editor.uploader != null) {

+        this.menu = [

+          {

+            name: 'upload-image',

+            text: this._t('uploadImage')

+          }, {

+            name: 'external-image',

+            text: this._t('externalImage')

+          }

+        ];

+      } else {

+        this.menu = false;

+      }

+    }

+    this.defaultImage = this.editor.opts.defaultImage;

+    this.editor.body.on('click', 'img:not([data-non-image])', (function(_this) {

+      return function(e) {

+        var $img, range;

+        $img = $(e.currentTarget);

+        range = document.createRange();

+        range.selectNode($img[0]);

+        _this.editor.selection.range(range);

+        if (!_this.editor.util.support.onselectionchange) {

+          _this.editor.trigger('selectionchanged');

+        }

+        return false;

+      };

+    })(this));

+    this.editor.body.on('mouseup', 'img:not([data-non-image])', function(e) {

+      return false;

+    });

+    this.editor.on('selectionchanged.image', (function(_this) {

+      return function() {

+        var $contents, $img, range;

+        range = _this.editor.selection.range();

+        if (range == null) {

+          return;

+        }

+        $contents = $(range.cloneContents()).contents();

+        if ($contents.length === 1 && $contents.is('img:not([data-non-image])')) {

+          $img = $(range.startContainer).contents().eq(range.startOffset);

+          return _this.popover.show($img);

+        } else {

+          return _this.popover.hide();

+        }

+      };

+    })(this));