tiny-markdown-editor 0.1.3 → 0.1.5

package/lib/TinyMDE.js

@@ -1,122 +1,56 @@
 "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");
-
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.symbol.iterator.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/es.object.set-prototype-of.js");
+require("core-js/modules/es.regexp.constructor.js");
+require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/es.weak-map.js");
+require("core-js/modules/es.array.reduce.js");
+require("core-js/modules/es.object.keys.js");
+require("core-js/modules/es.symbol.replace.js");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.string.split.js");
+require("core-js/modules/es.string.replace.js");
+require("core-js/modules/es.string.match.js");
+require("core-js/modules/es.string.trim.js");
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.parse-int.js");
+require("core-js/modules/es.array.splice.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.string.includes.js");
+require("core-js/modules/es.object.assign.js");
+require("core-js/modules/es.object.define-property.js");
 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 _wrapRegExp() { _wrapRegExp = function _wrapRegExp(re, groups) { return new BabelRegExp(re, void 0, groups); }; var _super = RegExp.prototype, _groups = new WeakMap(); function BabelRegExp(re, flags, groups) { var _this = new RegExp(re, flags); return _groups.set(_this, groups || _groups.get(re)), _setPrototypeOf(_this, BabelRegExp.prototype); } function buildGroups(result, re) { var g = _groups.get(re); return Object.keys(g).reduce(function (groups, name) { var i = g[name]; if ("number" == typeof i) groups[name] = result[i];else { for (var k = 0; void 0 === result[i[k]] && k + 1 < i.length;) { k++; } groups[name] = result[i[k]]; } return groups; }, Object.create(null)); } return _inherits(BabelRegExp, RegExp), BabelRegExp.prototype.exec = function (str) { var result = _super.exec.call(this, str); if (result) { result.groups = buildGroups(result, this); var indices = result.indices; indices && (indices.groups = buildGroups(indices, this)); } return result; }, BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { if ("string" == typeof substitution) { var groups = _groups.get(this); return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { var group = groups[name]; return "$" + (Array.isArray(group) ? group.join("$") : group); })); } if ("function" == typeof substitution) { var _this = this; return _super[Symbol.replace].call(this, str, function () { var args = arguments; return "object" != _typeof(args[args.length - 1]) && (args = [].slice.call(args)).push(buildGroups(args, _this)), substitution.apply(this, args); }); } return _super[Symbol.replace].call(this, str, substitution); }, _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 } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) 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 _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { 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 = it.call(o); }, 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; }
-
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 var Editor = /*#__PURE__*/function () {
   function Editor() {
     var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-
     _classCallCheck(this, Editor);
-
     this.e = null;
     this.textarea = null;
     this.lines = [];
@@ -133,77 +67,67 @@ var Editor = /*#__PURE__*/function () {
     };
     var 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
    */
-
-
   _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;
+      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.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", function (e) {
         return _this.handleInputEvent(e);
-      }); // this.e.addEventListener("keydown", (e) => this.handleKeydownEvent(e));
-
+      });
+      // this.e.addEventListener("keydown", (e) => this.handleKeydownEvent(e));
       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));
-
+      });
+      // 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
      */
-
   }, {
     key: "setContent",
     value: function setContent(content) {
@@ -211,60 +135,57 @@ var Editor = /*#__PURE__*/function () {
       while (this.e.firstChild) {
         this.e.removeChild(this.e.firstChild);
       }
-
       this.lines = content.split(/(?:\r\n|\r|\n)/);
       this.lineDirty = [];
-
       for (var lineNum = 0; lineNum < this.lines.length; lineNum++) {
         var le = document.createElement('div');
         this.e.appendChild(le);
         this.lineDirty.push(true);
       }
-
       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)
      */
-
   }, {
     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
-
-      this.updateLinkLabels(); // Now, apply the formatting
-
+      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();
     }
+
     /**
      * 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]);
         }
       }
     }
+
     /**
      * 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, 
@@ -275,30 +196,28 @@ var Editor = /*#__PURE__*/function () {
      * @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.
-
+          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.
@@ -307,30 +226,28 @@ var Editor = /*#__PURE__*/function () {
         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;
@@ -341,32 +258,30 @@ var Editor = /*#__PURE__*/function () {
             lineReplacement = '$0';
             lineCapture = [this.lines[lineNum]];
           }
-        } // if (lineNum > 0 && (this.lineTypes[lineNum - 1] == 'TMCodeFenceTildeOpen' || this.lineTypes[lineNum - 1] == 'TMFencedCodeTilde')) {
+        }
+        // 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]];
-            }
-          } // Check HTML block types
-
+          // 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]];
+          }
+        }
 
