tiny-markdown-editor 0.1.4 → 0.1.6

package/lib/TinyMDE.js

@@ -1,122 +1,13 @@
 "use strict";
 
-require("core-js/modules/es.symbol");
-
-require("core-js/modules/es.symbol.description");
-
-require("core-js/modules/es.symbol.iterator");
-
-require("core-js/modules/es.symbol.replace");
-
-require("core-js/modules/es.array.concat");
-
-require("core-js/modules/es.array.from");
-
-require("core-js/modules/es.array.includes");
-
-require("core-js/modules/es.array.index-of");
-
-require("core-js/modules/es.array.iterator");
-
-require("core-js/modules/es.array.join");
-
-require("core-js/modules/es.array.reduce");
-
-require("core-js/modules/es.array.slice");
-
-require("core-js/modules/es.array.splice");
-
-require("core-js/modules/es.function.name");
-
-require("core-js/modules/es.map");
-
-require("core-js/modules/es.object.assign");
-
-require("core-js/modules/es.object.get-prototype-of");
-
-require("core-js/modules/es.object.keys");
-
-require("core-js/modules/es.object.to-string");
-
-require("core-js/modules/es.reflect.construct");
-
-require("core-js/modules/es.regexp.constructor");
-
-require("core-js/modules/es.regexp.exec");
-
-require("core-js/modules/es.regexp.to-string");
-
-require("core-js/modules/es.string.includes");
-
-require("core-js/modules/es.string.iterator");
-
-require("core-js/modules/es.string.match");
-
-require("core-js/modules/es.string.replace");
-
-require("core-js/modules/es.string.split");
-
-require("core-js/modules/es.string.trim");
-
-require("core-js/modules/es.weak-map");
-
-require("core-js/modules/web.dom-collections.iterator");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _grammar = require("./grammar");
-
-function _wrapRegExp(re, groups) { _wrapRegExp = function _wrapRegExp(re, groups) { return new BabelRegExp(re, undefined, groups); }; var _RegExp = _wrapNativeSuper(RegExp); var _super = RegExp.prototype; var _groups = new WeakMap(); function BabelRegExp(re, flags, groups) { var _this = _RegExp.call(this, re, flags); _groups.set(_this, groups || _groups.get(re)); return _this; } _inherits(BabelRegExp, _RegExp); BabelRegExp.prototype.exec = function (str) { var result = _super.exec.call(this, str); if (result) result.groups = buildGroups(result, this); return result; }; BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { if (typeof substitution === "string") { var groups = _groups.get(this); return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { return "$" + groups[name]; })); } else if (typeof substitution === "function") { var _this = this; return _super[Symbol.replace].call(this, str, function () { var args = []; args.push.apply(args, arguments); if (_typeof(args[args.length - 1]) !== "object") { args.push(buildGroups(args, _this)); } return substitution.apply(this, args); }); } else { return _super[Symbol.replace].call(this, str, substitution); } }; function buildGroups(result, re) { var g = _groups.get(re); return Object.keys(g).reduce(function (groups, name) { groups[name] = result[g[name]]; return groups; }, Object.create(null)); } return _wrapRegExp.apply(this, arguments); }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
-
-function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
-
-function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-var Editor = /*#__PURE__*/function () {
-  function Editor() {
-    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-
-    _classCallCheck(this, Editor);
-
+class Editor {
+  constructor() {
+    let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     this.e = null;
     this.textarea = null;
     this.lines = [];
@@ -131,1942 +22,1624 @@ var Editor = /*#__PURE__*/function () {
       change: [],
       selection: []
     };
-    var element = props.element;
+    let element = props.element;
     this.textarea = props.textarea;
-
     if (this.textarea && !this.textarea.tagName) {
       this.textarea = document.getElementById(this.textarea);
       if (!element) element = this.textarea;
     }
-
     if (element && !element.tagName) {
       element = document.getElementById(props.element);
     }
-
     if (!element) {
       element = document.getElementsByTagName('body')[0];
     }
-
     if (element.tagName == 'TEXTAREA') {
       this.textarea = element;
       element = this.textarea.parentNode;
     }
-
     if (this.textarea) {
       this.textarea.style.display = 'none';
     }
-
-    this.createEditorElement(element); // TODO Placeholder for empty content
-
+    this.createEditorElement(element);
+    // TODO Placeholder for empty content
     this.setContent(props.content || (this.textarea ? this.textarea.value : false) || '# Hello TinyMDE!\nEdit **here**');
   }
+
   /**
    * Creates the editor element inside the target element of the DOM tree
    * @param element The target element of the DOM tree
    */
+  createEditorElement(element) {
+    this.e = document.createElement('div');
+    this.e.className = 'TinyMDE';
+    this.e.contentEditable = true;
+    // The following is important for formatting purposes, but also since otherwise the browser replaces subsequent spaces with  &nbsp; &nbsp;
+    // That breaks a lot of stuff, so we do this here and not in CSS—therefore, you don't have to remember to but this in the CSS file
+    this.e.style.whiteSpace = 'pre-wrap';
+    // Avoid formatting (B / I / U) popping up on iOS
+    this.e.style.webkitUserModify = 'read-write-plaintext-only';
+    if (this.textarea && this.textarea.parentNode == element && this.textarea.nextSibling) {
+      element.insertBefore(this.e, this.textarea.nextSibling);
+    } else {
+      element.appendChild(this.e);
+    }
+    this.e.addEventListener("input", e => this.handleInputEvent(e));
+    // this.e.addEventListener("keydown", (e) => this.handleKeydownEvent(e));
+    document.addEventListener("selectionchange", e => this.handleSelectionChangeEvent(e));
+    this.e.addEventListener("paste", e => this.handlePaste(e));
+    // this.e.addEventListener('keydown', (e) => this.handleKeyDown(e));
+    this.lineElements = this.e.childNodes; // this will automatically update
+  }
 
+  /**
+   * Sets the editor content.
+   * @param {string} content The new Markdown content
+   */
+  setContent(content) {
+    // Delete any existing content
+    while (this.e.firstChild) {
+      this.e.removeChild(this.e.firstChild);
+    }
+    this.lines = content.split(/(?:\r\n|\r|\n)/);
+    this.lineDirty = [];
+    for (let lineNum = 0; lineNum < this.lines.length; lineNum++) {
+      let le = document.createElement('div');
+      this.e.appendChild(le);
+      this.lineDirty.push(true);
+    }
+    this.lineTypes = new Array(this.lines.length);
+    this.updateFormatting();
+    this.fireChange();
+  }
 
-  _createClass(Editor, [{
-    key: "createEditorElement",
-    value: function createEditorElement(element) {
-      var _this = this;
-
-      this.e = document.createElement('div');
-      this.e.className = 'TinyMDE';
-      this.e.contentEditable = true; // The following is important for formatting purposes, but also since otherwise the browser replaces subsequent spaces with  &nbsp; &nbsp;
-      // That breaks a lot of stuff, so we do this here and not in CSS—therefore, you don't have to remember to but this in the CSS file
-
-      this.e.style.whiteSpace = 'pre-wrap'; // Avoid formatting (B / I / U) popping up on iOS
+  /**
+   * Gets the editor content as a Markdown string.
+   * @returns {string} The editor content as a markdown string
+   */
+  getContent() {
+    return this.lines.join('\n');
+  }
 
-      this.e.style.webkitUserModify = 'read-write-plaintext-only';
+  /**
+   * This is the main method to update the formatting (from this.lines to HTML output)
+   */
+  updateFormatting() {
+    // First, parse line types. This will update this.lineTypes, this.lineReplacements, and this.lineCaptures
+    // We don't apply the formatting yet
+    this.updateLineTypes();
+    // Collect any valid link labels from link reference definitions—we need that for formatting to determine what's a valid link
+    this.updateLinkLabels();
+    // Now, apply the formatting
+    this.applyLineTypes();
+  }
 
-      if (this.textarea && this.textarea.parentNode == element && this.textarea.nextSibling) {
-        element.insertBefore(this.e, this.textarea.nextSibling);
-      } else {
-        element.appendChild(this.e);
+  /**
+   * Updates this.linkLabels: For every link reference definition (line type TMLinkReferenceDefinition), we collect the label
+   */
+  updateLinkLabels() {
+    this.linkLabels = [];
+    for (let l = 0; l < this.lines.length; l++) {
+      if (this.lineTypes[l] == 'TMLinkReferenceDefinition') {
+        this.linkLabels.push(this.lineCaptures[l][_grammar.lineGrammar.TMLinkReferenceDefinition.labelPlaceholder]);
       }
+    }
+  }
 
-      this.e.addEventListener("input", function (e) {
-        return _this.handleInputEvent(e);
-      }); // this.e.addEventListener("keydown", (e) => this.handleKeydownEvent(e));
+  /**
+   * Helper function to replace placeholders from a RegExp capture. The replacement string can contain regular dollar placeholders (e.g., $1),
+   * which are interpreted like in String.replace(), but also double dollar placeholders ($$1). In the case of double dollar placeholders, 
+   * Markdown inline grammar is applied on the content of the captured subgroup, i.e., $$1 processes inline Markdown grammar in the content of the
+   * first captured subgroup, and replaces `$$1` with the result.
+   * 
+   * @param {string} replacement The replacement string, including placeholders.
+   * @param  capture The result of a RegExp.exec() call
+   * @returns The replacement string, with placeholders replaced from the capture result.
+   */
+  replace(replacement, capture) {
+    return replacement.replace(/(\${1,2})([0-9])/g, (str, p1, p2) => {
+      if (p1 == '$') return (0, _grammar.htmlescape)(capture[p2]);else return `<span class="TMInlineFormatted">${this.processInlineStyles(capture[p2])}</span>`;
+    });
+  }
 
-      document.addEventListener("selectionchange", function (e) {
-        return _this.handleSelectionChangeEvent(e);
-      });
-      this.e.addEventListener("paste", function (e) {
-        return _this.handlePaste(e);
-      }); // this.e.addEventListener('keydown', (e) => this.handleKeyDown(e));
+  /**
+   * Applies the line types (from this.lineTypes as well as the capture result in this.lineReplacements and this.lineCaptures) 
+   * and processes inline formatting for all lines.
+   */
+  applyLineTypes() {
+    for (let lineNum = 0; lineNum < this.lines.length; lineNum++) {
+      if (this.lineDirty[lineNum]) {
+        let contentHTML = this.replace(this.lineReplacements[lineNum], this.lineCaptures[lineNum]);
+        // this.lineHTML[lineNum] = (contentHTML == '' ? '<br />' : contentHTML); // Prevent empty elements which can't be selected etc.
+        this.lineElements[lineNum].className = this.lineTypes[lineNum];
+        this.lineElements[lineNum].removeAttribute('style');
+        this.lineElements[lineNum].innerHTML = contentHTML == '' ? '<br />' : contentHTML; // Prevent empty elements which can't be selected etc.
+      }
 
-      this.lineElements = this.e.childNodes; // this will automatically update
+      this.lineElements[lineNum].dataset.lineNum = lineNum;
     }
-    /**
-     * Sets the editor content.
-     * @param {string} content The new Markdown content
-     */
-
-  }, {
-    key: "setContent",
-    value: function setContent(content) {
-      // Delete any existing content
-      while (this.e.firstChild) {
-        this.e.removeChild(this.e.firstChild);
-      }
+  }
 
-      this.lines = content.split(/(?:\r\n|\r|\n)/);
-      this.lineDirty = [];
+  /**
+   * Determines line types for all lines based on the line / block grammar. Captures the results of the respective line
+   * grammar regular expressions.
+   * Updates this.lineTypes, this.lineCaptures, and this.lineReplacements.
+   */
+  updateLineTypes() {
+    let codeBlockType = false;
+    let codeBlockSeqLength = 0;
+    let htmlBlock = false;
+    for (let lineNum = 0; lineNum < this.lines.length; lineNum++) {
+      let lineType = 'TMPara';
+      let lineCapture = [this.lines[lineNum]];
+      let lineReplacement = '$$0'; // Default replacement for paragraph: Inline format the entire line
+
+      // Check ongoing code blocks
+      // if (lineNum > 0 && (this.lineTypes[lineNum - 1] == 'TMCodeFenceBacktickOpen' || this.lineTypes[lineNum - 1] == 'TMFencedCodeBacktick')) {
+      if (codeBlockType == 'TMCodeFenceBacktickOpen') {
+        // We're in a backtick-fenced code block, check if the current line closes it
+        let capture = _grammar.lineGrammar.TMCodeFenceBacktickClose.regexp.exec(this.lines[lineNum]);
+        if (capture && capture.groups['seq'].length >= codeBlockSeqLength) {
+          lineType = 'TMCodeFenceBacktickClose';
+          lineReplacement = _grammar.lineGrammar.TMCodeFenceBacktickClose.replacement;
+          lineCapture = capture;
+          codeBlockType = false;
+        } else {
+          lineType = 'TMFencedCodeBacktick';
+          lineReplacement = '$0';
+          lineCapture = [this.lines[lineNum]];
+        }
+      }
+      // if (lineNum > 0 && (this.lineTypes[lineNum - 1] == 'TMCodeFenceTildeOpen' || this.lineTypes[lineNum - 1] == 'TMFencedCodeTilde')) {
+      else if (codeBlockType == 'TMCodeFenceTildeOpen') {
+        // We're in a tilde-fenced code block
+        let capture = _grammar.lineGrammar.TMCodeFenceTildeClose.regexp.exec(this.lines[lineNum]);
+        if (capture && capture.groups['seq'].length >= codeBlockSeqLength) {
+          lineType = 'TMCodeFenceTildeClose';
+          lineReplacement = _grammar.lineGrammar.TMCodeFenceTildeClose.replacement;
+          lineCapture = capture;
+          codeBlockType = false;
+        } else {
+          lineType = 'TMFencedCodeTilde';
+          lineReplacement = '$0';
+          lineCapture = [this.lines[lineNum]];
+        }
+      }
 
-      for (var lineNum = 0; lineNum < this.lines.length; lineNum++) {
-        var le = document.createElement('div');
-        this.e.appendChild(le);
-        this.lineDirty.push(true);
+      // Check HTML block types
+      if (lineType == 'TMPara' && htmlBlock === false) {
+        for (let htmlBlockType of _grammar.htmlBlockGrammar) {
+          if (this.lines[lineNum].match(htmlBlockType.start)) {
+            // Matching start condition. Check if this tag can start here (not all start conditions allow breaking a paragraph).
+            if (htmlBlockType.paraInterrupt || lineNum == 0 || !(this.lineTypes[lineNum - 1] == 'TMPara' || this.lineTypes[lineNum - 1] == 'TMUL' || this.lineTypes[lineNum - 1] == 'TMOL' || this.lineTypes[lineNum - 1] == 'TMBlockquote')) {
+              htmlBlock = htmlBlockType;
+              break;
+            }
+          }
+        }
+      }
+      if (htmlBlock !== false) {
+        lineType = 'TMHTMLBlock';
+        lineReplacement = '$0'; // No formatting in TMHTMLBlock
+        lineCapture = [this.lines[lineNum]]; // This should already be set but better safe than sorry
+
+        // Check if HTML block should be closed
+        if (htmlBlock.end) {
+          // Specific end condition
+          if (this.lines[lineNum].match(htmlBlock.end)) {
+            htmlBlock = false;
+          }
+        } else {
+          // No specific end condition, ends with blank line
+          if (lineNum == this.lines.length - 1 || this.lines[lineNum + 1].match(_grammar.lineGrammar.TMBlankLine.regexp)) {
+            htmlBlock = false;
+          }
+        }
       }
 
-      this.lineTypes = new Array(this.lines.length);
-      this.updateFormatting();
-      this.fireChange();
-    }
-    /**
-     * Gets the editor content as a Markdown string.
-     * @returns {string} The editor content as a markdown string
-     */
-
-  }, {
-    key: "getContent",
-    value: function getContent() {
-      return this.lines.join('\n');
-    }
-    /**
-     * This is the main method to update the formatting (from this.lines to HTML output)
-     */
+      // Check all regexps if we haven't applied one of the code block types
+      if (lineType == 'TMPara') {
+        for (let type in _grammar.lineGrammar) {
+          if (_grammar.lineGrammar[type].regexp) {
+            let capture = _grammar.lineGrammar[type].regexp.exec(this.lines[lineNum]);
+            if (capture) {
+              lineType = type;
+              lineReplacement = _grammar.lineGrammar[type].replacement;
+              lineCapture = capture;
+              break;
+            }
+          }
+        }
+      }
 
-  }, {
-    key: "updateFormatting",
-    value: function updateFormatting() {
-      // First, parse line types. This will update this.lineTypes, this.lineReplacements, and this.lineCaptures
-      // We don't apply the formatting yet
-      this.updateLineTypes(); // Collect any valid link labels from link reference definitions—we need that for formatting to determine what's a valid link
+      // If we've opened a code block, remember that
+      if (lineType == 'TMCodeFenceBacktickOpen' || lineType == 'TMCodeFenceTildeOpen') {
+        codeBlockType = lineType;
+        codeBlockSeqLength = lineCapture.groups['seq'].length;
+      }
 
-      this.updateLinkLabels(); // Now, apply the formatting
+      // Link reference definition and indented code can't interrupt a paragraph
+      if ((lineType == 'TMIndentedCode' || lineType == 'TMLinkReferenceDefinition') && lineNum > 0 && (this.lineTypes[lineNum - 1] == 'TMPara' || this.lineTypes[lineNum - 1] == 'TMUL' || this.lineTypes[lineNum - 1] == 'TMOL' || this.lineTypes[lineNum - 1] == 'TMBlockquote')) {
+        // Fall back to TMPara
+        lineType = 'TMPara';
+        lineCapture = [this.lines[lineNum]];
+        lineReplacement = '$$0';
+      }
 
-      this.applyLineTypes();
-    }
-    /**
-     * Updates this.linkLabels: For every link reference definition (line type TMLinkReferenceDefinition), we collect the label
-     */
-
-  }, {
-    key: "updateLinkLabels",
-    value: function updateLinkLabels() {
-      this.linkLabels = [];
-
-      for (var l = 0; l < this.lines.length; l++) {
-        if (this.lineTypes[l] == 'TMLinkReferenceDefinition') {
-          this.linkLabels.push(this.lineCaptures[l][_grammar.lineGrammar.TMLinkReferenceDefinition.labelPlaceholder]);
+      // Setext H2 markers that can also be interpreted as an empty list item should be regarded as such (as per CommonMark spec)
+      if (lineType == 'TMSetextH2Marker') {
+        let capture = _grammar.lineGrammar.TMUL.regexp.exec(this.lines[lineNum]);
+        if (capture) {
+          lineType = 'TMUL';
+          lineReplacement = _grammar.lineGrammar.TMUL.replacement;
+          lineCapture = capture;
         }
       }
-    }
-    /**
-     * Helper function to replace placeholders from a RegExp capture. The replacement string can contain regular dollar placeholders (e.g., $1),
-     * which are interpreted like in String.replace(), but also double dollar placeholders ($$1). In the case of double dollar placeholders, 
-     * Markdown inline grammar is applied on the content of the captured subgroup, i.e., $$1 processes inline Markdown grammar in the content of the
-     * first captured subgroup, and replaces `$$1` with the result.
-     * 
-     * @param {string} replacement The replacement string, including placeholders.
-     * @param  capture The result of a RegExp.exec() call
-     * @returns The replacement string, with placeholders replaced from the capture result.
-     */
-
-  }, {
-    key: "replace",
-    value: function replace(replacement, capture) {
-      var _this2 = this;
-
-      return replacement.replace(/\$\$([0-9])/g, function (str, p1) {
-        return "<span class=\"TMInlineFormatted\">".concat(_this2.processInlineStyles(capture[p1]), "</span>");
-      }).replace(/\$([0-9])/g, function (str, p1) {
-        return (0, _grammar.htmlescape)(capture[p1]);
-      });
-    }
-    /**
-     * Applies the line types (from this.lineTypes as well as the capture result in this.lineReplacements and this.lineCaptures) 
-     * and processes inline formatting for all lines.
-     */
-
-  }, {
-    key: "applyLineTypes",
-    value: function applyLineTypes() {
-      for (var lineNum = 0; lineNum < this.lines.length; lineNum++) {
-        if (this.lineDirty[lineNum]) {
-          var contentHTML = this.replace(this.lineReplacements[lineNum], this.lineCaptures[lineNum]); // this.lineHTML[lineNum] = (contentHTML == '' ? '<br />' : contentHTML); // Prevent empty elements which can't be selected etc.
-
-          this.lineElements[lineNum].className = this.lineTypes[lineNum];
-          this.lineElements[lineNum].removeAttribute('style');
-          this.lineElements[lineNum].innerHTML = contentHTML == '' ? '<br />' : contentHTML; // Prevent empty elements which can't be selected etc.
-        }
 
-        this.lineElements[lineNum].dataset.lineNum = lineNum;
-      }
-    }
-    /**
-     * Determines line types for all lines based on the line / block grammar. Captures the results of the respective line
-     * grammar regular expressions.
-     * Updates this.lineTypes, this.lineCaptures, and this.lineReplacements.
-     */
-
-  }, {
-    key: "updateLineTypes",
-    value: function updateLineTypes() {
-      var codeBlockType = false;
-      var codeBlockSeqLength = 0;
-      var htmlBlock = false;
-
-      for (var lineNum = 0; lineNum < this.lines.length; lineNum++) {
-        var lineType = 'TMPara';
-        var lineCapture = [this.lines[lineNum]];
-        var lineReplacement = '$$0'; // Default replacement for paragraph: Inline format the entire line
-        // Check ongoing code blocks
-        // if (lineNum > 0 && (this.lineTypes[lineNum - 1] == 'TMCodeFenceBacktickOpen' || this.lineTypes[lineNum - 1] == 'TMFencedCodeBacktick')) {
-
-        if (codeBlockType == 'TMCodeFenceBacktickOpen') {
-          // We're in a backtick-fenced code block, check if the current line closes it
-          var capture = _grammar.lineGrammar.TMCodeFenceBacktickClose.regexp.exec(this.lines[lineNum]);
-
-          if (capture && capture.groups['seq'].length >= codeBlockSeqLength) {
-            lineType = 'TMCodeFenceBacktickClose';
-            lineReplacement = _grammar.lineGrammar.TMCodeFenceBacktickClose.replacement;
+      // Setext headings are only valid if preceded by a paragraph (and if so, they change the type of the previous paragraph)
+      if (lineType == 'TMSetextH1Marker' || lineType == 'TMSetextH2Marker') {
+        if (lineNum == 0 || this.lineTypes[lineNum - 1] != 'TMPara') {
+          // Setext marker is invalid. However, a H2 marker might still be a valid HR, so let's check that
+          let capture = _grammar.lineGrammar.TMHR.regexp.exec(this.lines[lineNum]);
+          if (capture) {
+            // Valid HR
+            lineType = 'TMHR';
             lineCapture = capture;
-            codeBlockType = false;
+            lineReplacement = _grammar.lineGrammar.TMHR.replacement;
           } else {
-            lineType = 'TMFencedCodeBacktick';
-            lineReplacement = '$0';
+            // Not valid HR, format as TMPara
+            lineType = 'TMPara';
             lineCapture = [this.lines[lineNum]];
+            lineReplacement = '$$0';
           }
-        } // if (lineNum > 0 && (this.lineTypes[lineNum - 1] == 'TMCodeFenceTildeOpen' || this.lineTypes[lineNum - 1] == 'TMFencedCodeTilde')) {
-        else if (codeBlockType == 'TMCodeFenceTildeOpen') {
-            // We're in a tilde-fenced code block
-            var _capture = _grammar.lineGrammar.TMCodeFenceTildeClose.regexp.exec(this.lines[lineNum]);
-
-            if (_capture && _capture.groups['seq'].length >= codeBlockSeqLength) {
-              lineType = 'TMCodeFenceTildeClose';
-              lineReplacement = _grammar.lineGrammar.TMCodeFenceTildeClose.replacement;
-              lineCapture = _capture;
-              codeBlockType = false;
-            } else {
-              lineType = 'TMFencedCodeTilde';
-              lineReplacement = '$0';
-              lineCapture = [this.lines[lineNum]];
+        } else {
+          // Valid setext marker. Change types of preceding para lines
+          let headingLine = lineNum - 1;
+          const headingLineType = lineType == 'TMSetextH1Marker' ? 'TMSetextH1' : 'TMSetextH2';
+          do {
+            if (this.lineTypes[headingLineType] != headingLineType) {
+              this.lineTypes[headingLine] = headingLineType;
+              this.lineDirty[headingLineType] = true;
             }
-          } // Check HTML block types
+            this.lineReplacements[headingLine] = '$$0';
+            this.lineCaptures[headingLine] = [this.lines[headingLine]];
+            headingLine--;
+          } while (headingLine >= 0 && this.lineTypes[headingLine] == 'TMPara');
+        }
+      }
+      // Lastly, save the line style to be applied later
+      if (this.lineTypes[lineNum] != lineType) {
+        this.lineTypes[lineNum] = lineType;
+        this.lineDirty[lineNum] = true;
+      }
+      this.lineReplacements[lineNum] = lineReplacement;
+      this.lineCaptures[lineNum] = lineCapture;
+    }
+  }
 
+  /**
+   * Updates all line contents from the HTML, then re-applies formatting.
+   */
+  updateLineContentsAndFormatting() {
+    this.clearDirtyFlag();
+    this.updateLineContents();
+    this.updateFormatting();
+  }
 
-        if (lineType == 'TMPara' && htmlBlock === false) {
-          var _iterator = _createForOfIteratorHelper(_grammar.htmlBlockGrammar),
-              _step;
+  /**
+   * Attempts to parse a link or image at the current position. This assumes that the opening [ or ![ has already been matched. 
+   * Returns false if this is not a valid link, image. See below for more information
+   * @param {string} originalString The original string, starting at the opening marker ([ or ![)
+   * @param {boolean} isImage Whether or not this is an image (opener == ![)
+   * @returns false if not a valid link / image. 
+   * Otherwise returns an object with two properties: output is the string to be included in the processed output, 
+   * charCount is the number of input characters (from originalString) consumed.
+   */
+  parseLinkOrImage(originalString, isImage) {
+    // Skip the opening bracket
+    let textOffset = isImage ? 2 : 1;
+    let opener = originalString.substr(0, textOffset);
+    let type = isImage ? 'TMImage' : 'TMLink';
+    let currentOffset = textOffset;
+    let bracketLevel = 1;
+    let linkText = false;
+    let linkRef = false;
+    let linkLabel = [];
+    let linkDetails = []; // If matched, this will be an array: [whitespace + link destination delimiter, link destination, link destination delimiter, whitespace, link title delimiter, link title, link title delimiter + whitespace]. All can be empty strings.
+
+    textOuter: while (currentOffset < originalString.length && linkText === false /* empty string is okay */) {
+      let string = originalString.substr(currentOffset);
+
+      // Capture any escapes and code blocks at current position, they bind more strongly than links
+      // We don't have to actually process them here, that'll be done later in case the link / image is valid, but we need to skip over them.
+      for (let rule of ['escape', 'code', 'autolink', 'html']) {
+        let cap = _grammar.inlineGrammar[rule].regexp.exec(string);
+        if (cap) {
+          currentOffset += cap[0].length;
+          continue textOuter;
+        }
+      }
 
-          try {
-            for (_iterator.s(); !(_step = _iterator.n()).done;) {
-              var htmlBlockType = _step.value;
+      // Check for image. It's okay for an image to be included in a link or image
+      if (string.match(_grammar.inlineGrammar.imageOpen.regexp)) {
+        // Opening image. It's okay if this is a matching pair of brackets
+        bracketLevel++;
+        currentOffset += 2;
+        continue textOuter;
+      }
 
-              if (this.lines[lineNum].match(htmlBlockType.start)) {
-                // Matching start condition. Check if this tag can start here (not all start conditions allow breaking a paragraph).
-                if (htmlBlockType.paraInterrupt || lineNum == 0 || !(this.lineTypes[lineNum - 1] == 'TMPara' || this.lineTypes[lineNum - 1] == 'TMUL' || this.lineTypes[lineNum - 1] == 'TMOL' || this.lineTypes[lineNum - 1] == 'TMBlockquote')) {
-                  htmlBlock = htmlBlockType;
-                  break;
-                }
-              }
-            }
-          } catch (err) {
-            _iterator.e(err);
-          } finally {
-            _iterator.f();
+      // Check for link (not an image because that would have been captured and skipped over above)
+      if (string.match(_grammar.inlineGrammar.linkOpen.regexp)) {
+        // Opening bracket. Two things to do:
+        // 1) it's okay if this part of a pair of brackets.
+        // 2) If we are currently trying to parse a link, this nested bracket musn't start a valid link (no nested links allowed)
+        bracketLevel++;
+        // if (bracketLevel >= 2) return false; // Nested unescaped brackets, this doesn't qualify as a link / image
+        if (!isImage) {
+          if (this.parseLinkOrImage(string, false)) {
+            // Valid link inside this possible link, which makes this link invalid (inner links beat outer ones)
+            return false;
           }
         }
+        currentOffset += 1;
+        continue textOuter;
+      }
 
-        if (htmlBlock !== false) {
-          lineType = 'TMHTMLBlock';
-          lineReplacement = '$0'; // No formatting in TMHTMLBlock
+      // Check for closing bracket
+      if (string.match(/^\]/)) {
+        bracketLevel--;
+        if (bracketLevel == 0) {
+          // Found matching bracket and haven't found anything disqualifying this as link / image.
+          linkText = originalString.substr(textOffset, currentOffset - textOffset);
+          currentOffset++;
+          continue textOuter;
+        }
+      }
 
-          lineCapture = [this.lines[lineNum]]; // This should already be set but better safe than sorry
-          // Check if HTML block should be closed
+      // Nothing matches, proceed to next char
+      currentOffset++;
+    }
 
-          if (htmlBlock.end) {
-            // Specific end condition
-            if (this.lines[lineNum].match(htmlBlock.end)) {
-              htmlBlock = false;
-            }
-          } else {
-            // No specific end condition, ends with blank line
-            if (lineNum == this.lines.length - 1 || this.lines[lineNum + 1].match(_grammar.lineGrammar.TMBlankLine.regexp)) {
-              htmlBlock = false;
-            }
-          }
-        } // Check all regexps if we haven't applied one of the code block types
+    // Did we find a link text (i.e., find a matching closing bracket?)
+    if (linkText === false) return false; // Nope
+
+    // So far, so good. We've got a valid link text. Let's see what type of link this is
+    let nextChar = currentOffset < originalString.length ? originalString.substr(currentOffset, 1) : '';
+
+    // REFERENCE LINKS
+    if (nextChar == '[') {
+      let string = originalString.substr(currentOffset);
+      let cap = _grammar.inlineGrammar.linkLabel.regexp.exec(string);
+      if (cap) {
+        // Valid link label
+        currentOffset += cap[0].length;
+        linkLabel.push(cap[1], cap[2], cap[3]);
+        if (cap[_grammar.inlineGrammar.linkLabel.labelPlaceholder]) {
+          // Full reference link
+          linkRef = cap[_grammar.inlineGrammar.linkLabel.labelPlaceholder];
+        } else {
+          // Collapsed reference link
+          linkRef = linkText.trim();
+        }
+      } else {
+        // Not a valid link label
+        return false;
+      }
+    } else if (nextChar != '(') {
+      // Shortcut ref link
+      linkRef = linkText.trim();
+
+      // INLINE LINKS
+    } else {
+      // nextChar == '('
+
+      // Potential inline link
+      currentOffset++;
+      let parenthesisLevel = 1;
+      inlineOuter: while (currentOffset < originalString.length && parenthesisLevel > 0) {
+        let string = originalString.substr(currentOffset);
+
+        // Process whitespace
+        let cap = /^\s+/.exec(string);
+        if (cap) {
+          switch (linkDetails.length) {
+            case 0:
+              linkDetails.push(cap[0]);
+              break;
+            // Opening whitespace
+            case 1:
+              linkDetails.push(cap[0]);
+              break;
+            // Open destination, but not a destination yet; desination opened with <
+            case 2:
+              // Open destination with content in it. Whitespace only allowed if opened by angle bracket, otherwise this closes the destination
+              if (linkDetails[0].match(/</)) {
+                linkDetails[1] = linkDetails[1].concat(cap[0]);
+              } else {
+                if (parenthesisLevel != 1) return false; // Unbalanced parenthesis
+                linkDetails.push(''); // Empty end delimiter for destination
+                linkDetails.push(cap[0]); // Whitespace in between destination and title
+              }
 
+              break;
+            case 3:
+              linkDetails.push(cap[0]);
+              break;
+            // Whitespace between destination and title
+            case 4:
+              return false;
+            // This should never happen (no opener for title yet, but more whitespace to capture)
+            case 5:
+              linkDetails.push('');
+            // Whitespace at beginning of title, push empty title and continue
+            case 6:
+              linkDetails[5] = linkDetails[5].concat(cap[0]);
+              break;
+            // Whitespace in title
+            case 7:
+              linkDetails[6] = linkDetails[6].concat(cap[0]);
+              break;
+            // Whitespace after closing delimiter
+            default:
+              return false;
+            // We should never get here
+          }
 
-        if (lineType == 'TMPara') {
-          for (var type in _grammar.lineGrammar) {
-            if (_grammar.lineGrammar[type].regexp) {
-              var _capture2 = _grammar.lineGrammar[type].regexp.exec(this.lines[lineNum]);
+          currentOffset += cap[0].length;
+          continue inlineOuter;
+        }
 
-              if (_capture2) {
-                lineType = type;
-                lineReplacement = _grammar.lineGrammar[type].replacement;
-                lineCapture = _capture2;
-                break;
-              }
-            }
+        // Process backslash escapes
+        cap = _grammar.inlineGrammar.escape.regexp.exec(string);
+        if (cap) {
+          switch (linkDetails.length) {
+            case 0:
+              linkDetails.push('');
+            // this opens the link destination, add empty opening delimiter and proceed to next case
+            case 1:
+              linkDetails.push(cap[0]);
+              break;
+            // This opens the link destination, append it
+            case 2:
+              linkDetails[1] = linkDetails[1].concat(cap[0]);
+              break;
+            // Part of the link destination
+            case 3:
+              return false;
+            // Lacking opening delimiter for link title
+            case 4:
+              return false;
+            // Lcaking opening delimiter for link title
+            case 5:
+              linkDetails.push('');
+            // This opens the link title
+            case 6:
+              linkDetails[5] = linkDetails[5].concat(cap[0]);
+              break;
+            // Part of the link title
+            default:
+              return false;
+            // After link title was closed, without closing parenthesis
           }
-        } // If we've opened a code block, remember that
-
 
-        if (lineType == 'TMCodeFenceBacktickOpen' || lineType == 'TMCodeFenceTildeOpen') {
-          codeBlockType = lineType;
-          codeBlockSeqLength = lineCapture.groups['seq'].length;
-        } // Link reference definition and indented code can't interrupt a paragraph
+          currentOffset += cap[0].length;
+          continue inlineOuter;
+        }
 
+        // Process opening angle bracket as deilimiter of destination
+        if (linkDetails.length < 2 && string.match(/^</)) {
+          if (linkDetails.length == 0) linkDetails.push('');
+          linkDetails[0] = linkDetails[0].concat('<');
+          currentOffset++;
+          continue inlineOuter;
+        }
 
-        if ((lineType == 'TMIndentedCode' || lineType == 'TMLinkReferenceDefinition') && lineNum > 0 && (this.lineTypes[lineNum - 1] == 'TMPara' || this.lineTypes[lineNum - 1] == 'TMUL' || this.lineTypes[lineNum - 1] == 'TMOL' || this.lineTypes[lineNum - 1] == 'TMBlockquote')) {
-          // Fall back to TMPara
-          lineType = 'TMPara';
-          lineCapture = [this.lines[lineNum]];
-          lineReplacement = '$$0';
-        } // Setext H2 markers that can also be interpreted as an empty list item should be regarded as such (as per CommonMark spec)
+        // Process closing angle bracket as delimiter of destination
+        if ((linkDetails.length == 1 || linkDetails.length == 2) && string.match(/^>/)) {
+          if (linkDetails.length == 1) linkDetails.push(''); // Empty link destination
+          linkDetails.push('>');
+          currentOffset++;
+          continue inlineOuter;
+        }
 
+        // Process  non-parenthesis delimiter for title. 
+        cap = /^["']/.exec(string);
+        // For this to be a valid opener, we have to either have no destination, only whitespace so far,
+        // or a destination with trailing whitespace.
+        if (cap && (linkDetails.length == 0 || linkDetails.length == 1 || linkDetails.length == 4)) {
+          while (linkDetails.length < 4) linkDetails.push('');
+          linkDetails.push(cap[0]);
+          currentOffset++;
+          continue inlineOuter;
+        }
 
-        if (lineType == 'TMSetextH2Marker') {
-          var _capture3 = _grammar.lineGrammar.TMUL.regexp.exec(this.lines[lineNum]);
+        // For this to be a valid closer, we have to have an opener and some or no title, and this has to match the opener
+        if (cap && (linkDetails.length == 5 || linkDetails.length == 6) && linkDetails[4] == cap[0]) {
+          if (linkDetails.length == 5) linkDetails.push(''); // Empty link title
+          linkDetails.push(cap[0]);
+          currentOffset++;
+          continue inlineOuter;
+        }
+        // Other cases (linkDetails.length == 2, 3, 7) will be handled with the "default" case below.
 
-          if (_capture3) {
-            lineType = 'TMUL';
-            lineReplacement = _grammar.lineGrammar.TMUL.replacement;
-            lineCapture = _capture3;
+        // Process opening parenthesis
+        if (string.match(/^\(/)) {
+          switch (linkDetails.length) {
+            case 0:
+              linkDetails.push('');
+            // this opens the link destination, add empty opening delimiter and proceed to next case
+            case 1:
+              linkDetails.push('');
+            // This opens the link destination
+            case 2:
+              // Part of the link destination
+              linkDetails[1] = linkDetails[1].concat('(');
+              if (!linkDetails[0].match(/<$/)) parenthesisLevel++;
+              break;
+            case 3:
+              linkDetails.push('');
+            //  opening delimiter for link title
+            case 4:
+              linkDetails.push('(');
+              break;
+            // opening delimiter for link title
+            case 5:
+              linkDetails.push('');
+            // opens the link title, add empty title content and proceed to next case 
+            case 6:
+              // Part of the link title. Un-escaped parenthesis only allowed in " or ' delimited title
+              if (linkDetails[4] == '(') return false;
+              linkDetails[5] = linkDetails[5].concat('(');
+              break;
+            default:
+              return false;
+            // After link title was closed, without closing parenthesis
           }
-        } // Setext headings are only valid if preceded by a paragraph (and if so, they change the type of the previous paragraph)
-
 
-        if (lineType == 'TMSetextH1Marker' || lineType == 'TMSetextH2Marker') {
-          if (lineNum == 0 || this.lineTypes[lineNum - 1] != 'TMPara') {
-            // Setext marker is invalid. However, a H2 marker might still be a valid HR, so let's check that
-            var _capture4 = _grammar.lineGrammar.TMHR.regexp.exec(this.lines[lineNum]);
+          currentOffset++;
+          continue inlineOuter;
+        }
 
-            if (_capture4) {
-              // Valid HR
-              lineType = 'TMHR';
-              lineCapture = _capture4;
-              lineReplacement = _grammar.lineGrammar.TMHR.replacement;
+        // Process closing parenthesis
+        if (string.match(/^\)/)) {
+          if (linkDetails.length <= 2) {
+            // We are inside the link destination. Parentheses have to be matched if not in angle brackets
+            while (linkDetails.length < 2) linkDetails.push('');
+            if (!linkDetails[0].match(/<$/)) parenthesisLevel--;
+            if (parenthesisLevel > 0) {
+              linkDetails[1] = linkDetails[1].concat(')');
+            }
+          } else if (linkDetails.length == 5 || linkDetails.length == 6) {
+            // We are inside the link title. 
+            if (linkDetails[4] == '(') {
+              // This closes the link title
+              if (linkDetails.length == 5) linkDetails.push('');
+              linkDetails.push(')');
             } else {
-              // Not valid HR, format as TMPara
-              lineType = 'TMPara';
-              lineCapture = [this.lines[lineNum]];
-              lineReplacement = '$$0';
+              // Just regular ol' content
+              if (linkDetails.length == 5) linkDetails.push(')');else linkDetails[5] = linkDetails[5].concat(')');
             }
           } else {
-            // Valid setext marker. Change types of preceding para lines
-            var headingLine = lineNum - 1;
-            var headingLineType = lineType == 'TMSetextH1Marker' ? 'TMSetextH1' : 'TMSetextH2';
-
-            do {
-              if (this.lineTypes[headingLineType] != headingLineType) {
-                this.lineTypes[headingLine] = headingLineType;
-                this.lineDirty[headingLineType] = true;
-              }
+            parenthesisLevel--; // This should decrease it from 1 to 0...
+          }
 
-              this.lineReplacements[headingLine] = '$$0';
-              this.lineCaptures[headingLine] = [this.lines[headingLine]];
-              headingLine--;
-            } while (headingLine >= 0 && this.lineTypes[headingLine] == 'TMPara');
+          if (parenthesisLevel == 0) {
+            // No invalid condition, let's make sure the linkDetails array is complete
+            while (linkDetails.length < 7) linkDetails.push('');
           }
-        } // Lastly, save the line style to be applied later
+          currentOffset++;
+          continue inlineOuter;
+        }
 
+        // Any old character
+        cap = /^./.exec(string);
+        if (cap) {
+          switch (linkDetails.length) {
+            case 0:
+              linkDetails.push('');
+            // this opens the link destination, add empty opening delimiter and proceed to next case
+            case 1:
+              linkDetails.push(cap[0]);
+              break;
+            // This opens the link destination, append it
+            case 2:
+              linkDetails[1] = linkDetails[1].concat(cap[0]);
+              break;
+            // Part of the link destination
+            case 3:
+              return false;
+            // Lacking opening delimiter for link title
+            case 4:
+              return false;
+            // Lcaking opening delimiter for link title
+            case 5:
+              linkDetails.push('');
+            // This opens the link title
+            case 6:
+              linkDetails[5] = linkDetails[5].concat(cap[0]);
+              break;
+            // Part of the link title
+            default:
+              return false;
+            // After link title was closed, without closing parenthesis
+          }
 
-        if (this.lineTypes[lineNum] != lineType) {
-          this.lineTypes[lineNum] = lineType;
-          this.lineDirty[lineNum] = true;
+          currentOffset += cap[0].length;
+          continue inlineOuter;
         }
-
-        this.lineReplacements[lineNum] = lineReplacement;
-        this.lineCaptures[lineNum] = lineCapture;
+        throw "Infinite loop"; // we should never get here since the last test matches any character
       }
-    }
-    /**
-     * Updates all line contents from the HTML, then re-applies formatting.
-     */
 
-  }, {
-    key: "updateLineContentsAndFormatting",
-    value: function updateLineContentsAndFormatting() {
-      this.clearDirtyFlag();
-      this.updateLineContents();
-      this.updateFormatting();
+      if (parenthesisLevel > 0) return false; // Parenthes(es) not closed
     }
-    /**
-     * Attempts to parse a link or image at the current position. This assumes that the opening [ or ![ has already been matched. 
-     * Returns false if this is not a valid link, image. See below for more information
-     * @param {string} originalString The original string, starting at the opening marker ([ or ![)
-     * @param {boolean} isImage Whether or not this is an image (opener == ![)
-     * @returns false if not a valid link / image. 
-     * Otherwise returns an object with two properties: output is the string to be included in the processed output, 
-     * charCount is the number of input characters (from originalString) consumed.
-     */
-
-  }, {
-    key: "parseLinkOrImage",
-    value: function parseLinkOrImage(originalString, isImage) {
-      // Skip the opening bracket
-      var textOffset = isImage ? 2 : 1;
-      var opener = originalString.substr(0, textOffset);
-      var type = isImage ? 'TMImage' : 'TMLink';
-      var currentOffset = textOffset;
-      var bracketLevel = 1;
-      var linkText = false;
-      var linkRef = false;
-      var linkLabel = [];
-      var linkDetails = []; // If matched, this will be an array: [whitespace + link destination delimiter, link destination, link destination delimiter, whitespace, link title delimiter, link title, link title delimiter + whitespace]. All can be empty strings.
-
-      textOuter: while (currentOffset < originalString.length && linkText === false
-      /* empty string is okay */
-      ) {
-        var string = originalString.substr(currentOffset); // Capture any escapes and code blocks at current position, they bind more strongly than links
-        // We don't have to actually process them here, that'll be done later in case the link / image is valid, but we need to skip over them.
-
-        for (var _i = 0, _arr = ['escape', 'code', 'autolink', 'html']; _i < _arr.length; _i++) {
-          var rule = _arr[_i];
-
-          var cap = _grammar.inlineGrammar[rule].regexp.exec(string);
-
-          if (cap) {
-            currentOffset += cap[0].length;
-            continue textOuter;
-          }
-        } // Check for image. It's okay for an image to be included in a link or image
 
+    if (linkRef !== false) {
+      // Ref link; check that linkRef is valid
+      let valid = false;
+      for (let label of this.linkLabels) {
+        if (label == linkRef) {
+          valid = true;
+          break;
+        }
+      }
+      let label = valid ? "TMLinkLabel TMLinkLabel_Valid" : "TMLinkLabel TMLinkLabel_Invalid";
+      let output = `<span class="TMMark TMMark_${type}">${opener}</span><span class="${type} ${linkLabel.length < 3 || !linkLabel[1] ? label : ""}">${this.processInlineStyles(linkText)}</span><span class="TMMark TMMark_${type}">]</span>`;
+      if (linkLabel.length >= 3) {
+        output = output.concat(`<span class="TMMark TMMark_${type}">${linkLabel[0]}</span>`, `<span class="${label}">${linkLabel[1]}</span>`, `<span class="TMMark TMMark_${type}">${linkLabel[2]}</span>`);
+      }
+      return {
+        output: output,
+        charCount: currentOffset
+      };
+    } else if (linkDetails) {
+      // Inline link
 
-        if (string.match(_grammar.inlineGrammar.imageOpen.regexp)) {
-          // Opening image. It's okay if this is a matching pair of brackets
-          bracketLevel++;
-          currentOffset += 2;
-          continue textOuter;
-        } // Check for link (not an image because that would have been captured and skipped over above)
+      // This should never happen, but better safe than sorry.
+      while (linkDetails.length < 7) {
+        linkDetails.push('');
+      }
+      return {
+        output: `<span class="TMMark TMMark_${type}">${opener}</span><span class="${type}">${this.processInlineStyles(linkText)}</span><span class="TMMark TMMark_${type}">](${linkDetails[0]}</span><span class="${type}Destination">${linkDetails[1]}</span><span class="TMMark TMMark_${type}">${linkDetails[2]}${linkDetails[3]}${linkDetails[4]}</span><span class="${type}Title">${linkDetails[5]}</span><span class="TMMark TMMark_${type}">${linkDetails[6]})</span>`,
+        charCount: currentOffset
+      };
+    }
+    return false;
+  }
 
+  /**
+   * Formats a markdown string as HTML, using Markdown inline formatting.
+   * @param {string} originalString The input (markdown inline formatted) string
+   * @returns {string} The HTML formatted output
+   */
+  processInlineStyles(originalString) {
+    let processed = '';
+    let stack = []; // Stack is an array of objects of the format: {delimiter, delimString, count, output}
+    let offset = 0;
+    let string = originalString;
+    outer: while (string) {
+      // Process simple rules (non-delimiter)
+      for (let rule of ['escape', 'code', 'autolink', 'html']) {
+        let cap = _grammar.inlineGrammar[rule].regexp.exec(string);
+        if (cap) {
+          string = string.substr(cap[0].length);
+          offset += cap[0].length;
+          processed += _grammar.inlineGrammar[rule].replacement
+          // .replace(/\$\$([1-9])/g, (str, p1) => processInlineStyles(cap[p1])) // todo recursive calling
+          .replace(/\$([1-9])/g, (str, p1) => (0, _grammar.htmlescape)(cap[p1]));
+          continue outer;
+        }
+      }
 
-        if (string.match(_grammar.inlineGrammar.linkOpen.regexp)) {
-          // Opening bracket. Two things to do:
-          // 1) it's okay if this part of a pair of brackets.
-          // 2) If we are currently trying to parse a link, this nested bracket musn't start a valid link (no nested links allowed)
-          bracketLevel++; // if (bracketLevel >= 2) return false; // Nested unescaped brackets, this doesn't qualify as a link / image
+      // Check for links / images
+      let potentialLink = string.match(_grammar.inlineGrammar.linkOpen.regexp);
+      let potentialImage = string.match(_grammar.inlineGrammar.imageOpen.regexp);
+      if (potentialImage || potentialLink) {
+        let result = this.parseLinkOrImage(string, potentialImage);
+        if (result) {
+          processed = `${processed}${result.output}`;
+          string = string.substr(result.charCount);
+          offset += result.charCount;
+          continue outer;
+        }
+      }
 
-          if (!isImage) {
-            if (this.parseLinkOrImage(string, false)) {
-              // Valid link inside this possible link, which makes this link invalid (inner links beat outer ones)
-              return false;
-            }
-          }
+      // Check for em / strong delimiters
+      let cap = /(^\*+)|(^_+)/.exec(string);
+      if (cap) {
+        let delimCount = cap[0].length;
+        const delimString = cap[0];
+        const currentDelimiter = cap[0][0]; // This should be * or _
 
-          currentOffset += 1;
-          continue textOuter;
-        } // Check for closing bracket
+        string = string.substr(cap[0].length);
 
+        // We have a delimiter run. Let's check if it can open or close an emphasis.
 
-        if (string.match(/^\]/)) {
-          bracketLevel--;
+        const preceding = offset > 0 ? originalString.substr(0, offset) : ' '; // beginning and end of line count as whitespace
+        const following = offset + cap[0].length < originalString.length ? string : ' ';
+        const punctuationFollows = following.match(_grammar.punctuationLeading);
+        const punctuationPrecedes = preceding.match(_grammar.punctuationTrailing);
+        const whitespaceFollows = following.match(/^\s/);
+        const whitespacePrecedes = preceding.match(/\s$/);
 
-          if (bracketLevel == 0) {
-            // Found matching bracket and haven't found anything disqualifying this as link / image.
-            linkText = originalString.substr(textOffset, currentOffset - textOffset);
-            currentOffset++;
-            continue textOuter;
-          }
-        } // Nothing matches, proceed to next char
+        // These are the rules for right-flanking and left-flanking delimiter runs as per CommonMark spec
+        let canOpen = !whitespaceFollows && (!punctuationFollows || !!whitespacePrecedes || !!punctuationPrecedes);
+        let canClose = !whitespacePrecedes && (!punctuationPrecedes || !!whitespaceFollows || !!punctuationFollows);
 
+        // Underscores have more detailed rules than just being part of left- or right-flanking run:
+        if (currentDelimiter == '_' && canOpen && canClose) {
+          canOpen = punctuationPrecedes;
+          canClose = punctuationFollows;
+        }
 
-        currentOffset++;
-      } // Did we find a link text (i.e., find a matching closing bracket?)
+        // If the delimiter can close, check the stack if there's something it can close
+        if (canClose) {
+          let stackPointer = stack.length - 1;
+          // See if we can find a matching opening delimiter, move down through the stack
+          while (delimCount && stackPointer >= 0) {
+            if (stack[stackPointer].delimiter == currentDelimiter) {
+              // We found a matching delimiter, let's construct the formatted string
 
+              // Firstly, if we skipped any stack levels, pop them immediately (non-matching delimiters)
+              while (stackPointer < stack.length - 1) {
+                const entry = stack.pop();
+                processed = `${entry.output}${entry.delimString.substr(0, entry.count)}${processed}`;
+              }
 
-      if (linkText === false) return false; // Nope
-      // So far, so good. We've got a valid link text. Let's see what type of link this is
-
-      var nextChar = currentOffset < originalString.length ? originalString.substr(currentOffset, 1) : ''; // REFERENCE LINKS
-
-      if (nextChar == '[') {
-        var _string = originalString.substr(currentOffset);
-
-        var _cap = _grammar.inlineGrammar.linkLabel.regexp.exec(_string);
-
-        if (_cap) {
-          // Valid link label
-          currentOffset += _cap[0].length;
-          linkLabel.push(_cap[1], _cap[2], _cap[3]);
-
-          if (_cap[_grammar.inlineGrammar.linkLabel.labelPlaceholder]) {
-            // Full reference link
-            linkRef = _cap[_grammar.inlineGrammar.linkLabel.labelPlaceholder];
-          } else {
-            // Collapsed reference link
-            linkRef = linkText.trim();
-          }
-        } else {
-          // Not a valid link label
-          return false;
-        }
-      } else if (nextChar != '(') {
-        // Shortcut ref link
-        linkRef = linkText.trim(); // INLINE LINKS
-      } else {
-        // nextChar == '('
-        // Potential inline link
-        currentOffset++;
-        var parenthesisLevel = 1;
-
-        inlineOuter: while (currentOffset < originalString.length && parenthesisLevel > 0) {
-          var _string2 = originalString.substr(currentOffset); // Process whitespace
-
-
-          var _cap2 = /^\s+/.exec(_string2);
-
-          if (_cap2) {
-            switch (linkDetails.length) {
-              case 0:
-                linkDetails.push(_cap2[0]);
-                break;
-              // Opening whitespace
-
-              case 1:
-                linkDetails.push(_cap2[0]);
-                break;
-              // Open destination, but not a destination yet; desination opened with <
-
-              case 2:
-                // Open destination with content in it. Whitespace only allowed if opened by angle bracket, otherwise this closes the destination
-                if (linkDetails[0].match(/</)) {
-                  linkDetails[1] = linkDetails[1].concat(_cap2[0]);
-                } else {
-                  if (parenthesisLevel != 1) return false; // Unbalanced parenthesis
-
-                  linkDetails.push(''); // Empty end delimiter for destination
-
-                  linkDetails.push(_cap2[0]); // Whitespace in between destination and title
-                }
-
-                break;
-
-              case 3:
-                linkDetails.push(_cap2[0]);
-                break;
-              // Whitespace between destination and title
-
-              case 4:
-                return false;
-              // This should never happen (no opener for title yet, but more whitespace to capture)
-
-              case 5:
-                linkDetails.push('');
-              // Whitespace at beginning of title, push empty title and continue
-
-              case 6:
-                linkDetails[5] = linkDetails[5].concat(_cap2[0]);
-                break;
-              // Whitespace in title
-
-              case 7:
-                linkDetails[6] = linkDetails[6].concat(_cap2[0]);
-                break;
-              // Whitespace after closing delimiter
-
-              default:
-                return false;
-              // We should never get here
-            }
-
-            currentOffset += _cap2[0].length;
-            continue inlineOuter;
-          } // Process backslash escapes
-
-
-          _cap2 = _grammar.inlineGrammar.escape.regexp.exec(_string2);
-
-          if (_cap2) {
-            switch (linkDetails.length) {
-              case 0:
-                linkDetails.push('');
-              // this opens the link destination, add empty opening delimiter and proceed to next case
-
-              case 1:
-                linkDetails.push(_cap2[0]);
-                break;
-              // This opens the link destination, append it
-
-              case 2:
-                linkDetails[1] = linkDetails[1].concat(_cap2[0]);
-                break;
-              // Part of the link destination
-
-              case 3:
-                return false;
-              // Lacking opening delimiter for link title
-
-              case 4:
-                return false;
-              // Lcaking opening delimiter for link title
-
-              case 5:
-                linkDetails.push('');
-              // This opens the link title
-
-              case 6:
-                linkDetails[5] = linkDetails[5].concat(_cap2[0]);
-                break;
-              // Part of the link title
-
-              default:
-                return false;
-              // After link title was closed, without closing parenthesis
-            }
-
-            currentOffset += _cap2[0].length;
-            continue inlineOuter;
-          } // Process opening angle bracket as deilimiter of destination
-
-
-          if (linkDetails.length < 2 && _string2.match(/^</)) {
-            if (linkDetails.length == 0) linkDetails.push('');
-            linkDetails[0] = linkDetails[0].concat('<');
-            currentOffset++;
-            continue inlineOuter;
-          } // Process closing angle bracket as delimiter of destination
-
-
-          if ((linkDetails.length == 1 || linkDetails.length == 2) && _string2.match(/^>/)) {
-            if (linkDetails.length == 1) linkDetails.push(''); // Empty link destination
-
-            linkDetails.push('>');
-            currentOffset++;
-            continue inlineOuter;
-          } // Process  non-parenthesis delimiter for title. 
-
-
-          _cap2 = /^["']/.exec(_string2); // For this to be a valid opener, we have to either have no destination, only whitespace so far,
-          // or a destination with trailing whitespace.
-
-          if (_cap2 && (linkDetails.length == 0 || linkDetails.length == 1 || linkDetails.length == 4)) {
-            while (linkDetails.length < 4) {
-              linkDetails.push('');
-            }
-
-            linkDetails.push(_cap2[0]);
-            currentOffset++;
-            continue inlineOuter;
-          } // For this to be a valid closer, we have to have an opener and some or no title, and this has to match the opener
-
-
-          if (_cap2 && (linkDetails.length == 5 || linkDetails.length == 6) && linkDetails[4] == _cap2[0]) {
-            if (linkDetails.length == 5) linkDetails.push(''); // Empty link title
-
-            linkDetails.push(_cap2[0]);
-            currentOffset++;
-            continue inlineOuter;
-          } // Other cases (linkDetails.length == 2, 3, 7) will be handled with the "default" case below.
-          // Process opening parenthesis
-
-
-          if (_string2.match(/^\(/)) {
-            switch (linkDetails.length) {
-              case 0:
-                linkDetails.push('');
-              // this opens the link destination, add empty opening delimiter and proceed to next case
-
-              case 1:
-                linkDetails.push('');
-              // This opens the link destination
-
-              case 2:
-                // Part of the link destination
-                linkDetails[1] = linkDetails[1].concat('(');
-                if (!linkDetails[0].match(/<$/)) parenthesisLevel++;
-                break;
-
-              case 3:
-                linkDetails.push('');
-              //  opening delimiter for link title
-
-              case 4:
-                linkDetails.push('(');
-                break;
-              // opening delimiter for link title
-
-              case 5:
-                linkDetails.push('');
-              // opens the link title, add empty title content and proceed to next case 
-
-              case 6:
-                // Part of the link title. Un-escaped parenthesis only allowed in " or ' delimited title
-                if (linkDetails[4] == '(') return false;
-                linkDetails[5] = linkDetails[5].concat('(');
-                break;
-
-              default:
-                return false;
-              // After link title was closed, without closing parenthesis
-            }
-
-            currentOffset++;
-            continue inlineOuter;
-          } // Process closing parenthesis
-
-
-          if (_string2.match(/^\)/)) {
-            if (linkDetails.length <= 2) {
-              // We are inside the link destination. Parentheses have to be matched if not in angle brackets
-              while (linkDetails.length < 2) {
-                linkDetails.push('');
-              }
-
-              if (!linkDetails[0].match(/<$/)) parenthesisLevel--;
-
-              if (parenthesisLevel > 0) {
-                linkDetails[1] = linkDetails[1].concat(')');
-              }
-            } else if (linkDetails.length == 5 || linkDetails.length == 6) {
-              // We are inside the link title. 
-              if (linkDetails[4] == '(') {
-                // This closes the link title
-                if (linkDetails.length == 5) linkDetails.push('');
-                linkDetails.push(')');
+              // Then, format the string
+              if (delimCount >= 2 && stack[stackPointer].count >= 2) {
+                // Strong
+                processed = `<span class="TMMark">${currentDelimiter}${currentDelimiter}</span><strong class="TMStrong">${processed}</strong><span class="TMMark">${currentDelimiter}${currentDelimiter}</span>`;
+                delimCount -= 2;
+                stack[stackPointer].count -= 2;
               } else {
-                // Just regular ol' content
-                if (linkDetails.length == 5) linkDetails.push(')');else linkDetails[5] = linkDetails[5].concat(')');
+                // Em
+                processed = `<span class="TMMark">${currentDelimiter}</span><em class="TMEm">${processed}</em><span class="TMMark">${currentDelimiter}</span>`;
+                delimCount -= 1;
+                stack[stackPointer].count -= 1;
               }
-            } else {
-              parenthesisLevel--; // This should decrease it from 1 to 0...
-            }
 
-            if (parenthesisLevel == 0) {
-              // No invalid condition, let's make sure the linkDetails array is complete
-              while (linkDetails.length < 7) {
-                linkDetails.push('');
+              // If that stack level is empty now, pop it
+              if (stack[stackPointer].count == 0) {
+                let entry = stack.pop();
+                processed = `${entry.output}${processed}`;
+                stackPointer--;
               }
-            }
-
-            currentOffset++;
-            continue inlineOuter;
-          } // Any old character
-
-
-          _cap2 = /^./.exec(_string2);
-
-          if (_cap2) {
-            switch (linkDetails.length) {
-              case 0:
-                linkDetails.push('');
-              // this opens the link destination, add empty opening delimiter and proceed to next case
-
-              case 1:
-                linkDetails.push(_cap2[0]);
-                break;
-              // This opens the link destination, append it
-
-              case 2:
-                linkDetails[1] = linkDetails[1].concat(_cap2[0]);
-                break;
-              // Part of the link destination
-
-              case 3:
-                return false;
-              // Lacking opening delimiter for link title
-
-              case 4:
-                return false;
-              // Lcaking opening delimiter for link title
-
-              case 5:
-                linkDetails.push('');
-              // This opens the link title
-
-              case 6:
-                linkDetails[5] = linkDetails[5].concat(_cap2[0]);
-                break;
-              // Part of the link title
-
-              default:
-                return false;
-              // After link title was closed, without closing parenthesis
-            }
-
-            currentOffset += _cap2[0].length;
-            continue inlineOuter;
-          }
-
-          throw "Infinite loop"; // we should never get here since the last test matches any character
-        }
-
-        if (parenthesisLevel > 0) return false; // Parenthes(es) not closed
-      }
-
-      if (linkRef !== false) {
-        // Ref link; check that linkRef is valid
-        var valid = false;
-
-        var _iterator2 = _createForOfIteratorHelper(this.linkLabels),
-            _step2;
-
-        try {
-          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-            var _label = _step2.value;
-
-            if (_label == linkRef) {
-              valid = true;
-              break;
+            } else {
+              // This stack level's delimiter type doesn't match the current delimiter type
+              // Go down one level in the stack
+              stackPointer--;
             }
           }
-        } catch (err) {
-          _iterator2.e(err);
-        } finally {
-          _iterator2.f();
         }
-
-        var label = valid ? "TMLinkLabel TMLinkLabel_Valid" : "TMLinkLabel TMLinkLabel_Invalid";
-        var output = "<span class=\"TMMark TMMark_".concat(type, "\">").concat(opener, "</span><span class=\"").concat(type, " ").concat(linkLabel.length < 3 || !linkLabel[1] ? label : "", "\">").concat(this.processInlineStyles(linkText), "</span><span class=\"TMMark TMMark_").concat(type, "\">]</span>");
-
-        if (linkLabel.length >= 3) {
-          output = output.concat("<span class=\"TMMark TMMark_".concat(type, "\">").concat(linkLabel[0], "</span>"), "<span class=\"".concat(label, "\">").concat(linkLabel[1], "</span>"), "<span class=\"TMMark TMMark_".concat(type, "\">").concat(linkLabel[2], "</span>"));
+        // If there are still delimiters left, and the delimiter run can open, push it on the stack
+        if (delimCount && canOpen) {
+          stack.push({
+            delimiter: currentDelimiter,
+            delimString: delimString,
+            count: delimCount,
+            output: processed
+          });
+          processed = ''; // Current formatted output has been pushed on the stack and will be prepended when the stack gets popped
+          delimCount = 0;
         }
 
-        return {
-          output: output,
-          charCount: currentOffset
-        };
-      } else if (linkDetails) {
-        // Inline link
-        // This should never happen, but better safe than sorry.
-        while (linkDetails.length < 7) {
-          linkDetails.push('');
+        // Any delimiters that are left (closing unmatched) are appended to the output.
+        if (delimCount) {
+          processed = `${processed}${delimString.substr(0, delimCount)}`;
         }
-
-        return {
-          output: "<span class=\"TMMark TMMark_".concat(type, "\">").concat(opener, "</span><span class=\"").concat(type, "\">").concat(this.processInlineStyles(linkText), "</span><span class=\"TMMark TMMark_").concat(type, "\">](").concat(linkDetails[0], "</span><span class=\"").concat(type, "Destination\">").concat(linkDetails[1], "</span><span class=\"TMMark TMMark_").concat(type, "\">").concat(linkDetails[2]).concat(linkDetails[3]).concat(linkDetails[4], "</span><span class=\"").concat(type, "Title\">").concat(linkDetails[5], "</span><span class=\"TMMark TMMark_").concat(type, "\">").concat(linkDetails[6], ")</span>"),
-          charCount: currentOffset
-        };
+        offset += cap[0].length;
+        continue outer;
       }
 
-      return false;
-    }
-    /**
-     * Formats a markdown string as HTML, using Markdown inline formatting.
-     * @param {string} originalString The input (markdown inline formatted) string
-     * @returns {string} The HTML formatted output
-     */
-
-  }, {
-    key: "processInlineStyles",
-    value: function processInlineStyles(originalString) {
-      var _this3 = this;
-
-      var processed = '';
-      var stack = []; // Stack is an array of objects of the format: {delimiter, delimString, count, output}
-
-      var offset = 0;
-      var string = originalString;
-
-      var _loop = function _loop() {
-        var _loop2 = function _loop2() {
-          var rule = _arr2[_i2];
-
-          var cap = _grammar.inlineGrammar[rule].regexp.exec(string);
-
-          if (cap) {
-            string = string.substr(cap[0].length);
-            offset += cap[0].length;
-            processed += _grammar.inlineGrammar[rule].replacement // .replace(/\$\$([1-9])/g, (str, p1) => processInlineStyles(cap[p1])) // todo recursive calling
-            .replace(/\$([1-9])/g, function (str, p1) {
-              return (0, _grammar.htmlescape)(cap[p1]);
-            });
-            return {
-              v: "continue|outer"
-            };
-          }
-        };
-
-        // Process simple rules (non-delimiter)
-        for (var _i2 = 0, _arr2 = ['escape', 'code', 'autolink', 'html']; _i2 < _arr2.length; _i2++) {
-          var _ret2 = _loop2();
-
-          if (_typeof(_ret2) === "object") return _ret2.v;
-        } // Check for links / images
-
-
-        var potentialLink = string.match(_grammar.inlineGrammar.linkOpen.regexp);
-        var potentialImage = string.match(_grammar.inlineGrammar.imageOpen.regexp);
-
-        if (potentialImage || potentialLink) {
-          var result = _this3.parseLinkOrImage(string, potentialImage);
-
-          if (result) {
-            processed = "".concat(processed).concat(result.output);
-            string = string.substr(result.charCount);
-            offset += result.charCount;
-            return "continue|outer";
-          }
-        } // Check for em / strong delimiters
-
-
-        var cap = /(^\*+)|(^_+)/.exec(string);
-
-        if (cap) {
-          var delimCount = cap[0].length;
-          var delimString = cap[0];
-          var currentDelimiter = cap[0][0]; // This should be * or _
-
-          string = string.substr(cap[0].length); // We have a delimiter run. Let's check if it can open or close an emphasis.
-
-          var preceding = offset > 0 ? originalString.substr(0, offset) : ' '; // beginning and end of line count as whitespace
-
-          var following = offset + cap[0].length < originalString.length ? string : ' ';
-          var punctuationFollows = following.match(_grammar.punctuationLeading);
-          var punctuationPrecedes = preceding.match(_grammar.punctuationTrailing);
-          var whitespaceFollows = following.match(/^\s/);
-          var whitespacePrecedes = preceding.match(/\s$/); // These are the rules for right-flanking and left-flanking delimiter runs as per CommonMark spec
-
-          var canOpen = !whitespaceFollows && (!punctuationFollows || !!whitespacePrecedes || !!punctuationPrecedes);
-          var canClose = !whitespacePrecedes && (!punctuationPrecedes || !!whitespaceFollows || !!punctuationFollows); // Underscores have more detailed rules than just being part of left- or right-flanking run:
-
-          if (currentDelimiter == '_' && canOpen && canClose) {
-            canOpen = punctuationPrecedes;
-            canClose = punctuationFollows;
-          } // If the delimiter can close, check the stack if there's something it can close
-
-
-          if (canClose) {
-            var stackPointer = stack.length - 1; // See if we can find a matching opening delimiter, move down through the stack
-
-            while (delimCount && stackPointer >= 0) {
-              if (stack[stackPointer].delimiter == currentDelimiter) {
-                // We found a matching delimiter, let's construct the formatted string
-                // Firstly, if we skipped any stack levels, pop them immediately (non-matching delimiters)
-                while (stackPointer < stack.length - 1) {
-                  var _entry = stack.pop();
-
-                  processed = "".concat(_entry.output).concat(_entry.delimString.substr(0, _entry.count)).concat(processed);
-                } // Then, format the string
-
-
-                if (delimCount >= 2 && stack[stackPointer].count >= 2) {
-                  // Strong
-                  processed = "<span class=\"TMMark\">".concat(currentDelimiter).concat(currentDelimiter, "</span><strong class=\"TMStrong\">").concat(processed, "</strong><span class=\"TMMark\">").concat(currentDelimiter).concat(currentDelimiter, "</span>");
-                  delimCount -= 2;
-                  stack[stackPointer].count -= 2;
-                } else {
-                  // Em
-                  processed = "<span class=\"TMMark\">".concat(currentDelimiter, "</span><em class=\"TMEm\">").concat(processed, "</em><span class=\"TMMark\">").concat(currentDelimiter, "</span>");
-                  delimCount -= 1;
-                  stack[stackPointer].count -= 1;
-                } // If that stack level is empty now, pop it
-
-
-                if (stack[stackPointer].count == 0) {
-                  var _entry2 = stack.pop();
-
-                  processed = "".concat(_entry2.output).concat(processed);
-                  stackPointer--;
-                }
-              } else {
-                // This stack level's delimiter type doesn't match the current delimiter type
-                // Go down one level in the stack
-                stackPointer--;
-              }
+      // Check for strikethrough delimiter
+      cap = /^~~/.exec(string);
+      if (cap) {
+        let consumed = false;
+        let stackPointer = stack.length - 1;
+        // See if we can find a matching opening delimiter, move down through the stack
+        while (!consumed && stackPointer >= 0) {
+          if (stack[stackPointer].delimiter == '~') {
+            // We found a matching delimiter, let's construct the formatted string
+
+            // Firstly, if we skipped any stack levels, pop them immediately (non-matching delimiters)
+            while (stackPointer < stack.length - 1) {
+              const entry = stack.pop();
+              processed = `${entry.output}${entry.delimString.substr(0, entry.count)}${processed}`;
             }
-          } // If there are still delimiters left, and the delimiter run can open, push it on the stack
-
-
-          if (delimCount && canOpen) {
-            stack.push({
-              delimiter: currentDelimiter,
-              delimString: delimString,
-              count: delimCount,
-              output: processed
-            });
-            processed = ''; // Current formatted output has been pushed on the stack and will be prepended when the stack gets popped
-
-            delimCount = 0;
-          } // Any delimiters that are left (closing unmatched) are appended to the output.
-
-
-          if (delimCount) {
-            processed = "".concat(processed).concat(delimString.substr(0, delimCount));
-          }
-
-          offset += cap[0].length;
-          return "continue|outer";
-        } // Check for strikethrough delimiter
-
-
-        cap = /^~~/.exec(string);
-
-        if (cap) {
-          var consumed = false;
-
-          var _stackPointer = stack.length - 1; // See if we can find a matching opening delimiter, move down through the stack
-
-
-          while (!consumed && _stackPointer >= 0) {
-            if (stack[_stackPointer].delimiter == '~') {
-              // We found a matching delimiter, let's construct the formatted string
-              // Firstly, if we skipped any stack levels, pop them immediately (non-matching delimiters)
-              while (_stackPointer < stack.length - 1) {
-                var _entry4 = stack.pop();
-
-                processed = "".concat(_entry4.output).concat(_entry4.delimString.substr(0, _entry4.count)).concat(processed);
-              } // Then, format the string
-
-
-              processed = "<span class=\"TMMark\">~~</span><del class=\"TMStrikethrough\">".concat(processed, "</del><span class=\"TMMark\">~~</span>");
-
-              var _entry3 = stack.pop();
-
-              processed = "".concat(_entry3.output).concat(processed);
-              consumed = true;
-            } else {
-              // This stack level's delimiter type doesn't match the current delimiter type
-              // Go down one level in the stack
-              _stackPointer--;
-            }
-          } // If there are still delimiters left, and the delimiter run can open, push it on the stack
-
 
-          if (!consumed) {
-            stack.push({
-              delimiter: '~',
-              delimString: '~~',
-              count: 2,
-              output: processed
-            });
-            processed = ''; // Current formatted output has been pushed on the stack and will be prepended when the stack gets popped
+            // Then, format the string
+            processed = `<span class="TMMark">~~</span><del class="TMStrikethrough">${processed}</del><span class="TMMark">~~</span>`;
+            let entry = stack.pop();
+            processed = `${entry.output}${processed}`;
+            consumed = true;
+          } else {
+            // This stack level's delimiter type doesn't match the current delimiter type
+            // Go down one level in the stack
+            stackPointer--;
           }
+        }
 
-          offset += cap[0].length;
-          string = string.substr(cap[0].length);
-          return "continue|outer";
-        } // Process 'default' rule
-
-
-        cap = _grammar.inlineGrammar.default.regexp.exec(string);
-
-        if (cap) {
-          string = string.substr(cap[0].length);
-          offset += cap[0].length;
-          processed += _grammar.inlineGrammar.default.replacement.replace(/\$([1-9])/g, function (str, p1) {
-            return (0, _grammar.htmlescape)(cap[p1]);
+        // If there are still delimiters left, and the delimiter run can open, push it on the stack
+        if (!consumed) {
+          stack.push({
+            delimiter: '~',
+            delimString: '~~',
+            count: 2,
+            output: processed
           });
-          return "continue|outer";
+          processed = ''; // Current formatted output has been pushed on the stack and will be prepended when the stack gets popped
         }
 
-        throw 'Infinite loop!';
-      };
-
-      outer: while (string) {
-        var _ret = _loop();
-
-        if (_ret === "continue|outer") continue outer;
-      } // Empty the stack, any opening delimiters are unused
-
-
-      while (stack.length) {
-        var entry = stack.pop();
-        processed = "".concat(entry.output).concat(entry.delimString.substr(0, entry.count)).concat(processed);
+        offset += cap[0].length;
+        string = string.substr(cap[0].length);
+        continue outer;
       }
 
-      return processed;
-    }
-    /** 
-     * Clears the line dirty flag (resets it to an array of false)
-     */
-
-  }, {
-    key: "clearDirtyFlag",
-    value: function clearDirtyFlag() {
-      this.lineDirty = new Array(this.lines.length);
-
-      for (var i = 0; i < this.lineDirty.length; i++) {
-        this.lineDirty[i] = false;
+      // Process 'default' rule
+      cap = _grammar.inlineGrammar.default.regexp.exec(string);
+      if (cap) {
+        string = string.substr(cap[0].length);
+        offset += cap[0].length;
+        processed += _grammar.inlineGrammar.default.replacement.replace(/\$([1-9])/g, (str, p1) => (0, _grammar.htmlescape)(cap[p1]));
+        continue outer;
       }
+      throw 'Infinite loop!';
     }
-    /**
-     * Updates the class properties (lines, lineElements) from the DOM.
-     * @returns true if contents changed
-     */
-
-  }, {
-    key: "updateLineContents",
-    value: function updateLineContents() {
-      // this.lineDirty = []; 
-      // Check if we have changed anything about the number of lines (inserted or deleted a paragraph)
-      // < 0 means line(s) removed; > 0 means line(s) added
-      var lineDelta = this.e.childElementCount - this.lines.length;
-
-      if (lineDelta) {
-        // yup. Let's try how much we can salvage (find out which lines from beginning and end were unchanged)
-        // Find lines from the beginning that haven't changed...
-        var firstChangedLine = 0;
-
-        while (firstChangedLine <= this.lines.length && firstChangedLine <= this.lineElements.length && this.lineElements[firstChangedLine] // Check that the line element hasn't been deleted
-        && this.lines[firstChangedLine] == this.lineElements[firstChangedLine].textContent) {
-          firstChangedLine++;
-        } // End also from the end
-
-
-        var lastChangedLine = -1;
-
-        while (-lastChangedLine < this.lines.length && -lastChangedLine < this.lineElements.length && this.lines[this.lines.length + lastChangedLine] == this.lineElements[this.lineElements.length + lastChangedLine].textContent) {
-          lastChangedLine--;
-        }
-
-        var linesToDelete = this.lines.length + lastChangedLine + 1 - firstChangedLine;
-        if (linesToDelete < -lineDelta) linesToDelete = -lineDelta;
-        if (linesToDelete < 0) linesToDelete = 0;
-        var linesToAdd = [];
 
-        for (var l = 0; l < linesToDelete + lineDelta; l++) {
-          linesToAdd.push(this.lineElements[firstChangedLine + l].textContent);
-        }
-
-        this.spliceLines(firstChangedLine, linesToDelete, linesToAdd, false);
-      } else {
-        // No lines added or removed
-        for (var line = 0; line < this.lineElements.length; line++) {
-          var e = this.lineElements[line];
-          var ct = e.textContent;
-
-          if (this.lines[line] !== ct) {
-            // Line changed, update it
-            this.lines[line] = ct;
-            this.lineDirty[line] = true;
-          }
-        }
-      }
+    // Empty the stack, any opening delimiters are unused
+    while (stack.length) {
+      const entry = stack.pop();
+      processed = `${entry.output}${entry.delimString.substr(0, entry.count)}${processed}`;
     }
-    /**
-     * Processes a new paragraph.
-     * @param sel The current selection
-     */
-
-  }, {
-    key: "processNewParagraph",
-    value: function processNewParagraph(sel) {
-      if (!sel) return; // Update lines from content
-
-      this.updateLineContents();
-      var continuableType = false; // Let's see if we need to continue a list
-
-      var checkLine = sel.col > 0 ? sel.row : sel.row - 1;
-
-      switch (this.lineTypes[checkLine]) {
-        case 'TMUL':
-          continuableType = 'TMUL';
-          break;
+    return processed;
+  }
 
-        case 'TMOL':
-          continuableType = 'TMOL';
-          break;
+  /** 
+   * Clears the line dirty flag (resets it to an array of false)
+   */
+  clearDirtyFlag() {
+    this.lineDirty = new Array(this.lines.length);
+    for (let i = 0; i < this.lineDirty.length; i++) {
+      this.lineDirty[i] = false;
+    }
+  }
 
-        case 'TMIndentedCode':
-          continuableType = 'TMIndentedCode';
-          break;
+  /**
+   * Updates the class properties (lines, lineElements) from the DOM.
+   * @returns true if contents changed
+   */
+  updateLineContents() {
+    // this.lineDirty = []; 
+    // Check if we have changed anything about the number of lines (inserted or deleted a paragraph)
+    // < 0 means line(s) removed; > 0 means line(s) added
+    let lineDelta = this.e.childElementCount - this.lines.length;
+    if (lineDelta) {
+      // yup. Let's try how much we can salvage (find out which lines from beginning and end were unchanged)
+      // Find lines from the beginning that haven't changed...
+      let firstChangedLine = 0;
+      while (firstChangedLine <= this.lines.length && firstChangedLine <= this.lineElements.length && this.lineElements[firstChangedLine] // Check that the line element hasn't been deleted
+      && this.lines[firstChangedLine] == this.lineElements[firstChangedLine].textContent) {
+        firstChangedLine++;
       }
 
-      var lines = this.lines[sel.row].replace(/\n\n$/, '\n').split(/(?:\r\n|\n|\r)/);
-
-      if (lines.length == 1) {
-        // No new line
-        this.updateFormatting();
-        return;
+      // End also from the end
+      let lastChangedLine = -1;
+      while (-lastChangedLine < this.lines.length && -lastChangedLine < this.lineElements.length && this.lines[this.lines.length + lastChangedLine] == this.lineElements[this.lineElements.length + lastChangedLine].textContent) {
+        lastChangedLine--;
       }
-
-      this.spliceLines(sel.row, 1, lines, true);
-      sel.row++;
-      sel.col = 0;
-
-      if (continuableType) {
-        // Check if the previous line was non-empty
-        var capture = _grammar.lineGrammar[continuableType].regexp.exec(this.lines[sel.row - 1]);
-
-        if (capture) {
-          // Convention: capture[1] is the line type marker, capture[2] is the content
-          if (capture[2]) {
-            // Previous line has content, continue the continuable type
-            // Hack for OL: increment number
-            if (continuableType == 'TMOL') {
-              capture[1] = capture[1].replace(/\d{1,9}/, function (result) {
-                return parseInt(result[0]) + 1;
-              });
-            }
-
-            this.lines[sel.row] = "".concat(capture[1]).concat(this.lines[sel.row]);
-            this.lineDirty[sel.row] = true;
-            sel.col = capture[1].length;
-          } else {
-            // Previous line has no content, remove the continuable type from the previous row
-            this.lines[sel.row - 1] = '';
-            this.lineDirty[sel.row - 1] = true;
-          }
+      let linesToDelete = this.lines.length + lastChangedLine + 1 - firstChangedLine;
+      if (linesToDelete < -lineDelta) linesToDelete = -lineDelta;
+      if (linesToDelete < 0) linesToDelete = 0;
+      let linesToAdd = [];
+      for (let l = 0; l < linesToDelete + lineDelta; l++) {
+        linesToAdd.push(this.lineElements[firstChangedLine + l].textContent);
+      }
+      this.spliceLines(firstChangedLine, linesToDelete, linesToAdd, false);
+    } else {
+      // No lines added or removed
+      for (let line = 0; line < this.lineElements.length; line++) {
+        let e = this.lineElements[line];
+        let ct = e.textContent;
+        if (this.lines[line] !== ct) {
+          // Line changed, update it
+          this.lines[line] = ct;
+          this.lineDirty[line] = true;
         }
       }
+    }
+  }
 
+  /**
+   * Processes a new paragraph.
+   * @param sel The current selection
+   */
+  processNewParagraph(sel) {
+    if (!sel) return;
+
+    // Update lines from content
+    this.updateLineContents();
+    let continuableType = false;
+    // Let's see if we need to continue a list
+
+    let checkLine = sel.col > 0 ? sel.row : sel.row - 1;
+    switch (this.lineTypes[checkLine]) {
+      case 'TMUL':
+        continuableType = 'TMUL';
+        break;
+      case 'TMOL':
+        continuableType = 'TMOL';
+        break;
+      case 'TMIndentedCode':
+        continuableType = 'TMIndentedCode';
+        break;
+    }
+    let lines = this.lines[sel.row].replace(/\n\n$/, '\n').split(/(?:\r\n|\n|\r)/);
+    if (lines.length == 1) {
+      // No new line
       this.updateFormatting();
-    } // /**
-    //  * Processes a "delete" input action.
-    //  * @param {object} focus The selection
-    //  * @param {boolean} forward If true, performs a forward delete, otherwise performs a backward delete
-    //  */
-    // processDelete(focus, forward) {
-    //   if (!focus) return;
-    //   let anchor = this.getSelection(true);
-    //   // Do we have a non-empty selection? 
-    //   if (focus.col != anchor.col || focus.row != anchor.row) {
-    //     // non-empty. direction doesn't matter.
-    //     this.paste('', anchor, focus);
-    //   } else {
-    //     if (forward) {
-    //       if (focus.col < this.lines[focus.row].length) this.paste('', {row: focus.row, col: focus.col + 1}, focus);
-    //       else if (focus.col < this.lines.length) this.paste('', {row: focus.row + 1, col: 0}, focus);
-    //       // Otherwise, we're at the very end and can't delete forward
-    //     } else {
-    //       if (focus.col > 0) this.paste('', {row: focus.row, col: focus.col - 1}, focus);
-    //       else if (focus.row > 0) this.paste('', {row: focus.row - 1, col: this.lines[focus.row - 1].length - 1}, focus);
-    //       // Otherwise, we're at the very beginning and can't delete backwards
-    //     }
-    //   }
-    // }
-
-    /**
-     * Gets the current position of the selection counted by row and column of the editor Markdown content (as opposed to the position in the DOM).
-     * 
-     * @param {boolean} getAnchor if set to true, gets the selection anchor (start point of the selection), otherwise gets the focus (end point).
-     * @return {object} An object representing the selection, with properties col and row.
-     */
-
-  }, {
-    key: "getSelection",
-    value: function getSelection() {
-      var getAnchor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-      var selection = window.getSelection();
-      var startNode = getAnchor ? selection.anchorNode : selection.focusNode;
-      if (!startNode) return null;
-      var offset = startNode.nodeType === Node.TEXT_NODE ? getAnchor ? selection.anchorOffset : selection.focusOffset : 0;
-
-      if (startNode == this.e) {
-        return {
-          row: 0,
-          col: offset
-        };
-      }
-
-      var col = this.computeColumn(startNode, offset);
-      if (col === null) return null; // We are outside of the editor
-      // Find the row node
-
-      var node = startNode;
-
-      while (node.parentElement != this.e) {
-        node = node.parentElement;
-      }
-
-      var row = 0; // Check if we can read a line number from the data-line-num attribute.
-      // The last condition is a security measure since inserting a new paragraph copies the previous rows' line number
-
-      if (node.dataset && node.dataset.lineNum && (!node.previousSibling || node.previousSibling.dataset.lineNum != node.dataset.lineNum)) {
-        row = parseInt(node.dataset.lineNum);
-      } else {
-        while (node.previousSibling) {
-          row++;
-          node = node.previousSibling;
+      return;
+    }
+    this.spliceLines(sel.row, 1, lines, true);
+    sel.row++;
+    sel.col = 0;
+    if (continuableType) {
+      // Check if the previous line was non-empty
+      let capture = _grammar.lineGrammar[continuableType].regexp.exec(this.lines[sel.row - 1]);
+      if (capture) {
+        // Convention: capture[1] is the line type marker, capture[2] is the content
+        if (capture[2]) {
+          // Previous line has content, continue the continuable type
+
+          // Hack for OL: increment number
+          if (continuableType == 'TMOL') {
+            capture[1] = capture[1].replace(/\d{1,9}/, result => {
+              return parseInt(result[0]) + 1;
+            });
+          }
+          this.lines[sel.row] = `${capture[1]}${this.lines[sel.row]}`;
+          this.lineDirty[sel.row] = true;
+          sel.col = capture[1].length;
+        } else {
+          // Previous line has no content, remove the continuable type from the previous row
+          this.lines[sel.row - 1] = '';
+          this.lineDirty[sel.row - 1] = true;
         }
       }
+    }
+    this.updateFormatting();
+  }
 
+  // /**
+  //  * Processes a "delete" input action.
+  //  * @param {object} focus The selection
+  //  * @param {boolean} forward If true, performs a forward delete, otherwise performs a backward delete
+  //  */
+  // processDelete(focus, forward) {
+  //   if (!focus) return;
+  //   let anchor = this.getSelection(true);
+  //   // Do we have a non-empty selection? 
+  //   if (focus.col != anchor.col || focus.row != anchor.row) {
+  //     // non-empty. direction doesn't matter.
+  //     this.paste('', anchor, focus);
+  //   } else {
+  //     if (forward) {
+  //       if (focus.col < this.lines[focus.row].length) this.paste('', {row: focus.row, col: focus.col + 1}, focus);
+  //       else if (focus.col < this.lines.length) this.paste('', {row: focus.row + 1, col: 0}, focus);
+  //       // Otherwise, we're at the very end and can't delete forward
+  //     } else {
+  //       if (focus.col > 0) this.paste('', {row: focus.row, col: focus.col - 1}, focus);
+  //       else if (focus.row > 0) this.paste('', {row: focus.row - 1, col: this.lines[focus.row - 1].length - 1}, focus);
+  //       // Otherwise, we're at the very beginning and can't delete backwards
+  //     }
+  //   }
+
+  // }
+
+  /**
+   * Gets the current position of the selection counted by row and column of the editor Markdown content (as opposed to the position in the DOM).
+   * 
+   * @param {boolean} getAnchor if set to true, gets the selection anchor (start point of the selection), otherwise gets the focus (end point).
+   * @return {object} An object representing the selection, with properties col and row.
+   */
+  getSelection() {
+    let getAnchor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    const selection = window.getSelection();
+    let startNode = getAnchor ? selection.anchorNode : selection.focusNode;
+    if (!startNode) return null;
+    let offset = startNode.nodeType === Node.TEXT_NODE ? getAnchor ? selection.anchorOffset : selection.focusOffset : 0;
+    if (startNode == this.e) {
       return {
-        row: row,
-        col: col,
-        node: startNode
+        row: 0,
+        col: offset
       };
     }
-    /**
-     * Computes a column within an editor line from a node and offset within that node.
-     * @param {Node} startNode The node
-     * @param {int} offset THe selection
-     * @returns {int} the column, or null if the node is not inside the editor
-     */
-
-  }, {
-    key: "computeColumn",
-    value: function computeColumn(startNode, offset) {
-      var node = startNode;
-      var col = offset; // First, make sure we're actually in the editor.
-
-      while (node && node.parentNode != this.e) {
-        node = node.parentNode;
-      }
-
-      if (node == null) return null;
-      node = startNode;
-
-      while (node.parentNode != this.e) {
-        if (node.previousSibling) {
-          node = node.previousSibling;
-          col += node.textContent.length;
-        } else {
-          node = node.parentNode;
-        }
-      }
+    let col = this.computeColumn(startNode, offset);
+    if (col === null) return null; // We are outside of the editor
 
-      return col;
+    // Find the row node
+    let node = startNode;
+    while (node.parentElement != this.e) {
+      node = node.parentElement;
     }
-    /**
-     * Computes DOM node and offset within that node from a position expressed as row and column.
-     * @param {int} row Row (line number)
-     * @param {int} col Column
-     * @returns An object with two properties: node and offset. offset may be null;
-     */
-
-  }, {
-    key: "computeNodeAndOffset",
-    value: function computeNodeAndOffset(row, col) {
-      var bindRight = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-
-      if (row >= this.lineElements.length) {
-        // Selection past the end of text, set selection to end of text
-        row = this.lineElements.length - 1;
-        col = this.lines[row].length;
+    let row = 0;
+    // Check if we can read a line number from the data-line-num attribute.
+    // The last condition is a security measure since inserting a new paragraph copies the previous rows' line number
+    if (node.dataset && node.dataset.lineNum && (!node.previousSibling || node.previousSibling.dataset.lineNum != node.dataset.lineNum)) {
+      row = parseInt(node.dataset.lineNum);
+    } else {
+      while (node.previousSibling) {
+        row++;
+        node = node.previousSibling;
       }
+    }
+    return {
+      row: row,
+      col: col,
+      node: startNode
+    };
+  }
 
-      if (col > this.lines[row].length) {
-        col = this.lines[row].length;
+  /**
+   * Computes a column within an editor line from a node and offset within that node.
+   * @param {Node} startNode The node
+   * @param {int} offset THe selection
+   * @returns {int} the column, or null if the node is not inside the editor
+   */
+  computeColumn(startNode, offset) {
+    let node = startNode;
+    let col = offset;
+    // First, make sure we're actually in the editor.
+    while (node && node.parentNode != this.e) {
+      node = node.parentNode;
+    }
+    if (node == null) return null;
+    node = startNode;
+    while (node.parentNode != this.e) {
+      if (node.previousSibling) {
+        node = node.previousSibling;
+        col += node.textContent.length;
+      } else {
+        node = node.parentNode;
       }
+    }
+    return col;
+  }
 
-      var parentNode = this.lineElements[row];
-      var node = parentNode.firstChild;
-      var childrenComplete = false; // default return value
-
-      var rv = {
-        node: parentNode.firstChild ? parentNode.firstChild : parentNode,
-        offset: 0
-      };
-
-      while (node != parentNode) {
-        if (!childrenComplete && node.nodeType === Node.TEXT_NODE) {
-          if (node.nodeValue.length >= col) {
-            if (bindRight && node.nodeValue.length == col) {
-              // Selection is at the end of this text node, but we are binding right (prefer an offset of 0 in the next text node)
-              // Remember return value in case we don't find another text node
-              rv = {
-                node: node,
-                offset: col
-              };
-              col = 0;
-            } else {
-              return {
-                node: node,
-                offset: col
-              };
-            }
+  /**
+   * Computes DOM node and offset within that node from a position expressed as row and column.
+   * @param {int} row Row (line number)
+   * @param {int} col Column
+   * @returns An object with two properties: node and offset. offset may be null;
+   */
+  computeNodeAndOffset(row, col) {
+    let bindRight = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    if (row >= this.lineElements.length) {
+      // Selection past the end of text, set selection to end of text
+      row = this.lineElements.length - 1;
+      col = this.lines[row].length;
+    }
+    if (col > this.lines[row].length) {
+      col = this.lines[row].length;
+    }
+    const parentNode = this.lineElements[row];
+    let node = parentNode.firstChild;
+    let childrenComplete = false;
+    // default return value
+    let rv = {
+      node: parentNode.firstChild ? parentNode.firstChild : parentNode,
+      offset: 0
+    };
+    while (node != parentNode) {
+      if (!childrenComplete && node.nodeType === Node.TEXT_NODE) {
+        if (node.nodeValue.length >= col) {
+          if (bindRight && node.nodeValue.length == col) {
+            // Selection is at the end of this text node, but we are binding right (prefer an offset of 0 in the next text node)
+            // Remember return value in case we don't find another text node
+            rv = {
+              node: node,
+              offset: col
+            };
+            col = 0;
           } else {
-            col -= node.nodeValue.length;
+            return {
+              node: node,
+              offset: col
+            };
           }
-        }
-
-        if (!childrenComplete && node.firstChild) {
-          node = node.firstChild;
-        } else if (node.nextSibling) {
-          childrenComplete = false;
-          node = node.nextSibling;
         } else {
-          childrenComplete = true;
-          node = node.parentNode;
+          col -= node.nodeValue.length;
         }
-      } // Either, the position was invalid and we just return the default return value
-      // Or we are binding right and the selection is at the end of the line
-
-
-      return rv;
+      }
+      if (!childrenComplete && node.firstChild) {
+        node = node.firstChild;
+      } else if (node.nextSibling) {
+        childrenComplete = false;
+        node = node.nextSibling;
+      } else {
+        childrenComplete = true;
+        node = node.parentNode;
+      }
     }
-    /**
-     * Sets the selection based on rows and columns within the editor Markdown content.
-     * @param {object} focus Object representing the selection, needs to have properties row and col.
-     */
-
-  }, {
-    key: "setSelection",
-    value: function setSelection(focus) {
-      var anchor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-      if (!focus) return;
-      var range = document.createRange();
 
-      var _this$computeNodeAndO = this.computeNodeAndOffset(focus.row, focus.col, anchor && anchor.row == focus.row && anchor.col > focus.col),
-          focusNode = _this$computeNodeAndO.node,
-          focusOffset = _this$computeNodeAndO.offset; // Bind selection right if anchor is in the same row and behind the focus
-
-
-      var anchorNode = null,
-          anchorOffset = null;
-
-      if (anchor && (anchor.row != focus.row || anchor.col != focus.col)) {
-        var _this$computeNodeAndO2 = this.computeNodeAndOffset(anchor.row, anchor.col, focus.row == anchor.row && focus.col > anchor.col),
-            node = _this$computeNodeAndO2.node,
-            offset = _this$computeNodeAndO2.offset;
-
-        anchorNode = node;
-        anchorOffset = offset;
-      }
+    // Either, the position was invalid and we just return the default return value
+    // Or we are binding right and the selection is at the end of the line
+    return rv;
+  }
 
-      if (anchorNode) range.setStart(anchorNode, anchorOffset);else range.setStart(focusNode, focusOffset);
-      range.setEnd(focusNode, focusOffset);
-      var windowSelection = window.getSelection();
-      windowSelection.removeAllRanges();
-      windowSelection.addRange(range);
+  /**
+   * Sets the selection based on rows and columns within the editor Markdown content.
+   * @param {object} focus Object representing the selection, needs to have properties row and col.
+   */
+  setSelection(focus) {
+    let anchor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    if (!focus) return;
+    let range = document.createRange();
+    let {
+      node: focusNode,
+      offset: focusOffset
+    } = this.computeNodeAndOffset(focus.row, focus.col, anchor && anchor.row == focus.row && anchor.col > focus.col); // Bind selection right if anchor is in the same row and behind the focus
+    let anchorNode = null,
+      anchorOffset = null;
+    if (anchor && (anchor.row != focus.row || anchor.col != focus.col)) {
+      let {
+        node,
+        offset
+      } = this.computeNodeAndOffset(anchor.row, anchor.col, focus.row == anchor.row && focus.col > anchor.col);
+      anchorNode = node;
+      anchorOffset = offset;
     }
-    /** 
-     * Event handler for input events 
-     */
-
-  }, {
-    key: "handleInputEvent",
-    value: function handleInputEvent(event) {
-      var focus = this.getSelection();
-
-      if ((event.inputType == 'insertParagraph' || event.inputType == 'insertLineBreak') && focus) {
-        this.clearDirtyFlag();
-        this.processNewParagraph(focus);
+    if (anchorNode) range.setStart(anchorNode, anchorOffset);else range.setStart(focusNode, focusOffset);
+    range.setEnd(focusNode, focusOffset);
+    let windowSelection = window.getSelection();
+    windowSelection.removeAllRanges();
+    windowSelection.addRange(range);
+  }
+
+  /** 
+   * Event handler for input events 
+   */
+  handleInputEvent(event) {
+    let focus = this.getSelection();
+    if ((event.inputType == 'insertParagraph' || event.inputType == 'insertLineBreak') && focus) {
+      this.clearDirtyFlag();
+      this.processNewParagraph(focus);
+    } else {
+      if (!this.e.firstChild) {
+        this.e.innerHTML = '<div class="TMBlankLine"><br></div>';
       } else {
-        if (!this.e.firstChild) {
-          this.e.innerHTML = '<div class="TMBlankLine"><br></div>';
-        } else {
-          for (var childNode = this.e.firstChild; childNode; childNode = childNode.nextSibling) {
-            if (childNode.nodeType != 3 || childNode.tagName != 'DIV') {
-              // Found a child node that's either not an element or not a div. Wrap it in a div.
-              var divWrapper = document.createElement('div');
-              this.e.insertBefore(divWrapper, childNode);
-              this.e.removeChild(childNode);
-              divWrapper.appendChild(childNode);
-            }
+        for (let childNode = this.e.firstChild; childNode; childNode = childNode.nextSibling) {
+          if (childNode.nodeType != 3 || childNode.tagName != 'DIV') {
+            // Found a child node that's either not an element or not a div. Wrap it in a div.
+            let divWrapper = document.createElement('div');
+            this.e.insertBefore(divWrapper, childNode);
+            this.e.removeChild(childNode);
+            divWrapper.appendChild(childNode);
           }
         }
-
-        this.updateLineContentsAndFormatting();
       }
-
-      if (focus) this.setSelection(focus);
-      this.fireChange();
+      this.updateLineContentsAndFormatting();
     }
-    /**
-     * Event handler for "selectionchange" events.
-     */
-
-  }, {
-    key: "handleSelectionChangeEvent",
-    value: function handleSelectionChangeEvent() {
-      this.fireSelection();
-    }
-    /**
-     * Convenience function to "splice" new lines into the arrays this.lines, this.lineDirty, this.lineTypes, and the DOM elements 
-     * underneath the editor element.
-     * This method is essentially Array.splice, only that the third parameter takes an un-spread array (and the forth parameter)
-     * determines whether the DOM should also be adjusted.
-     * 
-     * @param {int} startLine Position at which to start changing the array of lines
-     * @param {int} linesToDelete Number of lines to delete
-     * @param {array} linesToInsert Array of strings representing the lines to be inserted
-     * @param {boolean} adjustLineElements If true, then <div> elements are also inserted in the DOM at the respective position
-     */
-
-  }, {
-    key: "spliceLines",
-    value: function spliceLines(startLine) {
-      var _this$lines, _this$lineTypes, _this$lineDirty;
-
-      var linesToDelete = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-      var linesToInsert = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-      var adjustLineElements = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+    if (focus) this.setSelection(focus);
+    this.fireChange();
+  }
+
+  /**
+   * Event handler for "selectionchange" events.
+   */
+  handleSelectionChangeEvent() {
+    this.fireSelection();
+  }
 
+  /**
+   * Convenience function to "splice" new lines into the arrays this.lines, this.lineDirty, this.lineTypes, and the DOM elements 
+   * underneath the editor element.
+   * This method is essentially Array.splice, only that the third parameter takes an un-spread array (and the forth parameter)
+   * determines whether the DOM should also be adjusted.
+   * 
+   * @param {int} startLine Position at which to start changing the array of lines
+   * @param {int} linesToDelete Number of lines to delete
+   * @param {array} linesToInsert Array of strings representing the lines to be inserted
+   * @param {boolean} adjustLineElements If true, then <div> elements are also inserted in the DOM at the respective position
+   */
+  spliceLines(startLine) {
+    let linesToDelete = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    let linesToInsert = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    let adjustLineElements = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+    if (adjustLineElements) {
+      for (let i = 0; i < linesToDelete; i++) {
+        this.e.removeChild(this.e.childNodes[startLine]);
+      }
+    }
+    let insertedBlank = [];
+    let insertedDirty = [];
+    for (let i = 0; i < linesToInsert.length; i++) {
+      insertedBlank.push('');
+      insertedDirty.push(true);
       if (adjustLineElements) {
-        for (var i = 0; i < linesToDelete; i++) {
-          this.e.removeChild(this.e.childNodes[startLine]);
-        }
+        if (this.e.childNodes[startLine]) this.e.insertBefore(document.createElement('div'), this.e.childNodes[startLine]);else this.e.appendChild(document.createElement('div'));
       }
+    }
+    this.lines.splice(startLine, linesToDelete, ...linesToInsert);
+    this.lineTypes.splice(startLine, linesToDelete, ...insertedBlank);
+    this.lineDirty.splice(startLine, linesToDelete, ...insertedDirty);
+  }
 
-      var insertedBlank = [];
-      var insertedDirty = [];
-
-      for (var _i3 = 0; _i3 < linesToInsert.length; _i3++) {
-        insertedBlank.push('');
-        insertedDirty.push(true);
-
-        if (adjustLineElements) {
-          if (this.e.childNodes[startLine]) this.e.insertBefore(document.createElement('div'), this.e.childNodes[startLine]);else this.e.appendChild(document.createElement('div'));
-        }
-      }
+  /**
+   * Event handler for the "paste" event
+   */
+  handlePaste(event) {
+    event.preventDefault();
 
-      (_this$lines = this.lines).splice.apply(_this$lines, [startLine, linesToDelete].concat(_toConsumableArray(linesToInsert)));
+    // get text representation of clipboard
+    let text = (event.originalEvent || event).clipboardData.getData('text/plain');
 
-      (_this$lineTypes = this.lineTypes).splice.apply(_this$lineTypes, [startLine, linesToDelete].concat(insertedBlank));
+    // insert text manually
+    this.paste(text);
+  }
 
-      (_this$lineDirty = this.lineDirty).splice.apply(_this$lineDirty, [startLine, linesToDelete].concat(insertedDirty));
+  /**
+   * Pastes the text at the current selection (or at the end, if no current selection)
+   * @param {string} text 
+   */
+  paste(text) {
+    let anchor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    let focus = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    if (!anchor) anchor = this.getSelection(true);
+    if (!focus) focus = this.getSelection(false);
+    let beginning, end;
+    if (!focus) {
+      focus = {
+        row: this.lines.length - 1,
+        col: this.lines[this.lines.length - 1].length
+      }; // Insert at end
     }
-    /**
-     * Event handler for the "paste" event
-     */
-
-  }, {
-    key: "handlePaste",
-    value: function handlePaste(event) {
-      event.preventDefault(); // get text representation of clipboard
 
-      var text = (event.originalEvent || event).clipboardData.getData('text/plain'); // insert text manually
-
-      this.paste(text);
+    if (!anchor) {
+      anchor = focus;
     }
-    /**
-     * Pastes the text at the current selection (or at the end, if no current selection)
-     * @param {string} text 
-     */
-
-  }, {
-    key: "paste",
-    value: function paste(text) {
-      var anchor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-      var focus = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-      if (!anchor) anchor = this.getSelection(true);
-      if (!focus) focus = this.getSelection(false);
-      var beginning, end;
-
-      if (!focus) {
-        focus = {
-          row: this.lines.length - 1,
-          col: this.lines[this.lines.length - 1].length
-        }; // Insert at end
-      }
-
-      if (!anchor) {
-        anchor = focus;
-      }
+    if (anchor.row < focus.row || anchor.row == focus.row && anchor.col <= focus.col) {
+      beginning = anchor;
+      end = focus;
+    } else {
+      beginning = focus;
+      end = anchor;
+    }
+    let insertedLines = text.split(/(?:\r\n|\r|\n)/);
+    let lineBefore = this.lines[beginning.row].substr(0, beginning.col);
+    let lineEnd = this.lines[end.row].substr(end.col);
+    insertedLines[0] = lineBefore.concat(insertedLines[0]);
+    let endColPos = insertedLines[insertedLines.length - 1].length;
+    insertedLines[insertedLines.length - 1] = insertedLines[insertedLines.length - 1].concat(lineEnd);
+    this.spliceLines(beginning.row, 1 + end.row - beginning.row, insertedLines);
+    focus.row = beginning.row + insertedLines.length - 1;
+    focus.col = endColPos;
+    this.updateFormatting();
+    this.setSelection(focus);
+    this.fireChange();
+  }
 
-      if (anchor.row < focus.row || anchor.row == focus.row && anchor.col <= focus.col) {
-        beginning = anchor;
-        end = focus;
-      } else {
-        beginning = focus;
-        end = anchor;
+  /**
+   * Computes the (lowest in the DOM tree) common ancestor of two DOM nodes.
+   * @param {Node} node1 the first node
+   * @param {Node} node2 the second node
+   * @returns {Node} The commen ancestor node, or null if there is no common ancestor
+   */
+  computeCommonAncestor(node1, node2) {
+    if (!node1 || !node2) return null;
+    if (node1 == node2) return node1;
+    const ancestry = node => {
+      let ancestry = [];
+      while (node) {
+        ancestry.unshift(node);
+        node = node.parentNode;
       }
+      return ancestry;
+    };
+    const ancestry1 = ancestry(node1);
+    const ancestry2 = ancestry(node2);
+    if (ancestry1[0] != ancestry2[0]) return null;
+    let i;
+    for (i = 0; ancestry1[i] == ancestry2[i]; i++);
+    return ancestry1[i - 1];
+  }
 
-      var insertedLines = text.split(/(?:\r\n|\r|\n)/);
-      var lineBefore = this.lines[beginning.row].substr(0, beginning.col);
-      var lineEnd = this.lines[end.row].substr(end.col);
-      insertedLines[0] = lineBefore.concat(insertedLines[0]);
-      var endColPos = insertedLines[insertedLines.length - 1].length;
-      insertedLines[insertedLines.length - 1] = insertedLines[insertedLines.length - 1].concat(lineEnd);
-      this.spliceLines(beginning.row, 1 + end.row - beginning.row, insertedLines);
-      focus.row = beginning.row + insertedLines.length - 1;
-      focus.col = endColPos;
-      this.updateFormatting();
-      this.setSelection(focus);
-      this.fireChange();
+  /**
+   * Finds the (lowest in the DOM tree) enclosing DOM node with a given class.
+   * @param {object} focus The focus selection object
+   * @param {object} anchor The anchor selection object
+   * @param {string} className The class name to find
+   * @returns {Node} The enclosing DOM node with the respective class (inside the editor), if there is one; null otherwise.
+   */
+  computeEnclosingMarkupNode(focus, anchor, className) {
+    let node = null;
+    if (!focus) return null;
+    if (!anchor) {
+      node = focus.node;
+    } else {
+      if (focus.row != anchor.row) return null;
+      node = this.computeCommonAncestor(focus.node, anchor.node);
     }
-    /**
-     * Computes the (lowest in the DOM tree) common ancestor of two DOM nodes.
-     * @param {Node} node1 the first node
-     * @param {Node} node2 the second node
-     * @returns {Node} The commen ancestor node, or null if there is no common ancestor
-     */
-
-  }, {
-    key: "computeCommonAncestor",
-    value: function computeCommonAncestor(node1, node2) {
-      if (!node1 || !node2) return null;
-      if (node1 == node2) return node1;
-
-      var ancestry = function ancestry(node) {
-        var ancestry = [];
-
-        while (node) {
-          ancestry.unshift(node);
-          node = node.parentNode;
-        }
-
-        return ancestry;
-      };
-
-      var ancestry1 = ancestry(node1);
-      var ancestry2 = ancestry(node2);
-      if (ancestry1[0] != ancestry2[0]) return null;
-      var i;
+    if (!node) return null;
+    while (node != this.e) {
+      if (node.className && node.className.includes(className)) return node;
+      node = node.parentNode;
+    }
+    // Ascended all the way to the editor element
+    return null;
+  }
 
-      for (i = 0; ancestry1[i] == ancestry2[i]; i++) {
-        ;
+  /**
+   * Returns the state (true / false) of all commands.
+   * @param focus Focus of the selection. If not given, assumes the current focus.
+   */
+  getCommandState() {
+    let focus = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    let anchor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    let commandState = {};
+    if (!focus) focus = this.getSelection(false);
+    if (!anchor) anchor = this.getSelection(true);
+    if (!focus) {
+      for (let cmd in _grammar.commands) {
+        commandState[cmd] = null;
       }
-
-      return ancestry1[i - 1];
+      return commandState;
+    }
+    if (!anchor) anchor = focus;
+    let start, end;
+    if (anchor.row < focus.row || anchor.row == focus.row && anchor.col < focus.col) {
+      start = anchor;
+      end = focus;
+    } else {
+      start = focus;
+      end = anchor;
+    }
+    if (end.row > start.row && end.col == 0) {
+      end.row--;
+      end.col = this.lines[end.row].length; // Selection to beginning of next line is said to end at the beginning of the last line
     }
-    /**
-     * Finds the (lowest in the DOM tree) enclosing DOM node with a given class.
-     * @param {object} focus The focus selection object
-     * @param {object} anchor The anchor selection object
-     * @param {string} className The class name to find
-     * @returns {Node} The enclosing DOM node with the respective class (inside the editor), if there is one; null otherwise.
-     */
-
-  }, {
-    key: "computeEnclosingMarkupNode",
-    value: function computeEnclosingMarkupNode(focus, anchor, className) {
-      var node = null;
-      if (!focus) return null;
-
-      if (!anchor) {
-        node = focus.node;
-      } else {
-        if (focus.row != anchor.row) return null;
-        node = this.computeCommonAncestor(focus.node, anchor.node);
-      }
-
-      if (!node) return null;
-
-      while (node != this.e) {
-        if (node.className && node.className.includes(className)) return node;
-        node = node.parentNode;
-      } // Ascended all the way to the editor element
 
+    for (let cmd in _grammar.commands) {
+      if (_grammar.commands[cmd].type == 'inline') {
+        if (!focus || focus.row != anchor.row || !this.isInlineFormattingAllowed(focus, anchor)) {
+          commandState[cmd] = null;
+        } else {
+          // The command state is true if there is a respective enclosing markup node (e.g., the selection is enclosed in a <b>..</b>) ... 
+          commandState[cmd] = !!this.computeEnclosingMarkupNode(focus, anchor, _grammar.commands[cmd].className) ||
+          // ... or if it's an empty string preceded by and followed by formatting markers, e.g. **|** where | is the cursor
 
-      return null;
-    }
-    /**
-     * Returns the state (true / false) of all commands.
-     * @param focus Focus of the selection. If not given, assumes the current focus.
-     */
-
-  }, {
-    key: "getCommandState",
-    value: function getCommandState() {
-      var focus = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-      var anchor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-      var commandState = {};
-      if (!focus) focus = this.getSelection(false);
-      if (!anchor) anchor = this.getSelection(true);
-
-      if (!focus) {
-        for (var cmd in _grammar.commands) {
+          focus.col == anchor.col && !!this.lines[focus.row].substr(0, focus.col).match(_grammar.commands[cmd].unset.prePattern) && !!this.lines[focus.row].substr(focus.col).match(_grammar.commands[cmd].unset.postPattern);
+        }
+      }
+      if (_grammar.commands[cmd].type == 'line') {
+        if (!focus) {
           commandState[cmd] = null;
+        } else {
+          let state = this.lineTypes[start.row] == _grammar.commands[cmd].className;
+          for (let line = start.row; line <= end.row; line++) {
+            if (this.lineTypes[line] == _grammar.commands[cmd].className != state) {
+              state = null;
+              break;
+            }
+          }
+          commandState[cmd] = state;
         }
-
-        return commandState;
       }
+    }
+    return commandState;
+  }
 
+  /**
+   * Sets a command state
+   * @param {string} command 
+   * @param {boolean} state 
+   */
+  setCommandState(command, state) {
+    if (_grammar.commands[command].type == 'inline') {
+      let anchor = this.getSelection(true);
+      let focus = this.getSelection(false);
       if (!anchor) anchor = focus;
-      var start, end;
+      if (!anchor) return;
+      if (anchor.row != focus.row) return;
+      if (!this.isInlineFormattingAllowed(focus, anchor)) return;
+      let markupNode = this.computeEnclosingMarkupNode(focus, anchor, _grammar.commands[command].className);
+      this.clearDirtyFlag();
+
+      // First case: There's an enclosing markup node, remove the markers around that markup node
+      if (markupNode) {
+        this.lineDirty[focus.row] = true;
+        const startCol = this.computeColumn(markupNode, 0);
+        const len = markupNode.textContent.length;
+        const left = this.lines[focus.row].substr(0, startCol).replace(_grammar.commands[command].unset.prePattern, '');
+        const mid = this.lines[focus.row].substr(startCol, len);
+        const right = this.lines[focus.row].substr(startCol + len).replace(_grammar.commands[command].unset.postPattern, '');
+        this.lines[focus.row] = left.concat(mid, right);
+        anchor.col = left.length;
+        focus.col = anchor.col + len;
+        this.updateFormatting();
+        this.setSelection(focus, anchor);
+
+        // Second case: Empty selection with surrounding formatting markers, remove those
+      } else if (focus.col == anchor.col && !!this.lines[focus.row].substr(0, focus.col).match(_grammar.commands[command].unset.prePattern) && !!this.lines[focus.row].substr(focus.col).match(_grammar.commands[command].unset.postPattern)) {
+        this.lineDirty[focus.row] = true;
+        const left = this.lines[focus.row].substr(0, focus.col).replace(_grammar.commands[command].unset.prePattern, '');
+        const right = this.lines[focus.row].substr(focus.col).replace(_grammar.commands[command].unset.postPattern, '');
+        this.lines[focus.row] = left.concat(right);
+        focus.col = anchor.col = left.length;
+        this.updateFormatting();
+        this.setSelection(focus, anchor);
 
-      if (anchor.row < focus.row || anchor.row == focus.row && anchor.col < focus.col) {
-        start = anchor;
-        end = focus;
+        // Not currently formatted, insert formatting markers
       } else {
-        start = focus;
-        end = anchor;
-      }
+        // Trim any spaces from the selection
+        let {
+          startCol,
+          endCol
+        } = focus.col < anchor.col ? {
+          startCol: focus.col,
+          endCol: anchor.col
+        } : {
+          startCol: anchor.col,
+          endCol: focus.col
+        };
+        let match = this.lines[focus.row].substr(startCol, endCol - startCol).match(/^(?<leading>\s*).*\S(?<trailing>\s*)$/);
+        if (match) {
+          startCol += match.groups.leading.length;
+          endCol -= match.groups.trailing.length;
+        }
+        focus.col = startCol;
+        anchor.col = endCol;
 
+        // Just insert markup before and after and hope for the best. 
+        this.wrapSelection(_grammar.commands[command].set.pre, _grammar.commands[command].set.post, focus, anchor);
+        // TODO clean this up so that markup remains properly nested
+      }
+    } else if (_grammar.commands[command].type == 'line') {
+      let anchor = this.getSelection(true);
+      let focus = this.getSelection(false);
+      if (!anchor) anchor = focus;
+      if (!focus) return;
+      this.clearDirtyFlag();
+      let start = anchor.row > focus.row ? focus : anchor;
+      let end = anchor.row > focus.row ? anchor : focus;
       if (end.row > start.row && end.col == 0) {
         end.row--;
-        end.col = this.lines[end.row].length; // Selection to beginning of next line is said to end at the beginning of the last line
       }
-
-      for (var _cmd in _grammar.commands) {
-        if (_grammar.commands[_cmd].type == 'inline') {
-          if (!focus || focus.row != anchor.row || !this.isInlineFormattingAllowed(focus, anchor)) {
-            commandState[_cmd] = null;
-          } else {
-            // The command state is true if there is a respective enclosing markup node (e.g., the selection is enclosed in a <b>..</b>) ... 
-            commandState[_cmd] = !!this.computeEnclosingMarkupNode(focus, anchor, _grammar.commands[_cmd].className) || // ... or if it's an empty string preceded by and followed by formatting markers, e.g. **|** where | is the cursor
-            focus.col == anchor.col && !!this.lines[focus.row].substr(0, focus.col).match(_grammar.commands[_cmd].unset.prePattern) && !!this.lines[focus.row].substr(focus.col).match(_grammar.commands[_cmd].unset.postPattern);
-          }
+      for (let line = start.row; line <= end.row; line++) {
+        if (state && this.lineTypes[line] != _grammar.commands[command].className) {
+          this.lines[line] = this.lines[line].replace(_grammar.commands[command].set.pattern, _grammar.commands[command].set.replacement.replace('$#', line - start.row + 1));
+          this.lineDirty[line] = true;
         }
-
-        if (_grammar.commands[_cmd].type == 'line') {
-          if (!focus) {
-            commandState[_cmd] = null;
-          } else {
-            var state = this.lineTypes[start.row] == _grammar.commands[_cmd].className;
-
-            for (var line = start.row; line <= end.row; line++) {
-              if (this.lineTypes[line] == _grammar.commands[_cmd].className != state) {
-                state = null;
-                break;
-              }
-            }
-
-            commandState[_cmd] = state;
-          }
+        if (!state && this.lineTypes[line] == _grammar.commands[command].className) {
+          this.lines[line] = this.lines[line].replace(_grammar.commands[command].unset.pattern, _grammar.commands[command].unset.replacement);
+          this.lineDirty[line] = true;
         }
       }
-
-      return commandState;
+      this.updateFormatting();
+      this.setSelection({
+        row: end.row,
+        col: this.lines[end.row].length
+      }, {
+        row: start.row,
+        col: 0
+      });
     }
-    /**
-     * Sets a command state
-     * @param {string} command 
-     * @param {boolean} state 
-     */
-
-  }, {
-    key: "setCommandState",
-    value: function setCommandState(command, state) {
-      if (_grammar.commands[command].type == 'inline') {
-        var anchor = this.getSelection(true);
-        var focus = this.getSelection(false);
-        if (!anchor) anchor = focus;
-        if (!anchor) return;
-        if (anchor.row != focus.row) return;
-        if (!this.isInlineFormattingAllowed(focus, anchor)) return;
-        var markupNode = this.computeEnclosingMarkupNode(focus, anchor, _grammar.commands[command].className);
-        this.clearDirtyFlag(); // First case: There's an enclosing markup node, remove the markers around that markup node
-
-        if (markupNode) {
-          this.lineDirty[focus.row] = true;
-          var startCol = this.computeColumn(markupNode, 0);
-          var len = markupNode.textContent.length;
-          var left = this.lines[focus.row].substr(0, startCol).replace(_grammar.commands[command].unset.prePattern, '');
-          var mid = this.lines[focus.row].substr(startCol, len);
-          var right = this.lines[focus.row].substr(startCol + len).replace(_grammar.commands[command].unset.postPattern, '');
-          this.lines[focus.row] = left.concat(mid, right);
-          anchor.col = left.length;
-          focus.col = anchor.col + len;
-          this.updateFormatting();
-          this.setSelection(focus, anchor); // Second case: Empty selection with surrounding formatting markers, remove those
-        } else if (focus.col == anchor.col && !!this.lines[focus.row].substr(0, focus.col).match(_grammar.commands[command].unset.prePattern) && !!this.lines[focus.row].substr(focus.col).match(_grammar.commands[command].unset.postPattern)) {
-          this.lineDirty[focus.row] = true;
-
-          var _left = this.lines[focus.row].substr(0, focus.col).replace(_grammar.commands[command].unset.prePattern, '');
-
-          var _right = this.lines[focus.row].substr(focus.col).replace(_grammar.commands[command].unset.postPattern, '');
-
-          this.lines[focus.row] = _left.concat(_right);
-          focus.col = anchor.col = _left.length;
-          this.updateFormatting();
-          this.setSelection(focus, anchor); // Not currently formatted, insert formatting markers
-        } else {
-          // Trim any spaces from the selection
-          var _ref = focus.col < anchor.col ? {
-            startCol: focus.col,
-            endCol: anchor.col
-          } : {
-            startCol: anchor.col,
-            endCol: focus.col
-          },
-              _startCol = _ref.startCol,
-              endCol = _ref.endCol;
-
-          var match = this.lines[focus.row].substr(_startCol, endCol - _startCol).match( /*#__PURE__*/_wrapRegExp(/^([\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]*).*[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uFEFE\uFF00-\uFFFF]([\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]*)$/, {
-            leading: 1,
-            trailing: 2
-          }));
-
-          if (match) {
-            _startCol += match.groups.leading.length;
-            endCol -= match.groups.trailing.length;
-          }
-
-          focus.col = _startCol;
-          anchor.col = endCol; // Just insert markup before and after and hope for the best. 
-
-          this.wrapSelection(_grammar.commands[command].set.pre, _grammar.commands[command].set.post, focus, anchor); // TODO clean this up so that markup remains properly nested
-        }
-      } else if (_grammar.commands[command].type == 'line') {
-        var _anchor = this.getSelection(true);
-
-        var _focus = this.getSelection(false);
-
-        if (!_anchor) _anchor = _focus;
-        if (!_focus) return;
-        this.clearDirtyFlag();
-        var start = _anchor.row > _focus.row ? _focus : _anchor;
-        var end = _anchor.row > _focus.row ? _anchor : _focus;
-
-        if (end.row > start.row && end.col == 0) {
-          end.row--;
-        }
+  }
 
-        for (var line = start.row; line <= end.row; line++) {
-          if (state && this.lineTypes[line] != _grammar.commands[command].className) {
-            this.lines[line] = this.lines[line].replace(_grammar.commands[command].set.pattern, _grammar.commands[command].set.replacement.replace('$#', line - start.row + 1));
-            this.lineDirty[line] = true;
-          }
+  /**
+   * Returns whether or not inline formatting is allowed at the current focus 
+   * @param {object} focus The current focus
+   */
+  isInlineFormattingAllowed() {
+    // TODO Remove parameters from all calls
+    const sel = window.getSelection();
+    if (!sel) return false;
+
+    // Check if we can find a common ancestor with the class `TMInlineFormatted` 
+
+    // Special case: Empty selection right before `TMInlineFormatted`
+    if (sel.isCollapsed && sel.focusNode.nodeType == 3 && sel.focusOffset == sel.focusNode.nodeValue.length) {
+      let node;
+      for (node = sel.focusNode; node && node.nextSibling == null; node = node.parentNode);
+      if (node && node.nextSibling.className && node.nextSibling.className.includes('TMInlineFormatted')) return true;
+    }
 
-          if (!state && this.lineTypes[line] == _grammar.commands[command].className) {
-            this.lines[line] = this.lines[line].replace(_grammar.commands[command].unset.pattern, _grammar.commands[command].unset.replacement);
-            this.lineDirty[line] = true;
-          }
-        }
+    // Look for a common ancestor
+    let ancestor = this.computeCommonAncestor(sel.focusNode, sel.anchorNode);
+    if (!ancestor) return false;
 
-        this.updateFormatting();
-        this.setSelection({
-          row: end.row,
-          col: this.lines[end.row].length
-        }, {
-          row: start.row,
-          col: 0
-        });
-      }
+    // Check if there's an ancestor of class 'TMInlineFormatted' or 'TMBlankLine'
+    while (ancestor && ancestor != this.e) {
+      if (ancestor.className && (ancestor.className.includes('TMInlineFormatted') || ancestor.className.includes('TMBlankLine'))) return true;
+      ancestor = ancestor.parentNode;
     }
-    /**
-     * Returns whether or not inline formatting is allowed at the current focus 
-     * @param {object} focus The current focus
-     */
-
-  }, {
-    key: "isInlineFormattingAllowed",
-    value: function isInlineFormattingAllowed() {
-      // TODO Remove parameters from all calls
-      var sel = window.getSelection();
-      if (!sel) return false; // Check if we can find a common ancestor with the class `TMInlineFormatted` 
-      // Special case: Empty selection right before `TMInlineFormatted`
-
-      if (sel.isCollapsed && sel.focusNode.nodeType == 3 && sel.focusOffset == sel.focusNode.nodeValue.length) {
-        var node;
-
-        for (node = sel.focusNode; node && node.nextSibling == null; node = node.parentNode) {
-          ;
-        }
+    return false;
+  }
 
-        if (node && node.nextSibling.className && node.nextSibling.className.includes('TMInlineFormatted')) return true;
-      } // Look for a common ancestor
+  /**
+   * Wraps the current selection in the strings pre and post. If the selection is not on one line, returns.
+   * @param {string} pre The string to insert before the selection.
+   * @param {string} post The string to insert after the selection.
+   * @param {object} focus The current selection focus. If null, selection will be computed.
+   * @param {object} anchor The current selection focus. If null, selection will be computed.
+   */
+  wrapSelection(pre, post) {
+    let focus = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    let anchor = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+    if (!focus) focus = this.getSelection(false);
+    if (!anchor) anchor = this.getSelection(true);
+    if (!focus || !anchor || focus.row != anchor.row) return;
+    this.lineDirty[focus.row] = true;
+    const startCol = focus.col < anchor.col ? focus.col : anchor.col;
+    const endCol = focus.col < anchor.col ? anchor.col : focus.col;
+    const left = this.lines[focus.row].substr(0, startCol).concat(pre);
+    const mid = endCol == startCol ? '' : this.lines[focus.row].substr(startCol, endCol - startCol);
+    const right = post.concat(this.lines[focus.row].substr(endCol));
+    this.lines[focus.row] = left.concat(mid, right);
+    anchor.col = left.length;
+    focus.col = anchor.col + mid.length;
+    this.updateFormatting();
+    this.setSelection(focus, anchor);
+  }
 
+  /**
+   * Toggles the command state for a command (true <-> false)
+   * @param {string} command The editor command
+   */
+  toggleCommandState(command) {
+    if (!this.lastCommandState) this.lastCommandState = this.getCommandState();
+    this.setCommandState(command, !this.lastCommandState[command]);
+  }
 
-      var ancestor = this.computeCommonAncestor(sel.focusNode, sel.anchorNode);
-      if (!ancestor) return false; // Check if there's an ancestor of class 'TMInlineFormatted' or 'TMBlankLine'
+  /**
+   * Fires a change event. Updates the linked textarea and notifies any event listeners.
+   */
+  fireChange() {
+    if (!this.textarea && !this.listeners.change.length) return;
+    const content = this.getContent();
+    if (this.textarea) this.textarea.value = content;
+    for (let listener of this.listeners.change) {
+      listener({
+        content: content,
+        linesDirty: this.linesDirty
+      });
+    }
+  }
 
-      while (ancestor && ancestor != this.e) {
-        if (ancestor.className && (ancestor.className.includes('TMInlineFormatted') || ancestor.className.includes('TMBlankLine'))) return true;
-        ancestor = ancestor.parentNode;
+  /**
+   * Fires a "selection changed" event.
+   */
+  fireSelection() {
+    if (this.listeners.selection && this.listeners.selection.length) {
+      let focus = this.getSelection(false);
+      let anchor = this.getSelection(true);
+      let commandState = this.getCommandState(focus, anchor);
+      if (this.lastCommandState) {
+        Object.assign(this.lastCommandState, commandState);
+      } else {
+        this.lastCommandState = Object.assign({}, commandState);
       }
-
-      return false;
-    }
-    /**
-     * Wraps the current selection in the strings pre and post. If the selection is not on one line, returns.
-     * @param {string} pre The string to insert before the selection.
-     * @param {string} post The string to insert after the selection.
-     * @param {object} focus The current selection focus. If null, selection will be computed.
-     * @param {object} anchor The current selection focus. If null, selection will be computed.
-     */
-
-  }, {
-    key: "wrapSelection",
-    value: function wrapSelection(pre, post) {
-      var focus = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-      var anchor = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
-      if (!focus) focus = this.getSelection(false);
-      if (!anchor) anchor = this.getSelection(true);
-      if (!focus || !anchor || focus.row != anchor.row) return;
-      this.lineDirty[focus.row] = true;
-      var startCol = focus.col < anchor.col ? focus.col : anchor.col;
-      var endCol = focus.col < anchor.col ? anchor.col : focus.col;
-      var left = this.lines[focus.row].substr(0, startCol).concat(pre);
-      var mid = endCol == startCol ? '' : this.lines[focus.row].substr(startCol, endCol - startCol);
-      var right = post.concat(this.lines[focus.row].substr(endCol));
-      this.lines[focus.row] = left.concat(mid, right);
-      anchor.col = left.length;
-      focus.col = anchor.col + mid.length;
-      this.updateFormatting();
-      this.setSelection(focus, anchor);
-    }
-    /**
-     * Toggles the command state for a command (true <-> false)
-     * @param {string} command The editor command
-     */
-
-  }, {
-    key: "toggleCommandState",
-    value: function toggleCommandState(command) {
-      if (!this.lastCommandState) this.lastCommandState = this.getCommandState();
-      this.setCommandState(command, !this.lastCommandState[command]);
-    }
-    /**
-     * Fires a change event. Updates the linked textarea and notifies any event listeners.
-     */
-
-  }, {
-    key: "fireChange",
-    value: function fireChange() {
-      if (!this.textarea && !this.listeners.change.length) return;
-      var content = this.getContent();
-      if (this.textarea) this.textarea.value = content;
-
-      var _iterator3 = _createForOfIteratorHelper(this.listeners.change),
-          _step3;
-
-      try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var listener = _step3.value;
-          listener({
-            content: content,
-            linesDirty: this.linesDirty
-          });
-        }
-      } catch (err) {
-        _iterator3.e(err);
-      } finally {
-        _iterator3.f();
+      for (let listener of this.listeners.selection) {
+        listener({
+          focus: focus,
+          anchor: anchor,
+          commandState: this.lastCommandState
+        });
       }
     }
-    /**
-     * Fires a "selection changed" event.
-     */
-
-  }, {
-    key: "fireSelection",
-    value: function fireSelection() {
-      if (this.listeners.selection && this.listeners.selection.length) {
-        var focus = this.getSelection(false);
-        var anchor = this.getSelection(true);
-        var commandState = this.getCommandState(focus, anchor);
-
-        if (this.lastCommandState) {
-          Object.assign(this.lastCommandState, commandState);
-        } else {
-          this.lastCommandState = Object.assign({}, commandState);
-        }
-
-        var _iterator4 = _createForOfIteratorHelper(this.listeners.selection),
-            _step4;
+  }
 
-        try {
-          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-            var listener = _step4.value;
-            listener({
-              focus: focus,
-              anchor: anchor,
-              commandState: this.lastCommandState
-            });
-          }
-        } catch (err) {
-          _iterator4.e(err);
-        } finally {
-          _iterator4.f();
-        }
-      }
+  /**
+   * Adds an event listener.
+   * @param {string} type The type of event to listen to. Can be 'change' or 'selection'
+   * @param {*} listener Function of the type (event) => {} to be called when the event occurs.
+   */
+  addEventListener(type, listener) {
+    if (type.match(/^(?:change|input)$/i)) {
+      this.listeners.change.push(listener);
     }
-    /**
-     * Adds an event listener.
-     * @param {string} type The type of event to listen to. Can be 'change' or 'selection'
-     * @param {*} listener Function of the type (event) => {} to be called when the event occurs.
-     */
-
-  }, {
-    key: "addEventListener",
-    value: function addEventListener(type, listener) {
-      if (type.match(/^(?:change|input)$/i)) {
-        this.listeners.change.push(listener);
-      }
-
-      if (type.match(/^(?:selection|selectionchange)$/i)) {
-        this.listeners.selection.push(listener);
-      }
+    if (type.match(/^(?:selection|selectionchange)$/i)) {
+      this.listeners.selection.push(listener);
     }
-  }]);
-
-  return Editor;
-}();
-
-var _default = Editor;
-exports.default = _default;
+  }
+}
+var _default = exports.default = Editor;