tiny-markdown-editor 0.2.27 → 0.2.29

package/lib/TinyMDE.js

@@ -136,7 +136,7 @@ class Editor {
         this.isRestoringHistory = false;
     }
     handleUndoRedoKey(e) {
-        const isMac = /Mac|iPod|iPhone|iPad/.test(navigator.platform);
+        const isMac = grammar_1.editorRegExp.macPlatform.test(navigator.platform);
         const ctrl = isMac ? e.metaKey : e.ctrlKey;
         if (ctrl && !e.altKey) {
             if (e.key === "z" || e.key === "Z") {
@@ -195,13 +195,14 @@ class Editor {
         this.e.addEventListener("focus", () => this.hasFocus = true);
         this.e.addEventListener("paste", (e) => this.handlePaste(e));
         this.e.addEventListener("drop", (e) => this.handleDrop(e));
+        this.e.addEventListener("click", (e) => this.handleClick(e));
         this.lineElements = this.e.childNodes;
     }
     setContent(content) {
         while (this.e.firstChild) {
             this.e.removeChild(this.e.firstChild);
         }
-        this.lines = content.split(/(?:\r\n|\r|\n)/);
+        this.lines = content.split(grammar_1.editorRegExp.lineSplit);
         this.lineDirty = [];
         for (let lineNum = 0; lineNum < this.lines.length; lineNum++) {
             let le = document.createElement("div");
@@ -242,7 +243,7 @@ class Editor {
         }
     }
     replace(replacement, capture) {
-        return replacement.replace(/(\${1,2})([0-9])/g, (str, p1, p2) => {
+        return replacement.replace(grammar_1.editorRegExp.replacementPlaceholder, (str, p1, p2) => {
             if (p1 === "$")
                 return (0, grammar_1.htmlescape)(capture[parseInt(p2)]);
             else
@@ -250,17 +251,194 @@ class Editor {
         });
     }
     applyLineTypes() {
-        for (let lineNum = 0; lineNum < this.lines.length; lineNum++) {
-            if (this.lineDirty[lineNum]) {
-                let contentHTML = this.replace(this.lineReplacements[lineNum], this.lineCaptures[lineNum]);
-                this.lineElements[lineNum].className = this.lineTypes[lineNum];
-                this.lineElements[lineNum].removeAttribute("style");
-                this.lineElements[lineNum].innerHTML =
-                    contentHTML === "" ? "<br />" : contentHTML;
+        let lineNum = 0;
+        while (lineNum < this.lines.length) {
+            // A "block" whose text flows across several source lines (a paragraph, a multi-line
+            // blockquote, or a list item with wrapped/lazy-continuation lines) is rendered as one
+            // inline-parsing unit so that inline styles (bold, italic, ...) can span the soft line
+            // breaks between its lines.
+            if (this.isInlineGroupLeader(lineNum)) {
+                const leaderType = this.lineTypes[lineNum];
+                let end = lineNum;
+                while (end + 1 < this.lines.length &&
+                    this.isInlineContinuation(end + 1, leaderType)) {
+                    end++;
+                }
+                this.applyInlineGroup(lineNum, end);
+                lineNum = end + 1;
+            }
+            else {
+                this.applyLine(lineNum);
+                lineNum++;
             }
-            this.lineElements[lineNum].dataset.lineNum = lineNum.toString();
         }
     }
+    /** A line that can begin a multi-line inline group (a paragraph-bearing block). */
+    isInlineGroupLeader(lineNum) {
+        const t = this.lineTypes[lineNum];
+        if (t === "TMPara" || t === "TMUL" || t === "TMOL")
+            return true;
+        // A blockquote line whose content is blank is a paragraph break inside the quote, so it
+        // doesn't start (or join) a group.
+        if (t === "TMBlockquote")
+            return !this.isBlankBlockquoteContent(lineNum);
+        return false;
+    }
+    /** Whether `lineNum` continues the inline group whose leader has type `leaderType`. */
+    isInlineContinuation(lineNum, leaderType) {
+        const t = this.lineTypes[lineNum];
+        // A plain paragraph line is a lazy continuation of the preceding block (paragraph, list item,
+        // or blockquote). Consecutive list markers (TMUL/TMOL), by contrast, each start a new item
+        // and therefore do NOT continue the group.
+        if (t === "TMPara")
+            return true;
+        if (t === "TMBlockquote" && leaderType === "TMBlockquote")
+            return !this.isBlankBlockquoteContent(lineNum);
+        return false;
+    }
+    /** True when a blockquote line carries no (non-whitespace) content, e.g. `>` or `> `. */
+    isBlankBlockquoteContent(lineNum) {
+        const cap = this.lineCaptures[lineNum];
+        const content = cap && cap[2] !== undefined ? cap[2] : "";
+        return grammar_1.editorRegExp.blankContent.test(content);
+    }
+    applyLine(lineNum) {
+        const el = this.lineElements[lineNum];
+        if (this.lineDirty[lineNum]) {
+            let contentHTML = this.replace(this.lineReplacements[lineNum], this.lineCaptures[lineNum]);
+            el.className = this.lineTypes[lineNum];
+            el.removeAttribute("style");
+            el.innerHTML = contentHTML === "" ? "<br />" : contentHTML;
+            // This line is no longer rendered as part of a multi-line inline group.
+            delete el.dataset.mlSig;
+        }
+        el.dataset.lineNum = lineNum.toString();
+    }
+    /**
+     * Renders a group of lines [start..end] that together form one inline-parsing unit. The inline
+     * content of each line (the `$$N` portion of its replacement — the whole line for a paragraph,
+     * the text after the marker for a list item or blockquote) is joined with newlines and parsed as
+     * a single unit, so inline styles can span the soft line breaks. The resulting HTML is split back
+     * into one fragment per line; any element still open at a line break is closed and re-opened so
+     * each line keeps its own well-formed block element. Per-line markers (list bullets, blockquote
+     * `>`) are preserved exactly. A single-line group (start === end) renders identically to before.
+     */
+    applyInlineGroup(start, end) {
+        // Signature of every input that affects this group's rendering (line types, replacements and
+        // captures — hence the marker prefixes and the inline content). Stored per line element so a
+        // group is re-rendered whenever its content, a sibling line, or its boundaries change (e.g. on
+        // a split/merge) even if the individual line wasn't separately marked dirty.
+        const contents = [];
+        let sigSource = `${end - start}`;
+        for (let i = start; i <= end; i++) {
+            const idx = this.inlineContentIndex(this.lineReplacements[i]);
+            contents.push(this.lineCaptures[i][idx] !== undefined ? this.lineCaptures[i][idx] : "");
+            sigSource += `\x1f${this.lineTypes[i]}\x1f${this.lineReplacements[i]}\x1f${JSON.stringify(this.lineCaptures[i])}`;
+        }
+        const sig = `${this.hashString(sigSource)}`;
+        let needsRender = false;
+        for (let i = start; i <= end; i++) {
+            if (this.lineDirty[i] ||
+                this.lineElements[i].dataset.mlSig !== sig) {
+                needsRender = true;
+                break;
+            }
+        }
+        if (needsRender) {
+            const fragments = this.splitInlineHTMLByLine(this.processInlineStyles(contents.join("\n")));
+            for (let i = start; i <= end; i++) {
+                const el = this.lineElements[i];
+                const frag = fragments[i - start] || "";
+                const contentHTML = this.replaceWithInline(this.lineReplacements[i], this.lineCaptures[i], frag);
+                el.className = this.lineTypes[i];
+                el.removeAttribute("style");
+                el.innerHTML = contentHTML === "" ? "<br />" : contentHTML;
+                el.dataset.mlSig = sig;
+            }
+        }
+        for (let i = start; i <= end; i++) {
+            this.lineElements[i].dataset.lineNum = i.toString();
+        }
+    }
+    /** Index of the inline-content placeholder (`$$N`) in a line replacement, or 0 if none. */
+    inlineContentIndex(replacement) {
+        const m = grammar_1.editorRegExp.inlineContentPlaceholder.exec(replacement);
+        return m ? parseInt(m[1]) : 0;
+    }
+    /**
+     * Like replace(), but uses a pre-computed inline fragment for the `$$N` (inline content)
+     * placeholder instead of inline-parsing the capture itself. Used for multi-line groups where the
+     * inline content was parsed jointly across all lines.
+     */
+    replaceWithInline(replacement, capture, inlineFragment) {
+        return replacement.replace(grammar_1.editorRegExp.replacementPlaceholder, (str, p1, p2) => {
+            if (p1 === "$")
+                return (0, grammar_1.htmlescape)(capture[parseInt(p2)]);
+            else
+                return `<span class="TMInlineFormatted">${inlineFragment}</span>`;
+        });
+    }
+    /**
+     * Splits inline HTML produced for a joined multi-line paragraph back into one fragment per
+     * source line (fragments are separated by the `\n` markers emitted by processInlineStyles).
+     * Inline elements that are still open at a line break are closed at the end of the fragment and
+     * re-opened at the start of the next one, so that every fragment is independently well-formed
+     * while the formatting visually continues across the lines.
+     */
+    splitInlineHTMLByLine(html) {
+        const fragments = [];
+        const openTags = []; // full opening-tag strings of currently open elements
+        let current = "";
+        let i = 0;
+        while (i < html.length) {
+            const ch = html[i];
+            if (ch === "\n") {
+                // Close currently open tags (in reverse) to finish this line's fragment ...
+                for (let t = openTags.length - 1; t >= 0; t--) {
+                    current += `</${this.inlineTagName(openTags[t])}>`;
+                }
+                fragments.push(current);
+                // ... and re-open them (in order) at the start of the next line's fragment.
+                current = openTags.join("");
+                i++;
+            }
+            else if (ch === "<") {
+                const close = html.indexOf(">", i);
+                if (close < 0) {
+                    // Defensive: malformed output, emit the remainder verbatim.
+                    current += html.substr(i);
+                    break;
+                }
+                const tag = html.substring(i, close + 1);
+                current += tag;
+                if (tag[1] === "/") {
+                    openTags.pop();
+                }
+                else if (tag[tag.length - 2] !== "/") {
+                    // Opening tag that isn't self-closing.
+                    openTags.push(tag);
+                }
+                i = close + 1;
+            }
+            else {
+                current += ch;
+                i++;
+            }
+        }
+        fragments.push(current);
+        return fragments;
+    }
+    inlineTagName(openTag) {
+        const m = grammar_1.editorRegExp.inlineTagName.exec(openTag);
+        return m ? m[1] : "span";
+    }
+    hashString(s) {
+        let h = 5381;
+        for (let i = 0; i < s.length; i++) {
+            h = (((h << 5) + h) ^ s.charCodeAt(i)) >>> 0;
+        }
+        return h;
+    }
     updateLineTypes() {
         let codeBlockType = false;
         let codeBlockSeqLength = 0;
@@ -398,6 +576,40 @@ class Editor {
                     } while (headingLine >= 0 && this.lineTypes[headingLine] === "TMPara");
                 }
             }
+            // GFM task list item: a list item whose content begins with a checkbox marker `[ ]`, `[x]`
+            // or `[X]` followed by whitespace (or the end of the line). The brackets and separator stay
+            // as ordinary TMMark text; only the inner character is rendered as a checkbox (via CSS), so
+            // the line's text content still equals its source and the cursor navigates it normally.
+            if (lineType === "TMUL" || lineType === "TMOL") {
+                const content = lineCapture[2] !== undefined ? lineCapture[2] : "";
+                const task = grammar_1.editorRegExp.taskListItem.exec(content);
+                if (task) {
+                    const checked = task[2] !== " "; // [x] / [X] are checked, [ ] is not
+                    const bulletClass = lineType === "TMUL" ? "TMMark_TMUL" : "TMMark_TMOL";
+                    const boxClass = checked
+                        ? "TMCheckbox TMCheckbox_checked"
+                        : "TMCheckbox TMCheckbox_unchecked";
+                    // Synthetic capture: [full, bullet, "[", inner, "]", separator, inline content]. The
+                    // inline content stays the last `$$N` group so inlineContentIndex()/applyInlineGroup()
+                    // (and thus multi-line continuation) behave exactly as for a plain list item.
+                    lineCapture = [
+                        lineCapture[0],
+                        lineCapture[1],
+                        task[1],
+                        task[2],
+                        task[3],
+                        task[4],
+                        task[5],
+                    ];
+                    lineReplacement =
+                        `<span class="TMMark ${bulletClass}">$1</span>` +
+                            `<span class="TMMark TMMark_TMTask">$2</span>` +
+                            `<span class="${boxClass}">$3</span>` +
+                            `<span class="TMMark TMMark_TMTask">$4</span>` +
+                            `<span class="TMMark TMMark_TMTask">$5</span>` +
+                            `$$6`;
+                }
+            }
             if (this.lineTypes[lineNum] !== lineType) {
                 this.lineTypes[lineNum] = lineType;
                 this.lineDirty[lineNum] = true;
@@ -499,7 +711,7 @@ class Editor {
             beginning = focus;
             end = anchor;
         }
-        let insertedLines = text.split(/(?:\r\n|\r|\n)/);
+        let insertedLines = text.split(grammar_1.editorRegExp.lineSplit);
         let lineBefore = this.lines[beginning.row].substr(0, beginning.col);
         let lineEnd = this.lines[end.row].substr(end.col);
         insertedLines[0] = lineBefore.concat(insertedLines[0]);
@@ -534,13 +746,13 @@ class Editor {
         this.setSelection(focus, anchor);
     }
     addEventListener(type, listener) {
-        if (type.match(/^(?:change|input)$/i)) {
+        if (type.match(grammar_1.editorRegExp.changeEvent)) {
             this.listeners.change.push(listener);
         }
-        if (type.match(/^(?:selection|selectionchange)$/i)) {
+        if (type.match(grammar_1.editorRegExp.selectionEvent)) {
             this.listeners.selection.push(listener);
         }
-        if (type.match(/^(?:drop)$/i)) {
+        if (type.match(grammar_1.editorRegExp.dropEvent)) {
             this.listeners.drop.push(listener);
         }
     }
@@ -663,7 +875,7 @@ class Editor {
                 if (capture) {
                     if (capture[2]) {
                         if (continuableType === "TMOL") {
-                            capture[1] = capture[1].replace(/\d{1,9}/, (result) => {
+                            capture[1] = capture[1].replace(grammar_1.editorRegExp.orderedListNumber, (result) => {
                                 return (parseInt(result) + 1).toString();
                             });
                         }
@@ -728,12 +940,59 @@ class Editor {
         event.preventDefault();
         this.fireDrop(event.dataTransfer);
     }
+    /**
+     * Toggles a task list checkbox when its rendered box is clicked. Only the single inner character
+     * of the marker (`[ ]` -> `[x]` and back) is changed; the edit is length-preserving, recorded in
+     * the undo history, and fires a `change` event, mirroring setCommandState's line-edit flow.
+     */
+    handleClick(event) {
+        const target = event.target;
+        const box = target && target.closest ? target.closest(".TMCheckbox") : null;
+        if (!box)
+            return; // Not a checkbox click — let the default caret placement happen.
+        // Walk up to the line element (a direct child of the editor) to find its source row.
+        let lineEl = box;
+        while (lineEl && lineEl.parentNode !== this.e) {
+            lineEl = lineEl.parentNode;
+        }
+        if (!lineEl || lineEl.dataset.lineNum === undefined)
+            return;
+        const row = parseInt(lineEl.dataset.lineNum, 10);
+        if (isNaN(row) || row < 0 || row >= this.lines.length)
+            return;
+        const col = this.computeColumn(box, 0);
+        if (col === null)
+            return;
+        const ch = this.lines[row].charAt(col);
+        if (ch !== " " && ch !== "x" && ch !== "X")
+            return; // Defensive: not actually a checkbox char.
+        event.preventDefault();
+        if (!this.isRestoringHistory)
+            this.pushHistory();
+        this.clearDirtyFlag();
+        const replacement = ch === " " ? "x" : " ";
+        this.lines[row] = this.lines[row].substr(0, col) + replacement + this.lines[row].substr(col + 1);
+        this.lineDirty[row] = true;
+        this.updateFormatting();
+        this.fireChange();
+    }
     processInlineStyles(originalString) {
         let processed = "";
         let stack = [];
         let offset = 0;
         let string = originalString;
         outer: while (string) {
+            // Soft line break: when a paragraph that spans several source lines is parsed as one
+            // joined string, the lines are separated by \n. Preserve it as a newline marker in the
+            // output; splitInlineHTMLByLine() later splits the result back into per-line fragments.
+            // No inline rule starts on a newline (NotTriggerChar and `.` both exclude it), so handling
+            // it here keeps the tokenizer from stalling.
+            if (string.charCodeAt(0) === 10) {
+                processed += "\n";
+                string = string.substr(1);
+                offset += 1;
+                continue outer;
+            }
             // Process simple rules (non-delimiter)
             for (let rule of ["escape", "code", "autolink", "html"]) {
                 if (this.mergedInlineGrammar[rule]) {
@@ -741,7 +1000,7 @@ class Editor {
                     if (cap) {
                         string = string.substr(cap[0].length);
                         offset += cap[0].length;
-                        processed += this.mergedInlineGrammar[rule].replacement.replace(/\$([1-9])/g, (str, p1) => (0, grammar_1.htmlescape)(cap[p1]));
+                        processed += this.mergedInlineGrammar[rule].replacement.replace(grammar_1.editorRegExp.inlineReplacementPlaceholder, (str, p1) => (0, grammar_1.htmlescape)(cap[p1]));
                         continue outer;
                     }
                 }
@@ -753,11 +1012,24 @@ class Editor {
                     if (cap) {
                         string = string.substr(cap[0].length);
                         offset += cap[0].length;
-                        processed += this.mergedInlineGrammar[rule].replacement.replace(/\$([1-9])/g, (str, p1) => (0, grammar_1.htmlescape)(cap[p1]));
+                        processed += this.mergedInlineGrammar[rule].replacement.replace(grammar_1.editorRegExp.inlineReplacementPlaceholder, (str, p1) => (0, grammar_1.htmlescape)(cap[p1]));
                         continue outer;
                     }
                 }
             }
+            // Check for GFM extended (non-delimited) autolinks: bare URLs (www.…, http(s)://…, ftp://…),
+            // email addresses, and mailto:/xmpp: links. These are only recognized at the start of the
+            // string or immediately after whitespace or one of the delimiters `*`, `_`, `~`, `(`.
+            const precedingChar = offset > 0 ? originalString[offset - 1] : "";
+            if (precedingChar === "" || grammar_1.editorRegExp.autolinkPrecedingChar.test(precedingChar)) {
+                let autolink = this.parseAutolinkExtension(string);
+                if (autolink) {
+                    processed = `${processed}${autolink.output}`;
+                    string = string.substr(autolink.charCount);
+                    offset += autolink.charCount;
+                    continue outer;
+                }
+            }
             // Check for links / images
             let potentialLink = string.match(this.mergedInlineGrammar.linkOpen.regexp);
             let potentialImage = string.match(this.mergedInlineGrammar.imageOpen.regexp);
@@ -771,7 +1043,7 @@ class Editor {
                 }
             }
             // Check for em / strong delimiters
-            let cap = /(^\*+)|(^_+)/.exec(string);
+            let cap = grammar_1.editorRegExp.emphasisDelimiter.exec(string);
             if (cap) {
                 let delimCount = cap[0].length;
                 const delimString = cap[0];
@@ -781,8 +1053,8 @@ class Editor {
                 const following = offset + cap[0].length < originalString.length ? string : " ";
                 const punctuationFollows = following.match(grammar_1.punctuationLeading);
                 const punctuationPrecedes = preceding.match(grammar_1.punctuationTrailing);
-                const whitespaceFollows = following.match(/^\s/);
-                const whitespacePrecedes = preceding.match(/\s$/);
+                const whitespaceFollows = following.match(grammar_1.editorRegExp.leadingWhitespace);
+                const whitespacePrecedes = preceding.match(grammar_1.editorRegExp.trailingWhitespace);
                 let canOpen = !whitespaceFollows && (!punctuationFollows || !!whitespacePrecedes || !!punctuationPrecedes);
                 let canClose = !whitespacePrecedes && (!punctuationPrecedes || !!whitespaceFollows || !!punctuationFollows);
                 if (currentDelimiter === "_" && canOpen && canClose) {
@@ -835,7 +1107,7 @@ class Editor {
                 continue outer;
             }
             // Check for strikethrough delimiter
-            cap = /^~~/.exec(string);
+            cap = grammar_1.editorRegExp.strikethroughDelimiter.exec(string);
             if (cap) {
                 let consumed = false;
                 let stackPointer = stack.length - 1;
@@ -872,7 +1144,7 @@ class Editor {
             if (cap) {
                 string = string.substr(cap[0].length);
                 offset += cap[0].length;
-                processed += this.mergedInlineGrammar.default.replacement.replace(/\$([1-9])/g, (str, p1) => (0, grammar_1.htmlescape)(cap[p1]));
+                processed += this.mergedInlineGrammar.default.replacement.replace(grammar_1.editorRegExp.inlineReplacementPlaceholder, (str, p1) => (0, grammar_1.htmlescape)(cap[p1]));
                 continue outer;
             }
             throw "Infinite loop!";
@@ -1059,6 +1331,118 @@ class Editor {
             }
         });
     }
+    /**
+     * Attempts to parse a GFM extended (non-delimited) autolink at the start of `string`: a bare URL
+     * (`www.…`, `http://…`, `https://…`, `ftp://…`), an email address, or a `mailto:`/`xmpp:` link.
+     * The caller is responsible for the preceding-character boundary check. On success, returns the
+     * rendered HTML (the matched text wrapped in a `TMAutolink` span, exactly like the content of an
+     * angle-bracketed autolink) and the number of source characters consumed; otherwise `false`.
+     */
+    parseAutolinkExtension(string) {
+        const match = this.matchExtendedAutolink(string);
+        if (!match)
+            return false;
+        return {
+            output: `<span class="TMAutolink">${(0, grammar_1.htmlescape)(match)}</span>`,
+            charCount: match.length,
+        };
+    }
+    /** Returns the longest extended-autolink substring at the start of `string`, or `false`. */
+    matchExtendedAutolink(string) {
+        // --- Bare URL / www autolink -----------------------------------------------------------------
+        // www. is treated as part of the domain; an explicit scheme is stripped before the domain.
+        const schemeCap = grammar_1.editorRegExp.autolinkScheme.exec(string);
+        const isWww = grammar_1.editorRegExp.autolinkWww.test(string);
+        if (schemeCap || isWww) {
+            const prefixLen = schemeCap ? schemeCap[0].length : 0;
+            const afterPrefix = string.substr(prefixLen);
+            // A valid domain is dot-separated segments of alphanumerics, `_` and `-`, with at least one
+            // dot and no underscore in the last two segments.
+            const domainCap = grammar_1.editorRegExp.autolinkDomain.exec(afterPrefix);
+            if (domainCap && this.isValidAutolinkDomain(domainCap[0])) {
+                // After the domain, any run of non-space, non-`<` characters forms the path/query/fragment.
+                const pathCap = grammar_1.editorRegExp.autolinkPath.exec(afterPrefix.substr(domainCap[0].length));
+                const link = string.substr(0, prefixLen + domainCap[0].length + (pathCap ? pathCap[0].length : 0));
+                const trimmed = this.trimAutolinkTrailing(link);
+                // Guard against trailing punctuation trimming having eaten into the domain.
+                if (trimmed.length >= prefixLen + domainCap[0].length)
+                    return trimmed;
+            }
+        }
+        // --- mailto: / xmpp: autolink ----------------------------------------------------------------
+        const protoCap = grammar_1.editorRegExp.autolinkProtocol.exec(string);
+        if (protoCap) {
+            const emailCap = this.matchAutolinkEmail(string.substr(protoCap[0].length));
+            if (emailCap) {
+                // xmpp addresses may carry a `/resource` suffix.
+                let extra = "";
+                if (grammar_1.editorRegExp.autolinkXmpp.test(string)) {
+                    const resCap = grammar_1.editorRegExp.autolinkXmppResource.exec(string.substr(protoCap[0].length + emailCap.length));
+                    if (resCap)
+                        extra = resCap[0];
+                }
+                return protoCap[0] + emailCap + extra;
+            }
+        }
+        // --- Bare email autolink ---------------------------------------------------------------------
+        const email = this.matchAutolinkEmail(string);
+        if (email)
+            return email;
+        return false;
+    }
+    /** GFM domain validity: at least one dot and no underscore in the last two segments. */
+    isValidAutolinkDomain(domain) {
+        const segments = domain.split(".");
+        if (segments.length < 2)
+            return false;
+        return !segments.slice(-2).some((seg) => seg.indexOf("_") >= 0);
+    }
+    /** Matches a bare email address at the start of `string` per the GFM extension, or `false`. */
+    matchAutolinkEmail(string) {
+        // Local part: alphanumerics plus `.`, `-`, `_`, `+`. Domain: dot-separated labels of
+        // alphanumerics, `-` and `_`, with at least one dot and no `-`/`_` as the final character.
+        const cap = grammar_1.editorRegExp.autolinkEmail.exec(string);
+        if (!cap)
+            return false;
+        let email = cap[0];
+        while (email.length && grammar_1.editorRegExp.emailTrailingChar.test(email))
+            email = email.substr(0, email.length - 1);
+        // Must still end in a complete TLD (i.e. retain a dot after the trimming).
+        if (!grammar_1.editorRegExp.emailTld.test(email))
+            return false;
+        return email;
+    }
+    /**
+     * Strips trailing characters that GFM excludes from an autolink: the punctuation `?!.,:*_~`, and
+     * any unbalanced trailing `)` (more closing than opening parentheses in the link).
+     */
+    trimAutolinkTrailing(link) {
+        let end = link.length;
+        let changed = true;
+        while (changed && end > 0) {
+            changed = false;
+            const c = link[end - 1];
+            if ("?!.,:*_~".indexOf(c) >= 0) {
+                end--;
+                changed = true;
+            }
+            else if (c === ")") {
+                let open = 0;
+                let close = 0;
+                for (let i = 0; i < end; i++) {
+                    if (link[i] === "(")
+                        open++;
+                    else if (link[i] === ")")
+                        close++;
+                }
+                if (close > open) {
+                    end--;
+                    changed = true;
+                }
+            }
+        }
+        return link.substr(0, end);
+    }
     parseLinkOrImage(originalString, isImage) {
         // Skip the opening bracket
         let textOffset = isImage ? 2 : 1;
@@ -1099,7 +1483,7 @@ class Editor {
                 continue textOuter;
             }
             // Check for closing bracket
-            if (string.match(/^\]/)) {
+            if (string.match(grammar_1.editorRegExp.linkClosingBracket)) {
                 bracketLevel--;
                 if (bracketLevel === 0) {
                     linkText = originalString.substr(textOffset, currentOffset - textOffset);
@@ -1144,7 +1528,7 @@ class Editor {
             inlineOuter: while (currentOffset < originalString.length && parenthesisLevel > 0) {
                 let string = originalString.substr(currentOffset);
                 // Process whitespace
-                let cap = /^\s+/.exec(string);
+                let cap = grammar_1.editorRegExp.leadingWhitespaceRun.exec(string);
                 if (cap) {
                     switch (linkDetails.length) {
                         case 0:
@@ -1154,7 +1538,7 @@ class Editor {
                             linkDetails.push(cap[0]);
                             break;
                         case 2:
-                            if (linkDetails[0].match(/</)) {
+                            if (linkDetails[0].match(grammar_1.editorRegExp.containsOpenAngle)) {
                                 linkDetails[1] = linkDetails[1].concat(cap[0]);
                             }
                             else {
@@ -1211,7 +1595,7 @@ class Editor {
                     continue inlineOuter;
                 }
                 // Process opening angle bracket
-                if (linkDetails.length < 2 && string.match(/^</)) {
+                if (linkDetails.length < 2 && string.match(grammar_1.editorRegExp.openingAngle)) {
                     if (linkDetails.length === 0)
                         linkDetails.push("");
                     linkDetails[0] = linkDetails[0].concat("<");
@@ -1219,7 +1603,7 @@ class Editor {
                     continue inlineOuter;
                 }
                 // Process closing angle bracket
-                if ((linkDetails.length === 1 || linkDetails.length === 2) && string.match(/^>/)) {
+                if ((linkDetails.length === 1 || linkDetails.length === 2) && string.match(grammar_1.editorRegExp.closingAngle)) {
                     if (linkDetails.length === 1)
                         linkDetails.push("");
                     linkDetails.push(">");
@@ -1227,7 +1611,7 @@ class Editor {
                     continue inlineOuter;
                 }
                 // Process non-parenthesis delimiter for title
-                cap = /^["']/.exec(string);
+                cap = grammar_1.editorRegExp.titleQuote.exec(string);
                 if (cap && (linkDetails.length === 0 || linkDetails.length === 1 || linkDetails.length === 4)) {
                     while (linkDetails.length < 4)
                         linkDetails.push("");
@@ -1243,7 +1627,7 @@ class Editor {
                     continue inlineOuter;
                 }
                 // Process opening parenthesis
-                if (string.match(/^\(/)) {
+                if (string.match(grammar_1.editorRegExp.openingParen)) {
                     switch (linkDetails.length) {
                         case 0:
                             linkDetails.push("");
@@ -1251,7 +1635,7 @@ class Editor {
                             linkDetails.push("");
                         case 2:
                             linkDetails[1] = linkDetails[1].concat("(");
-                            if (!linkDetails[0].match(/<$/))
+                            if (!linkDetails[0].match(grammar_1.editorRegExp.endsWithOpenAngle))
                                 parenthesisLevel++;
                             break;
                         case 3:
@@ -1273,11 +1657,11 @@ class Editor {
                     continue inlineOuter;
                 }
                 // Process closing parenthesis
-                if (string.match(/^\)/)) {
+                if (string.match(grammar_1.editorRegExp.closingParen)) {
                     if (linkDetails.length <= 2) {
                         while (linkDetails.length < 2)
                             linkDetails.push("");
-                        if (!linkDetails[0].match(/<$/))
+                        if (!linkDetails[0].match(grammar_1.editorRegExp.endsWithOpenAngle))
                             parenthesisLevel--;
                         if (parenthesisLevel > 0) {
                             linkDetails[1] = linkDetails[1].concat(")");
@@ -1307,7 +1691,7 @@ class Editor {
                     continue inlineOuter;
                 }
                 // Any old character
-                cap = /^./.exec(string);
+                cap = grammar_1.editorRegExp.anyChar.exec(string);
                 if (cap) {
                     switch (linkDetails.length) {
                         case 0:
@@ -1362,8 +1746,11 @@ class Editor {
             while (linkDetails.length < 7) {
                 linkDetails.push("");
             }
+            // Every literal mark fragment is HTML-escaped: linkDetails[0]/[2] hold the angle brackets of
+            // an `<...>` destination, so leaving them raw would inject a stray `<`/`>` into the output —
+            // which splitInlineHTMLByLine then mistakes for an HTML tag.
             return {
-                output: `<span class="TMMark TMMark_${type}">${opener}</span><span class="${type}">${this.processInlineStyles(linkText)}</span><span class="TMMark TMMark_${type}">](${linkDetails[0]}</span><span class="${type}Destination">${(0, grammar_1.htmlescape)(linkDetails[1])}</span><span class="TMMark TMMark_${type}">${linkDetails[2]}${linkDetails[3]}${linkDetails[4]}</span><span class="${type}Title">${(0, grammar_1.htmlescape)(linkDetails[5])}</span><span class="TMMark TMMark_${type}">${linkDetails[6]})</span>`,
+                output: `<span class="TMMark TMMark_${type}">${opener}</span><span class="${type}">${this.processInlineStyles(linkText)}</span><span class="TMMark TMMark_${type}">](${(0, grammar_1.htmlescape)(linkDetails[0])}</span><span class="${type}Destination">${(0, grammar_1.htmlescape)(linkDetails[1])}</span><span class="TMMark TMMark_${type}">${(0, grammar_1.htmlescape)(linkDetails[2])}${(0, grammar_1.htmlescape)(linkDetails[3])}${(0, grammar_1.htmlescape)(linkDetails[4])}</span><span class="${type}Title">${(0, grammar_1.htmlescape)(linkDetails[5])}</span><span class="TMMark TMMark_${type}">${(0, grammar_1.htmlescape)(linkDetails[6])})</span>`,
                 charCount: currentOffset,
             };
         }
@@ -1532,7 +1919,7 @@ class Editor {
                     : { startCol: anchor.col, endCol: focus.col };
                 let match = this.lines[focus.row]
                     .substr(startCol, endCol - startCol)
-                    .match(/^(?<leading>\s*).*\S(?<trailing>\s*)$/);
+                    .match(grammar_1.editorRegExp.surroundingWhitespace);
                 if (match) {
                     startCol += match.groups.leading.length;
                     endCol -= match.groups.trailing.length;