+        // Check HTML block types
         if (lineType == 'TMPara' && htmlBlock === false) {
           var _iterator = _createForOfIteratorHelper(_grammar.htmlBlockGrammar),
-              _step;
-
+            _step;
           try {
             for (_iterator.s(); !(_step = _iterator.n()).done;) {
               var htmlBlockType = _step.value;
-
               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')) {
@@ -381,14 +296,12 @@ var Editor = /*#__PURE__*/function () {
             _iterator.f();
           }
         }
-
         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
 
+          // Check if HTML block should be closed
           if (htmlBlock.end) {
             // Specific end condition
             if (this.lines[lineNum].match(htmlBlock.end)) {
@@ -400,14 +313,13 @@ var Editor = /*#__PURE__*/function () {
               htmlBlock = false;
             }
           }
-        } // Check all regexps if we haven't applied one of the code block types
-
+        }
 
+        // Check all regexps if we haven't applied one of the code block types
         if (lineType == 'TMPara') {
           for (var type in _grammar.lineGrammar) {
             if (_grammar.lineGrammar[type].regexp) {
               var _capture2 = _grammar.lineGrammar[type].regexp.exec(this.lines[lineNum]);
-
               if (_capture2) {
                 lineType = type;
                 lineReplacement = _grammar.lineGrammar[type].replacement;
@@ -416,39 +328,37 @@ var Editor = /*#__PURE__*/function () {
               }
             }
           }
-        } // If we've opened a code block, remember that
-
+        }
 
+        // 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
-
+        }
 
+        // 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';
-        } // Setext H2 markers that can also be interpreted as an empty list item should be regarded as such (as per CommonMark spec)
-
+        }
 
+        // 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') {
           var _capture3 = _grammar.lineGrammar.TMUL.regexp.exec(this.lines[lineNum]);
-
           if (_capture3) {
             lineType = 'TMUL';
             lineReplacement = _grammar.lineGrammar.TMUL.replacement;
             lineCapture = _capture3;
           }
-        } // Setext headings are only valid if preceded by a paragraph (and if so, they change the type of the previous paragraph)
-
+        }
 
+        // 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]);
-
             if (_capture4) {
               // Valid HR
               lineType = 'TMHR';
@@ -464,34 +374,30 @@ var Editor = /*#__PURE__*/function () {
             // 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;
               }
-
               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
-
-
+        }
+        // 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.
      */
-
   }, {
     key: "updateLineContentsAndFormatting",
     value: function updateLineContentsAndFormatting() {
@@ -499,6 +405,7 @@ var Editor = /*#__PURE__*/function () {
       this.updateLineContents();
       this.updateFormatting();
     }
+
     /**
      * 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
@@ -508,7 +415,6 @@ var Editor = /*#__PURE__*/function () {
      * 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) {
@@ -523,81 +429,74 @@ var Editor = /*#__PURE__*/function () {
       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.
+      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
-
+        }
 
+        // 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;
-        } // Check for link (not an image because that would have been captured and skipped over above)
-
+        }
 
+        // 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
-
+          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;
-        } // Check for closing bracket
-
+        }
 
+        // 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;
           }
-        } // Nothing matches, proceed to next char
-
+        }
 
+        // Nothing matches, proceed to next char
         currentOffset++;
-      } // Did we find a link text (i.e., find a matching closing bracket?)
-
+      }
 
+      // 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
 
-      var nextChar = currentOffset < originalString.length ? originalString.substr(currentOffset, 1) : ''; // REFERENCE LINKS
+      // 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];
@@ -611,68 +510,59 @@ var Editor = /*#__PURE__*/function () {
         }
       } else if (nextChar != '(') {
         // Shortcut ref link
-        linkRef = linkText.trim(); // INLINE LINKS
+        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 _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
@@ -680,44 +570,36 @@ var Editor = /*#__PURE__*/function () {
 
             currentOffset += _cap2[0].length;
             continue inlineOuter;
-          } // Process backslash escapes
-
+          }
 
+          // 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
@@ -725,85 +607,75 @@ var Editor = /*#__PURE__*/function () {
 
             currentOffset += _cap2[0].length;
             continue inlineOuter;
-          } // Process opening angle bracket as deilimiter of destination
-
+          }
 
+          // 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
-
+          }
 
+          // 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,
+          // 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
-
+          }
 
+          // 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
-
+          }
+          // 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
@@ -811,18 +683,16 @@ var Editor = /*#__PURE__*/function () {
 
             currentOffset++;
             continue inlineOuter;
-          } // Process closing parenthesis
-
+          }
 
