` elements (and contents).
+
+`remove` can be called multiple times, with the newly added remove filters taking precedence over older ones. Remove filters will be overridden by the keep filters, standard CommonMark rules, and any added rules. To remove elements that are normally handled by those rules, add a rule with the desired behaviour.
+
+`remove` returns the `TurndownService` instance for chaining.
+
+### `use(plugin|array)`
+
+Use a plugin, or an array of plugins. Example:
+
+```js
+// Import plugins from turndown-plugin-gfm
+var turndownPluginGfm = require('turndown-plugin-gfm')
+var gfm = turndownPluginGfm.gfm
+var tables = turndownPluginGfm.tables
+var strikethrough = turndownPluginGfm.strikethrough
+
+// Use the gfm plugin
+turndownService.use(gfm)
+
+// Use the table and strikethrough plugins only
+turndownService.use([tables, strikethrough])
+```
+
+`use` returns the `TurndownService` instance for chaining.
+
+See **Plugins** below.
+
+## Extending with Rules
+
+Turndown can be extended by adding **rules**. A rule is a plain JavaScript object with `filter` and `replacement` properties. For example, the rule for converting `` elements is as follows:
+
+```js
+{
+ filter: 'p',
+ replacement: function (content) {
+ return '\n\n' + content + '\n\n'
+ }
+}
+```
+
+The filter selects `
` elements, and the replacement function returns the `
` contents separated by two new lines.
+
+### `filter` String|Array|Function
+
+The filter property determines whether or not an element should be replaced with the rule's `replacement`. DOM nodes can be selected simply using a tag name or an array of tag names:
+
+ * `filter: 'p'` will select `
` elements
+ * `filter: ['em', 'i']` will select `` or `` elements
+
+Alternatively, the filter can be a function that returns a boolean depending on whether a given node should be replaced. The function is passed a DOM node as well as the `TurndownService` options. For example, the following rule selects `` elements (with an `href`) when the `linkStyle` option is `inlined`:
+
+```js
+filter: function (node, options) {
+ return (
+ options.linkStyle === 'inlined' &&
+ node.nodeName === 'A' &&
+ node.getAttribute('href')
+ )
+}
+```
+
+### `replacement` Function
+
+The replacement function determines how an element should be converted. It should return the Markdown string for a given node. The function is passed the node's content, the node itself, and the `TurndownService` options.
+
+The following rule shows how `` elements are converted:
+
+```js
+rules.emphasis = {
+ filter: ['em', 'i'],
+
+ replacement: function (content, node, options) {
+ return options.emDelimiter + content + options.emDelimiter
+ }
+}
+```
+
+### Special Rules
+
+**Blank rule** determines how to handle blank elements. It overrides every rule (even those added via `addRule`). A node is blank if it only contains whitespace, and it's not an ``, ` `,` ` or a void element. Its behaviour can be customised using the `blankReplacement` option.
+
+**Keep rules** determine how to handle the elements that should not be converted, i.e. rendered as HTML in the Markdown output. By default, no elements are kept. Block-level elements will be separated from surrounding content by blank lines. Its behaviour can be customised using the `keepReplacement` option.
+
+**Remove rules** determine which elements to remove altogether. By default, no elements are removed.
+
+**Default rule** handles nodes which are not recognised by any other rule. By default, it outputs the node's text content (separated by blank lines if it is a block-level element). Its behaviour can be customised with the `defaultReplacement` option.
+
+### Rule Precedence
+
+Turndown iterates over the set of rules, and picks the first one that matches the `filter`. The following list describes the order of precedence:
+
+1. Blank rule
+2. Added rules (optional)
+3. Commonmark rules
+4. Keep rules
+5. Remove rules
+6. Default rule
+
+## Plugins
+
+The plugin API provides a convenient way for developers to apply multiple extensions. A plugin is just a function that is called with the `TurndownService` instance.
+
+## License
+
+turndown is copyright © 2017+ Dom Christie and released under the MIT license.
diff --git a/packages/turndown/build_for_test.sh b/packages/turndown/build_for_test.sh
new file mode 100755
index 0000000000..9cf93ad689
--- /dev/null
+++ b/packages/turndown/build_for_test.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+set -e
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+ROOT_DIR="$SCRIPT_DIR/../.."
+
+npm run build
+cd $ROOT_DIR/packages/app-cli && npm run test -- HtmlToMd
\ No newline at end of file
diff --git a/packages/turndown/config/rollup.config.browser.cjs.js b/packages/turndown/config/rollup.config.browser.cjs.js
new file mode 100644
index 0000000000..8e2bddc603
--- /dev/null
+++ b/packages/turndown/config/rollup.config.browser.cjs.js
@@ -0,0 +1,9 @@
+import config from './rollup.config';
+
+export default config({
+ output: {
+ file: 'lib/turndown.browser.cjs.js',
+ format: 'cjs',
+ },
+ browser: true,
+});
diff --git a/packages/turndown/config/rollup.config.browser.es.js b/packages/turndown/config/rollup.config.browser.es.js
new file mode 100644
index 0000000000..0b2503422a
--- /dev/null
+++ b/packages/turndown/config/rollup.config.browser.es.js
@@ -0,0 +1,9 @@
+import config from './rollup.config';
+
+export default config({
+ output: {
+ file: 'lib/turndown.browser.es.js',
+ format: 'es',
+ },
+ browser: true,
+});
diff --git a/packages/turndown/config/rollup.config.browser.umd.js b/packages/turndown/config/rollup.config.browser.umd.js
new file mode 100644
index 0000000000..04a29ab2d1
--- /dev/null
+++ b/packages/turndown/config/rollup.config.browser.umd.js
@@ -0,0 +1,9 @@
+import config from './rollup.config';
+
+export default config({
+ output: {
+ file: 'lib/turndown.browser.umd.js',
+ format: 'umd',
+ },
+ browser: true,
+});
diff --git a/packages/turndown/config/rollup.config.cjs.js b/packages/turndown/config/rollup.config.cjs.js
new file mode 100644
index 0000000000..67306087ba
--- /dev/null
+++ b/packages/turndown/config/rollup.config.cjs.js
@@ -0,0 +1,9 @@
+import config from './rollup.config';
+
+export default config({
+ output: {
+ file: 'lib/turndown.cjs.js',
+ format: 'cjs',
+ },
+ browser: false,
+});
diff --git a/packages/turndown/config/rollup.config.es.js b/packages/turndown/config/rollup.config.es.js
new file mode 100644
index 0000000000..d8cc366213
--- /dev/null
+++ b/packages/turndown/config/rollup.config.es.js
@@ -0,0 +1,9 @@
+import config from './rollup.config';
+
+export default config({
+ output: {
+ file: 'lib/turndown.es.js',
+ format: 'es',
+ },
+ browser: false,
+});
diff --git a/packages/turndown/config/rollup.config.iife.js b/packages/turndown/config/rollup.config.iife.js
new file mode 100644
index 0000000000..2a881eead1
--- /dev/null
+++ b/packages/turndown/config/rollup.config.iife.js
@@ -0,0 +1,9 @@
+import config from './rollup.config';
+
+export default config({
+ output: {
+ file: 'dist/turndown.js',
+ format: 'iife',
+ },
+ browser: true,
+});
diff --git a/packages/turndown/config/rollup.config.js b/packages/turndown/config/rollup.config.js
new file mode 100644
index 0000000000..4666bd1b86
--- /dev/null
+++ b/packages/turndown/config/rollup.config.js
@@ -0,0 +1,17 @@
+import commonjs from 'rollup-plugin-commonjs';
+import replace from 'rollup-plugin-replace';
+import resolve from 'rollup-plugin-node-resolve';
+
+export default function(config) {
+ return {
+ input: 'src/turndown.js',
+ name: 'TurndownService',
+ output: config.output,
+ external: ['jsdom'],
+ plugins: [
+ commonjs(),
+ replace({ 'process.browser': JSON.stringify(!!config.browser) }),
+ resolve(),
+ ],
+ };
+}
diff --git a/packages/turndown/config/rollup.config.umd.js b/packages/turndown/config/rollup.config.umd.js
new file mode 100644
index 0000000000..37f506a699
--- /dev/null
+++ b/packages/turndown/config/rollup.config.umd.js
@@ -0,0 +1,8 @@
+import config from './rollup.config';
+
+export default config({
+ output: {
+ file: 'lib/turndown.umd.js',
+ format: 'umd',
+ },
+});
diff --git a/packages/turndown/index.html b/packages/turndown/index.html
new file mode 100644
index 0000000000..be38959f28
--- /dev/null
+++ b/packages/turndown/index.html
@@ -0,0 +1,282 @@
+
+
+
+Turndown Demo
+
+
+
HTML
+
+
+
+
Markdown
+
+
+
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+function containsOnlySpaces(text) {
+ if (!text) return false;
+ for (let i = 0; i < text.length; i++) {
+ if (text[i] !== ' ') return false;
+ }
+ return true;
+}
+
+/**
+ * collapseWhitespace(options) removes extraneous whitespace from an the given element.
+ *
+ * @param {Object} options
+ */
+function collapseWhitespace (options) {
+ var element = options.element
+ var isBlock = options.isBlock
+ var isVoid = options.isVoid
+ var isPre = options.isPre || function (node) {
+ return node.nodeName === 'PRE'
+ }
+
+ if (!element.firstChild || isPre(element)) return
+
+ var prevText = null
+ var prevVoid = false
+
+ var prev = null
+ var node = next(prev, element, isPre)
+
+ // We keep track of whether the previous was only spaces or not. This prevent the case where multiple empty blocks are
+ // added, which results in multiple spaces. This spaces are then incorrectly interpreted as a code block by renderers.
+ // So by keeping track of this, we make sure that only one space at most is added.
+ var prevTextIsOnlySpaces = false;
+
+ while (node !== element) {
+ if (node.nodeType === 3 || node.nodeType === 4) { // Node.TEXT_NODE or Node.CDATA_SECTION_NODE
+ var text = node.data.replace(/[ \r\n\t]+/g, ' ')
+
+ if ((!prevText || / $/.test(prevText.data)) &&
+ !prevVoid && text[0] === ' ') {
+ text = text.substr(1)
+ }
+
+ var textIsOnlySpaces = containsOnlySpaces(text);
+
+ // `text` might be empty at this point.
+ if (!text || (textIsOnlySpaces && prevTextIsOnlySpaces)) {
+ node = remove(node)
+ continue
+ }
+
+ prevTextIsOnlySpaces = textIsOnlySpaces;
+ node.data = text
+
+ prevText = node
+ } else if (node.nodeType === 1) { // Node.ELEMENT_NODE
+ if (isBlock(node) || node.nodeName === 'BR') {
+ if (prevText) {
+ prevText.data = prevText.data.replace(/ $/, '')
+ }
+
+ prevText = null
+ prevVoid = false
+ } else if (isVoid(node)) {
+ // Avoid trimming space around non-block, non-BR void elements.
+ prevText = null
+ prevVoid = true
+ }
+ } else {
+ node = remove(node)
+ continue
+ }
+
+ var nextNode = next(prev, node, isPre)
+ prev = node
+ node = nextNode
+ }
+
+ if (prevText) {
+ prevText.data = prevText.data.replace(/ $/, '')
+ if (!prevText.data) {
+ remove(prevText)
+ }
+ }
+}
+
+/**
+ * remove(node) removes the given node from the DOM and returns the
+ * next node in the sequence.
+ *
+ * @param {Node} node
+ * @return {Node} node
+ */
+function remove (node) {
+ var next = node.nextSibling || node.parentNode
+
+ node.parentNode.removeChild(node)
+
+ return next
+}
+
+/**
+ * next(prev, current, isPre) returns the next node in the sequence, given the
+ * current and previous nodes.
+ *
+ * @param {Node} prev
+ * @param {Node} current
+ * @param {Function} isPre
+ * @return {Node}
+ */
+function next (prev, current, isPre) {
+ if ((prev && prev.parentNode === current) || isPre(current)) {
+ return current.nextSibling || current.parentNode
+ }
+
+ return current.firstChild || current.nextSibling || current.parentNode
+}
+
+export default collapseWhitespace
diff --git a/packages/turndown/src/commonmark-rules.js b/packages/turndown/src/commonmark-rules.js
new file mode 100644
index 0000000000..da92fc8a80
--- /dev/null
+++ b/packages/turndown/src/commonmark-rules.js
@@ -0,0 +1,601 @@
+import { repeat, isCodeBlockSpecialCase1, isCodeBlockSpecialCase2, isCodeBlock } from './utilities'
+const Entities = require('html-entities').AllHtmlEntities;
+const htmlentities = (new Entities()).encode;
+
+function attributesHtml(attributes, options = null) {
+ if (!attributes) return '';
+
+ options = Object.assign({}, {
+ skipEmptyClass: false,
+ }, options);
+
+ const output = [];
+
+ for (let attr of attributes) {
+ if (attr.name === 'class' && !attr.value && options.skipEmptyClass) continue;
+ output.push(`${attr.name}="${htmlentities(attr.value)}"`);
+ }
+
+ return output.join(' ');
+}
+
+var rules = {}
+
+rules.paragraph = {
+ filter: 'p',
+
+ replacement: function (content) {
+ return '\n\n' + content + '\n\n'
+ }
+}
+
+rules.lineBreak = {
+ filter: 'br',
+
+ replacement: function (content, node, options) {
+ return options.br + '\n'
+ }
+}
+
+rules.heading = {
+ filter: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'],
+
+ replacement: function (content, node, options) {
+ var hLevel = Number(node.nodeName.charAt(1))
+
+ if (options.headingStyle === 'setext' && hLevel < 3) {
+ var underline = repeat((hLevel === 1 ? '=' : '-'), content.length)
+ return (
+ '\n\n' + content + '\n' + underline + '\n\n'
+ )
+ } else {
+ return '\n\n' + repeat('#', hLevel) + ' ' + content + '\n\n'
+ }
+ }
+}
+
+rules.blockquote = {
+ filter: 'blockquote',
+
+ replacement: function (content) {
+ content = content.replace(/^\n+|\n+$/g, '')
+ content = content.replace(/^/gm, '> ')
+ return '\n\n' + content + '\n\n'
+ }
+}
+
+rules.list = {
+ filter: ['ul', 'ol'],
+
+ replacement: function (content, node) {
+ var parent = node.parentNode
+ if (parent.nodeName === 'LI' && parent.lastElementChild === node) {
+ return '\n' + content
+ } else {
+ return '\n\n' + content + '\n\n'
+ }
+ }
+}
+
+// OL elements are ordered lists, but other elements with a "list-style-type: decimal" style
+// should also be considered ordered lists, at least that's how they are rendered
+// in browsers.
+// https://developer.mozilla.org/en-US/docs/Web/CSS/list-style-type
+function isOrderedList(e) {
+ if (e.nodeName === 'OL') return true;
+ return e.style && e.style.listStyleType === 'decimal';
+}
+
+rules.listItem = {
+ filter: 'li',
+
+ replacement: function (content, node, options) {
+ content = content
+ .replace(/^\n+/, '') // remove leading newlines
+ .replace(/\n+$/, '\n') // replace trailing newlines with just a single one
+
+ var prefix = options.bulletListMarker + ' '
+ content = content.replace(/\n/gm, '\n ') // indent
+
+ const joplinCheckbox = joplinCheckboxInfo(node);
+ if (joplinCheckbox) {
+ prefix = '- [' + (joplinCheckbox.checked ? 'x' : ' ') + '] ';
+ } else {
+ var parent = node.parentNode
+ if (isOrderedList(parent)) {
+ var start = parent.getAttribute('start')
+ var index = Array.prototype.indexOf.call(parent.children, node)
+ var indexStr = (start ? Number(start) + index : index + 1) + ''
+ // The content of the line that contains the bullet must align wih the following lines.
+ //
+ // i.e it should be:
+ //
+ // 9. my content
+ // second line
+ // 10. next one
+ // second line
+ //
+ // But not:
+ //
+ // 9. my content
+ // second line
+ // 10. next one
+ // second line
+ //
+ prefix = indexStr + '.' + ' '.repeat(3 - indexStr.length)
+ }
+ }
+
+ return (
+ prefix + content + (node.nextSibling && !/\n$/.test(content) ? '\n' : '')
+ )
+ }
+}
+
+rules.indentedCodeBlock = {
+ filter: function (node, options) {
+ if (options.codeBlockStyle !== 'indented') return false
+ return isCodeBlock(node);
+ },
+
+ replacement: function (content, node, options) {
+ const handledNode = isCodeBlockSpecialCase1(node) ? node : node.firstChild
+
+ return (
+ '\n\n ' +
+ handledNode.textContent.replace(/\n/g, '\n ') +
+ '\n\n'
+ )
+ }
+}
+
+rules.fencedCodeBlock = {
+ filter: function (node, options) {
+ if (options.codeBlockStyle !== 'fenced') return false;
+ return isCodeBlock(node);
+ },
+
+ replacement: function (content, node, options) {
+ let handledNode = node.firstChild;
+ if (isCodeBlockSpecialCase1(node) || isCodeBlockSpecialCase2(node)) handledNode = node;
+
+ var className = handledNode.className || ''
+ var language = (className.match(/language-(\S+)/) || [null, ''])[1]
+
+ return (
+ '\n\n' + options.fence + language + '\n' +
+ content +
+ '\n' + options.fence + '\n\n'
+ )
+ }
+}
+
+rules.horizontalRule = {
+ filter: 'hr',
+
+ replacement: function (content, node, options) {
+ return '\n\n' + options.hr + '\n\n'
+ }
+}
+
+function filterLinkContent (content) {
+ return content.trim().replace(/[\n\r]+/g, 'Something so the
+// rule below handle this.
+// Fixes https://github.com/laurent22/joplin/issues/1876
+rules.otherNamedAnchors = {
+ filter: function (node, options) {
+ return !!getNamedAnchorFromLink(node, options);
+ },
+
+ replacement: function (content, node, options) {
+ return getNamedAnchorFromLink(node, options) + content;
+ }
+}
+
+rules.referenceLink = {
+ filter: function (node, options) {
+ return (
+ options.linkStyle === 'referenced' &&
+ node.nodeName === 'A' &&
+ node.getAttribute('href')
+ )
+ },
+
+ replacement: function (content, node, options) {
+ var href = filterLinkHref(node.getAttribute('href'))
+ var title = node.title ? ' "' + node.title + '"' : ''
+ if (!href) title = ''
+ var replacement
+ var reference
+
+ content = filterLinkContent(content)
+
+ switch (options.linkReferenceStyle) {
+ case 'collapsed':
+ replacement = '[' + content + '][]'
+ reference = '[' + content + ']: ' + href + title
+ break
+ case 'shortcut':
+ replacement = '[' + content + ']'
+ reference = '[' + content + ']: ' + href + title
+ break
+ default:
+ var id = this.references.length + 1
+ replacement = '[' + content + '][' + id + ']'
+ reference = '[' + id + ']: ' + href + title
+ }
+
+ this.references.push(reference)
+ return replacement
+ },
+
+ references: [],
+
+ append: function (options) {
+ var references = ''
+ if (this.references.length) {
+ references = '\n\n' + this.references.join('\n') + '\n\n'
+ this.references = [] // Reset references
+ }
+ return references
+ }
+}
+
+rules.emphasis = {
+ filter: ['em', 'i'],
+
+ replacement: function (content, node, options) {
+ if (!content.trim()) return ''
+ if (node.isCode) return content;
+ return options.emDelimiter + content + options.emDelimiter
+ }
+}
+
+rules.strong = {
+ filter: ['strong', 'b'],
+
+ replacement: function (content, node, options) {
+ if (!content.trim()) return ''
+ if (node.isCode) return content;
+ return options.strongDelimiter + content + options.strongDelimiter
+ }
+}
+
+rules.code = {
+ filter: function (node) {
+ var hasSiblings = node.previousSibling || node.nextSibling
+ var isCodeBlock = node.parentNode.nodeName === 'PRE' && !hasSiblings
+
+ return node.nodeName === 'CODE' && !isCodeBlock
+ },
+
+ replacement: function (content) {
+ if (!content.trim()) return ''
+
+ var delimiter = '`'
+ var leadingSpace = ''
+ var trailingSpace = ''
+ var matches = content.match(/`+/gm)
+ if (matches) {
+ if (/^`/.test(content)) leadingSpace = ' '
+ if (/`$/.test(content)) trailingSpace = ' '
+ while (matches.indexOf(delimiter) !== -1) delimiter = delimiter + '`'
+ }
+
+ return delimiter + leadingSpace + content + trailingSpace + delimiter
+ }
+}
+
+function imageMarkdownFromNode(node, options = null) {
+ options = Object.assign({}, {
+ preserveImageTagsWithSize: false,
+ }, options);
+
+ if (options.preserveImageTagsWithSize && (node.getAttribute('width') || node.getAttribute('height'))) {
+ return node.outerHTML;
+ }
+
+ var alt = node.alt || ''
+ var src = filterLinkHref(node.getAttribute('src') || '')
+ var title = node.title || ''
+ var titlePart = title ? ' "' + filterImageTitle(title) + '"' : ''
+ return src ? '![' + alt.replace(/([[\]])/g, '\\$1') + ']' + '(' + src + titlePart + ')' : ''
+}
+
+function imageUrlFromSource(node) {
+ // Format of srcset can be:
+ // srcset="kitten.png"
+ // or:
+ // srcset="kitten.png, kitten@2X.png 2x"
+
+ let src = node.getAttribute('srcset');
+ if (!src) src = node.getAttribute('data-srcset');
+ if (!src) return '';
+
+ const s = src.split(',');
+ if (!s.length) return '';
+ src = s[0];
+
+ src = src.split(' ');
+ return src[0];
+}
+
+rules.image = {
+ filter: 'img',
+
+ replacement: function (content, node, options) {
+ return imageMarkdownFromNode(node, options);
+ }
+}
+
+rules.picture = {
+ filter: 'picture',
+
+ replacement: function (content, node, options) {
+ if (!node.childNodes) return '';
+
+ let firstSource = null;
+ let firstImg = null;
+
+ for (let i = 0; i < node.childNodes.length; i++) {
+ const child = node.childNodes[i];
+
+ if (child.nodeName === 'SOURCE' && !firstSource) firstSource = child;
+ if (child.nodeName === 'IMG') firstImg = child;
+ }
+
+ if (firstImg && firstImg.getAttribute('src')) {
+ return imageMarkdownFromNode(firstImg, options);
+ } else if (firstSource) {
+ // A tag can have multiple tag and the browser should decide which one to download
+ // but for now let's pick the first one.
+ const src = imageUrlFromSource(firstSource);
+ return src ? '' : '';
+ }
+
+ return '';
+ }
+}
+
+function findFirstDescendant(node, byType, name) {
+ for (const childNode of node.childNodes) {
+ if (byType === 'class' && childNode.classList.contains(name)) return childNode;
+ if (byType === 'nodeName' && childNode.nodeName === name) return childNode;
+
+ const sub = findFirstDescendant(childNode, byType, name);
+ if (sub) return sub;
+ }
+ return null;
+}
+
+function findParent(node, byType, name) {
+ while (true) {
+ const p = node.parentNode;
+ if (!p) return null;
+ if (byType === 'class' && p.classList && p.classList.contains(name)) return p;
+ if (byType === 'nodeName' && p.nodeName === name) return p;
+ node = p;
+ }
+}
+
+// ===============================================================================
+// MATHJAX support
+//
+// When encountering Mathjax elements there's first the rendered Mathjax,
+// which we want to skip because it cannot be converted reliably to Markdown.
+// This tag is followed by the actual MathJax script in a
+