markdown-to-jsx 6.10.1 → 6.11.1

package/index.js

@@ -167,11 +167,12 @@ const REFERENCE_LINK_R = /^\[([^\]]*)\] ?\[([^\]]*)\]/;
 const SQUARE_BRACKETS_R = /(\[|\])/g;
 const SHOULD_RENDER_AS_BLOCK_R = /(\n|^[-*]\s|^#|^ {2,}|^-{2,}|^>\s)/;
 const TAB_R = /\t/g;
+const TABLE_SEPARATOR_R = /^ *\| */;
 const TABLE_TRIM_PIPES = /(^ *\||\| *$)/g;
+const TABLE_CELL_END_TRIM = / *$/;
 const TABLE_CENTER_ALIGN = /^ *:-+: *$/;
 const TABLE_LEFT_ALIGN = /^ *:-+ *$/;
 const TABLE_RIGHT_ALIGN = /^ *-+: *$/;
-const TABLE_ROW_SPLIT = / *\| */;
 
 const TEXT_BOLD_R = /^([*_])\1((?:\[.*?\][([].*?[)\]]|<.*?>(?:.*?<.*?>)?|`.*?`|~+.*?~+|.)*?)\1\1(?!\1)/;
 const TEXT_EMPHASIZED_R = /^([*_])((?:\[.*?\][([].*?[)\]]|<.*?>(?:.*?<.*?>)?|`.*?`|~+.*?~+|.)*?)\1(?!\1)/;
@@ -179,7 +180,7 @@ const TEXT_STRIKETHROUGHED_R = /^~~((?:\[.*?\]|<.*?>(?:.*?<.*?>)?|`.*?`|.)*?)~~/
 
 const TEXT_ESCAPED_R = /^\\([^0-9A-Za-z\s])/;
 const TEXT_PLAIN_R = /^[\s\S]+?(?=[^0-9A-Z\s\u00c0-\uffff&;.()'"]|\d+\.|\n\n| {2,}\n|\w+:\S|$)/i;
-const TRIM_NEWLINES_AND_TRAILING_WHITESPACE_R = /(^\n+|(\n|\s)+$)/g;
+const TRIM_NEWLINES_AND_TRAILING_WHITESPACE_R = /(^\n+|\n+$|\s+$)/g;
 
 const HTML_LEFT_TRIM_AMOUNT_R = /^([ \t]*)/;
 
@@ -287,46 +288,56 @@ function parseTableAlignCapture(alignCapture) {
   return null;
 }
 
-function parseTableHeader(capture, parse, state) {
-  const headerText = capture[1]
-    .replace(TABLE_TRIM_PIPES, '')
-    .trim()
-    .split(TABLE_ROW_SPLIT);
-
-  return headerText.map(function(text) {
-    return parse(text, state);
+function parseTableRow(source, parse, state) {
+  const prevInTable = state.inTable;
+  state.inTable = true;
+  const tableRow = parse(source.trim(), state);
+  state.inTable = prevInTable;
+
+  let cells = [[]];
+  tableRow.forEach(function(node, i) {
+    if (node.type === 'tableSeparator') {
+      // Filter out empty table separators at the start/end:
+        if (i !== 0 && i !== tableRow.length - 1) {
+          // Split the current row:
+          cells.push([]);
+        }
+    } else {
+      if (node.type === 'text' && (
+        tableRow[i + 1] == null ||
+        tableRow[i + 1].type === 'tableSeparator'
+      )) {
+        node.content = node.content.replace(TABLE_CELL_END_TRIM, "");
+      }
+      cells[cells.length - 1].push(node);
+    }
   });
+  return cells;
 }
 
-function parseTableAlign(capture /*, parse, state*/) {
-  const alignText = capture[2]
+function parseTableAlign(source /*, parse, state*/) {
+  const alignText = source
     .replace(TABLE_TRIM_PIPES, '')
-    .trim()
-    .split(TABLE_ROW_SPLIT);
+    .split('|');
 
   return alignText.map(parseTableAlignCapture);
 }
 
-function parseTableCells(capture, parse, state) {
-  const rowsText = capture[3]
+function parseTableCells(source, parse, state) {
+  const rowsText = source
     .trim()
     .split('\n');
 
   return rowsText.map(function(rowText) {
-    return rowText
-      .replace(TABLE_TRIM_PIPES, '')
-      .split(TABLE_ROW_SPLIT)
-      .map(function(text) {
-        return parse(text.trim(), state);
-      });
+      return parseTableRow(rowText, parse, state);
   });
 }
 
 function parseTable(capture, parse, state) {
   state.inline = true;
-  const header = parseTableHeader(capture, parse, state);
-  const align = parseTableAlign(capture, parse, state);
-  const cells = parseTableCells(capture, parse, state);
+  const header = parseTableRow(capture[1], parse, state);
+  const align = parseTableAlign(capture[2], parse, state);
+  const cells = parseTableCells(capture[3], parse, state);
   state.inline = false;
 
   return {
@@ -374,6 +385,8 @@ function attributeValueToJSXPropValue(key, value) {
 
       return styles;
     }, {});
+  } else if (key === 'href') {
+    return sanitizeUrl(value)
   } else if (value.match(INTERPOLATION_R)) {
     // return as a string and let the consumer decide what to do with it
     value = value.slice(1, value.length - 1);
@@ -805,7 +818,7 @@ export function compiler(markdown, options) {
                 { key: index }
               );
             }
-          } else {
+          } else if (raw !== 'style') {
             map[ATTRIBUTE_TO_JSX_PROP_MAP[raw] || raw] = true;
           }
 
@@ -814,6 +827,10 @@ export function compiler(markdown, options) {
       : undefined;
   }
 
+  function stripHtmlComments(html) {
+    return html.replace(/<!--[\s\S]*?(?:-->)/g, '')
+  }
+
   /* istanbul ignore next */
   if (process.env.NODE_ENV !== 'production') {
     if (typeof markdown !== 'string') {
@@ -1013,47 +1030,6 @@ export function compiler(markdown, options) {
       },
     },
 
-    htmlBlock: {
-      /**
-       * find the first matching end tag and process the interior
-       */
-      match: anyScopeRegex(HTML_BLOCK_ELEMENT_R),
-      order: PARSE_PRIORITY_HIGH,
-      parse(capture, parse, state) {
-        const [, whitespace] = capture[3].match(HTML_LEFT_TRIM_AMOUNT_R);
-        const trimmer = new RegExp(`^${whitespace}`, 'gm');
-        const trimmed = capture[3].replace(trimmer, '');
-
-        const parseFunc = containsBlockSyntax(trimmed)
-          ? parseBlock
-          : parseInline;
-
-        const tagName = capture[1].toLowerCase();
-        const noInnerParse =
-          DO_NOT_PROCESS_HTML_ELEMENTS.indexOf(tagName) !== -1;
-
-        return {
-          attrs: attrStringToMap(capture[2]),
-          /**
-           * if another html block is detected within, parse as block,
-           * otherwise parse as inline to pick up any further markdown
-           */
-          content: noInnerParse ? capture[3] : parseFunc(parse, trimmed, state),
-
-          noInnerParse,
-
-          tag: noInnerParse ? tagName : capture[1]
-        };
-      },
-      react(node, output, state) {
-        return (
-          <node.tag key={state.key} {...node.attrs}>
-            {node.noInnerParse ? node.content : output(node.content, state)}
-          </node.tag>
-        );
-      },
-    },
-
     htmlComment: {
       match: anyScopeRegex(HTML_COMMENT_R),
       order: PARSE_PRIORITY_HIGH,
@@ -1063,23 +1039,6 @@ export function compiler(markdown, options) {
       react: renderNothing,
     },
 
-    htmlSelfClosing: {
-      /**
-       * find the first matching end tag and process the interior
-       */
-      match: anyScopeRegex(HTML_SELF_CLOSING_ELEMENT_R),
-      order: PARSE_PRIORITY_HIGH,
-      parse(capture /*, parse, state*/) {
-        return {
-          attrs: attrStringToMap(capture[2] || ''),
-          tag: capture[1],
-        };
-      },
-      react(node, output, state) {
-        return <node.tag {...node.attrs} key={state.key} />;
-      },
-    },
-
     image: {
       match: simpleInlineRegex(IMAGE_R),
       order: PARSE_PRIORITY_HIGH,
@@ -1411,6 +1370,21 @@ export function compiler(markdown, options) {
       },
     },
 
+    tableSeparator: {
+      match: function(source, state) {
+        if (!state.inTable) {
+            return null;
+        }
+        return TABLE_SEPARATOR_R.exec(source);
+      },
+      order: PARSE_PRIORITY_HIGH,
+      parse: function() {
+          return { type: 'tableSeparator' };
+      },
+      // These shouldn't be reached, but in case they are, be reasonable:
+      react() { return ' | '; }
+    },
+
     text: {
       // Here we look for anything followed by non-symbols,
       // double newlines, or double-space-newlines
@@ -1521,10 +1495,70 @@ export function compiler(markdown, options) {
   //     };
   // });
 
+  if (options.disableParsingRawHTML !== true) {
+    rules.htmlBlock = {
+      /**
+       * find the first matching end tag and process the interior
+       */
+      match: anyScopeRegex(HTML_BLOCK_ELEMENT_R),
+      order: PARSE_PRIORITY_HIGH,
+      parse(capture, parse, state) {
+        const [, whitespace] = capture[3].match(HTML_LEFT_TRIM_AMOUNT_R);
+        const trimmer = new RegExp(`^${whitespace}`, 'gm');
+        const trimmed = capture[3].replace(trimmer, '');
+
+        const parseFunc = containsBlockSyntax(trimmed)
+          ? parseBlock
+          : parseInline;
+
+        const tagName = capture[1].toLowerCase();
+        const noInnerParse =
+          DO_NOT_PROCESS_HTML_ELEMENTS.indexOf(tagName) !== -1;
+
+        return {
+          attrs: attrStringToMap(capture[2]),
+          /**
+           * if another html block is detected within, parse as block,
+           * otherwise parse as inline to pick up any further markdown
+           */
+          content: noInnerParse ? capture[3] : parseFunc(parse, trimmed, state),
+
+          noInnerParse,
+
+          tag: noInnerParse ? tagName : capture[1]
+        };
+      },
+      react(node, output, state) {
+        return (
+          <node.tag key={state.key} {...node.attrs}>
+            {node.noInnerParse ? node.content : output(node.content, state)}
+          </node.tag>
+        );
+      },
+    }
+
+    rules.htmlSelfClosing = {
+      /**
+       * find the first matching end tag and process the interior
+       */
+      match: anyScopeRegex(HTML_SELF_CLOSING_ELEMENT_R),
+      order: PARSE_PRIORITY_HIGH,
+      parse(capture /*, parse, state*/) {
+        return {
+          attrs: attrStringToMap(capture[2] || ''),
+          tag: capture[1],
+        };
+      },
+      react(node, output, state) {
+        return <node.tag {...node.attrs} key={state.key} />;
+      },
+    };
+  }
+
   const parser = parserFor(rules);
   const emitter = reactFor(ruleOutput(rules));
 
-  const jsx = compile(markdown);
+  const jsx = compile(stripHtmlComments(markdown));
 
   if (footnotes.length) {
     jsx.props.children.push(

package/package.json

@@ -3,7 +3,7 @@
   "description": "Convert markdown to JSX with ease for React and React-like projects. Super lightweight and highly configurable.",
   "homepage": "https://probablyup.github.io/markdown-to-jsx",
   "license": "MIT",
-  "version": "6.10.1",
+  "version": "6.11.1",
   "engines": {
     "node": ">= 4"
   },
@@ -90,7 +90,7 @@
   "size-limit": [
     {
       "path": "dist/cjs.js",
-      "limit": "5.15 kB"
+      "limit": "5.28 kB"
     }
   ],
   "jest": {