+          // 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(')');
               }
@@ -846,47 +716,38 @@ var Editor = /*#__PURE__*/function () {
                 linkDetails.push('');
               }
             }
-
             currentOffset++;
             continue inlineOuter;
-          } // Any old character
-
+          }
 
+          // 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
@@ -895,7 +756,6 @@ var Editor = /*#__PURE__*/function () {
             currentOffset += _cap2[0].length;
             continue inlineOuter;
           }
-
           throw "Infinite loop"; // we should never get here since the last test matches any character
         }
 
@@ -905,14 +765,11 @@ var Editor = /*#__PURE__*/function () {
       if (linkRef !== false) {
         // Ref link; check that linkRef is valid
         var valid = false;
-
         var _iterator2 = _createForOfIteratorHelper(this.linkLabels),
-            _step2;
-
+          _step2;
         try {
           for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
             var _label = _step2.value;
-
             if (_label == linkRef) {
               valid = true;
               break;
@@ -923,60 +780,52 @@ var Editor = /*#__PURE__*/function () {
         } 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>"));
         }
-
         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('');
         }
-
         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
         };
       }
-
       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
+            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]);
             });
@@ -985,70 +834,68 @@ var Editor = /*#__PURE__*/function () {
             };
           }
         };
-
         // 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
-
+        }
 
+        // 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
-
+        }
 
+        // 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.
+          string = string.substr(cap[0].length);
 
-          var preceding = offset > 0 ? originalString.substr(0, offset) : ' '; // beginning and end of line count as whitespace
+          // 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 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:
+          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 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
-
+            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
-
+                }
 
+                // 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>");
@@ -1059,12 +906,11 @@ var Editor = /*#__PURE__*/function () {
                   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 that stack level is empty now, pop it
                 if (stack[stackPointer].count == 0) {
                   var _entry2 = stack.pop();
-
                   processed = "".concat(_entry2.output).concat(processed);
                   stackPointer--;
                 }
@@ -1074,9 +920,8 @@ var Editor = /*#__PURE__*/function () {
                 stackPointer--;
               }
             }
-          } // If there are still delimiters left, and the delimiter run can open, push it on the stack
-
-
+          }
+          // If there are still delimiters left, and the delimiter run can open, push it on the stack
           if (delimCount && canOpen) {
             stack.push({
               delimiter: currentDelimiter,
@@ -1085,43 +930,36 @@ var Editor = /*#__PURE__*/function () {
               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.
-
+          }
 
+          // 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
-
+        }
 
+        // 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
-
-
+          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
-
+              }
 
+              // 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 {
@@ -1129,9 +967,9 @@ var Editor = /*#__PURE__*/function () {
               // 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 there are still delimiters left, and the delimiter run can open, push it on the stack
           if (!consumed) {
             stack.push({
               delimiter: '~',
@@ -1145,11 +983,10 @@ var Editor = /*#__PURE__*/function () {
           offset += cap[0].length;
           string = string.substr(cap[0].length);
           return "continue|outer";
-        } // Process 'default' rule
-
+        }
 
+        // Process 'default' rule
         cap = _grammar.inlineGrammar.default.regexp.exec(string);
-
         if (cap) {
           string = string.substr(cap[0].length);
           offset += cap[0].length;
@@ -1158,42 +995,37 @@ var Editor = /*#__PURE__*/function () {
           });
           return "continue|outer";
         }
-
         throw 'Infinite loop!';
       };
-
       outer: while (string) {
         var _ret = _loop();
-
         if (_ret === "continue|outer") continue outer;
-      } // Empty the stack, any opening delimiters are unused
-
+      }
 
+      // 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);
       }
-
       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;
       }
     }
+
     /**
      * Updates the class properties (lines, lineElements) from the DOM.
      * @returns true if contents changed
      */
-
   }, {
     key: "updateLineContents",
     value: function updateLineContents() {
@@ -1201,40 +1033,33 @@ var Editor = /*#__PURE__*/function () {
       // 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
-
+        }
 
+        // 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;
@@ -1243,62 +1068,56 @@ var Editor = /*#__PURE__*/function () {
         }
       }
     }
+
     /**
      * Processes a new paragraph.
      * @param sel The current selection
      */
-
   }, {
     key: "processNewParagraph",
     value: function processNewParagraph(sel) {
-      if (!sel) return; // Update lines from content
+      if (!sel) return;
 
+      // Update lines from content
       this.updateLineContents();
-      var continuableType = false; // Let's see if we need to continue a list
+      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;
-
         case 'TMOL':
           continuableType = 'TMOL';
           break;
-
         case 'TMIndentedCode':
           continuableType = 'TMIndentedCode';
           break;
       }
-
       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;
       }
-
       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;
@@ -1309,9 +1128,10 @@ var Editor = /*#__PURE__*/function () {
           }
         }
       }
-
       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
@@ -1334,6 +1154,7 @@ var Editor = /*#__PURE__*/function () {
     //       // Otherwise, we're at the very beginning and can't delete backwards
     //     }
     //   }
+
     // }
 
     /**
@@ -1342,7 +1163,6 @@ var Editor = /*#__PURE__*/function () {
      * @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() {
@@ -1351,27 +1171,23 @@ var Editor = /*#__PURE__*/function () {
       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
 
+      // 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.
+      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 {
@@ -1380,33 +1196,30 @@ var Editor = /*#__PURE__*/function () {
           node = node.previousSibling;
         }
       }
-
       return {
         row: row,
         col: col,
         node: startNode
       };
     }
+
     /**
      * 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.
-
+      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;
@@ -1415,40 +1228,35 @@ var Editor = /*#__PURE__*/function () {
           node = node.parentNode;
         }
       }
-
       return 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;
      */
-
   }, {
     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;
       }
-
       if (col > this.lines[row].length) {
         col = this.lines[row].length;
       }
-
       var parentNode = this.lineElements[row];
       var node = parentNode.firstChild;
-      var childrenComplete = false; // default return value
-
+      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) {
@@ -1470,7 +1278,6 @@ var Editor = /*#__PURE__*/function () {
             col -= node.nodeValue.length;
           }
         }
-
         if (!childrenComplete && node.firstChild) {
           node = node.firstChild;
         } else if (node.nextSibling) {
@@ -1480,56 +1287,49 @@ var Editor = /*#__PURE__*/function () {
           childrenComplete = true;
           node = node.parentNode;
         }
-      } // 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
-
+      }
 
+      // 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;
     }
+
     /**
      * 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
-
-
+        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;
-
+        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;
-
+          node = _this$computeNodeAndO2.node,
+          offset = _this$computeNodeAndO2.offset;
         anchorNode = node;
         anchorOffset = offset;
       }
-
       if (anchorNode) range.setStart(anchorNode, anchorOffset);else range.setStart(focusNode, focusOffset);
       range.setEnd(focusNode, focusOffset);
       var windowSelection = window.getSelection();
       windowSelection.removeAllRanges();
       windowSelection.addRange(range);
     }
+
     /** 
      * 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);
@@ -1547,22 +1347,21 @@ var Editor = /*#__PURE__*/function () {
             }
           }
         }
-
         this.updateLineContentsAndFormatting();
       }
-
       if (focus) this.setSelection(focus);
       this.fireChange();
     }
+
     /**
      * 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.
@@ -1574,58 +1373,51 @@ var Editor = /*#__PURE__*/function () {
      * @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 (adjustLineElements) {
         for (var i = 0; i < linesToDelete; i++) {
           this.e.removeChild(this.e.childNodes[startLine]);
         }
       }
-
       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'));
         }
       }
-
       (_this$lines = this.lines).splice.apply(_this$lines, [startLine, linesToDelete].concat(_toConsumableArray(linesToInsert)));
-
       (_this$lineTypes = this.lineTypes).splice.apply(_this$lineTypes, [startLine, linesToDelete].concat(insertedBlank));
-
       (_this$lineDirty = this.lineDirty).splice.apply(_this$lineDirty, [startLine, linesToDelete].concat(insertedDirty));
     }
+
     /**
      * Event handler for the "paste" event
      */
-
   }, {
     key: "handlePaste",
     value: function handlePaste(event) {
-      event.preventDefault(); // get text representation of clipboard
+      event.preventDefault();
 
-      var text = (event.originalEvent || event).clipboardData.getData('text/plain'); // insert text manually
+      // get text representation of clipboard
+      var text = (event.originalEvent || event).clipboardData.getData('text/plain');
 
+      // insert text manually
       this.paste(text);
     }
+
     /**
      * Pastes the text at the current selection (or at the end, if no current selection)
      * @param {string} text 
      */
-
   }, {
     key: "paste",
     value: function paste(text) {
@@ -1634,7 +1426,6 @@ var Editor = /*#__PURE__*/function () {
       if (!anchor) anchor = this.getSelection(true);
       if (!focus) focus = this.getSelection(false);
       var beginning, end;
-
       if (!focus) {
         focus = {
           row: this.lines.length - 1,
@@ -1645,7 +1436,6 @@ var Editor = /*#__PURE__*/function () {
       if (!anchor) {
         anchor = focus;
       }
-
       if (anchor.row < focus.row || anchor.row == focus.row && anchor.col <= focus.col) {
         beginning = anchor;
         end = focus;
@@ -1653,7 +1443,6 @@ var Editor = /*#__PURE__*/function () {
         beginning = focus;
         end = anchor;
       }
-
       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);
@@ -1667,41 +1456,36 @@ var Editor = /*#__PURE__*/function () {
       this.setSelection(focus);
       this.fireChange();
     }
+
     /**
      * 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;
-
       for (i = 0; ancestry1[i] == ancestry2[i]; i++) {
         ;
       }
-
       return ancestry1[i - 1];
     }
+
     /**
      * Finds the (lowest in the DOM tree) enclosing DOM node with a given class.
      * @param {object} focus The focus selection object
@@ -1709,35 +1493,30 @@ var Editor = /*#__PURE__*/function () {
      * @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
-
-
+      }
+      // Ascended all the way to the editor element
       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() {
@@ -1746,18 +1525,14 @@ var Editor = /*#__PURE__*/function () {
       var commandState = {};
       if (!focus) focus = this.getSelection(false);
       if (!anchor) anchor = this.getSelection(true);
-
       if (!focus) {
         for (var cmd in _grammar.commands) {
           commandState[cmd] = null;
         }
-
         return commandState;
       }
-
       if (!anchor) anchor = focus;
       var start, end;
-
       if (anchor.row < focus.row || anchor.row == focus.row && anchor.col < focus.col) {
         start = anchor;
         end = focus;
@@ -1765,7 +1540,6 @@ var Editor = /*#__PURE__*/function () {
         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
@@ -1777,37 +1551,35 @@ var Editor = /*#__PURE__*/function () {
             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
+            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);
           }
         }
-
         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;
           }
         }
       }
-
       return commandState;
     }
+
     /**
      * Sets a command state
      * @param {string} command 
      * @param {boolean} state 
      */
-
   }, {
     key: "setCommandState",
     value: function setCommandState(command, state) {
@@ -1819,8 +1591,9 @@ var Editor = /*#__PURE__*/function () {
         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
+        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);
@@ -1832,72 +1605,66 @@ var Editor = /*#__PURE__*/function () {
           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
+          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
+          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]*)$/, {
+              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(/^(\s*).*\S(\s*)$/, {
             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. 
+          anchor.col = endCol;
 
-          this.wrapSelection(_grammar.commands[command].set.pre, _grammar.commands[command].set.post, focus, anchor); // TODO clean this up so that markup remains properly nested
+          // 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;
           }
-
           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;
           }
         }
-
         this.updateFormatting();
         this.setSelection({
           row: end.row,
@@ -1908,40 +1675,41 @@ var Editor = /*#__PURE__*/function () {
         });
       }
     }
+
     /**
      * 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) 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) {
           ;
         }
-
         if (node && node.nextSibling.className && node.nextSibling.className.includes('TMInlineFormatted')) return true;
-      } // Look for a common ancestor
-
+      }
 
+      // Look for a common ancestor
       var ancestor = this.computeCommonAncestor(sel.focusNode, sel.anchorNode);
-      if (!ancestor) return false; // Check if there's an ancestor of class 'TMInlineFormatted' or 'TMBlankLine'
+      if (!ancestor) return false;
 
+      // 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;
       }
-
       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.
@@ -1949,7 +1717,6 @@ var Editor = /*#__PURE__*/function () {
      * @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) {
@@ -1970,31 +1737,29 @@ var Editor = /*#__PURE__*/function () {
       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;
-
+        _step3;
       try {
         for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
           var listener = _step3.value;
@@ -2009,10 +1774,10 @@ var Editor = /*#__PURE__*/function () {
         _iterator3.f();
       }
     }
+
     /**
      * Fires a "selection changed" event.
      */
-
   }, {
     key: "fireSelection",
     value: function fireSelection() {
@@ -2020,16 +1785,13 @@ var Editor = /*#__PURE__*/function () {
         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;
-
+          _step4;
         try {
           for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
             var listener = _step4.value;
@@ -2046,27 +1808,24 @@ var Editor = /*#__PURE__*/function () {
         }
       }
     }
+
     /**
      * 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);
       }
     }
   }]);
-
   return Editor;
 }();
-
 var _default = Editor;
 exports.default = _default;