@khanacademy/simple-markdown 0.8.1 → 0.8.2

package/dist/es/index.js

@@ -1,2 +1,1665 @@
-var t,n,r,e,u,o,i,a,l=/\r\n?/g,c=/\t/g,f=/\f/g,p=function(t){return t.replace(l,"\n").replace(f,"").replace(c,"    ")},s=function(t,n){var r=t||{};if(null!=n)for(var e in n)Object.prototype.hasOwnProperty.call(n,e)&&(r[e]=n[e]);return r},h=function(t,n){var r,e=Object.keys(t).filter((function(n){var r=t[n];if(null==r||null==r.match)return!1;var e=r.order;return"number"==typeof e&&isFinite(e)||"undefined"==typeof console||console.warn("simple-markdown: Invalid order for rule `"+n+"`: "+String(e)),!0}));e.sort((function(n,r){var e=t[n],u=t[r],o=e.order,i=u.order;if(o!==i)return o-i;var a=e.quality?0:1,l=u.quality?0:1;return a!==l?a-l:n<r?-1:n>r?1:0}));var u=function n(u,o){var i=[];for(r=o=o||r;u;){var a=null,l=null,c=null,f=NaN,p=0,s=e[0],h=t[s];do{var d=h.order,g=null==o.prevCapture?"":o.prevCapture[0],m=h.match(u,o,g);if(m){var y=h.quality?h.quality(m,o,g):0;y<=f||(a=s,l=h,c=m,f=y)}p++,s=e[p],h=t[s]}while(h&&(!c||h.order===d&&h.quality));if(null==l||null==c)throw new Error("Could not find a matching rule for the below content. The rule with highest `order` should always match content provided to it. Check the definition of `match` for '"+e[e.length-1]+"'. It seems to not match the following source:\n"+u);if(c.index)throw new Error("`match` must return a capture starting at index 0 (the current parse index). Did you forget a ^ at the start of the RegExp?");var v=l.parse(c,n,o);Array.isArray(v)?Array.prototype.push.apply(i,v):(null==v.type&&(v.type=a),i.push(v)),o.prevCapture=c,u=u.substring(o.prevCapture[0].length)}return i};return function(t,e){return(r=s(e,n)).inline||r.disableAutoBlockNewlines||(t+="\n\n"),r.prevCapture=null,u(p(t),r)}},d=function(t){var n=function(n,r,e){return r.inline?t.exec(n):null};return n.regex=t,n},g=function(t){var n=function(n,r){return r.inline?null:t.exec(n)};return n.regex=t,n},m=function(t){var n=function(n,r){return t.exec(n)};return n.regex=t,n},y="function"==typeof Symbol&&Symbol.for&&Symbol.for("react.element")||60103,v=function(t,n,r){return{$$typeof:y,type:t,key:null==n?void 0:n,ref:null,props:r,_owner:null}},S=function(t,n,r,e){r=r||{},e=void 0===e||e;var u="";for(var o in r){var i=r[o];Object.prototype.hasOwnProperty.call(r,o)&&i&&(u+=" "+_(o)+'="'+_(i)+'"')}var a="<"+t+u+">";return e?a+n+"</"+t+">":a},k={},w=function(t){if(null==t)return null;try{var n=new URL(t,"https://localhost").protocol;if(0===n.indexOf("javascript:")||0===n.indexOf("vbscript:")||0===n.indexOf("data:"))return null}catch(t){return null}return t},x=/[<>&"']/g,b={"<":"&lt;",">":"&gt;","&":"&amp;",'"':"&quot;","'":"&#x27;","/":"&#x2F;","`":"&#96;"},_=function(t){return String(t).replace(x,(function(t){return b[t]}))},E=/\\([^0-9A-Za-z\s])/g,R=function(t){return t.replace(E,"$1")},A=function(t,n,r){var e=r.inline||!1;r.inline=!0;var u=t(n,r);return r.inline=e,u},$=function(t,n,r){return{content:A(n,t[1],r)}},O=function(){return{}},T=new RegExp("^( *)((?:[*+-]|\\d+\\.)) +"),j=new RegExp("( *)((?:[*+-]|\\d+\\.)) +[^\\n]*(?:\\n(?!\\1(?:[*+-]|\\d+\\.) )[^\\n]*)*(\n|$)","gm"),P=/\n{2,}$/,C=/^ (?= *`)|(` *) $/g,q=P,F=/ *\n+$/,B=new RegExp("^( *)((?:[*+-]|\\d+\\.)) [\\s\\S]+?(?:\n{2,}(?! )(?!\\1(?:[*+-]|\\d+\\.) )\\n*|\\s*\n*$)"),N=/(?:^|\n)( *)$/,L=(t=/^ *\| *| *\| *$/g,n=/ *$/,r=/^ *-+: *$/,e=/^ *:-+: *$/,u=/^ *:-+ *$/,o=function(t){return r.test(t)?"right":e.test(t)?"center":u.test(t)?"left":null},i=function(t,r,e,u){var o=e.inTable;e.inTable=!0;var i=r(t.trim(),e);e.inTable=o;var a=[[]];return i.forEach((function(t,r){"tableSeparator"===t.type?(!u||0!==r&&r!==i.length-1)&&a.push([]):("text"!==t.type||null!=i[r+1]&&"tableSeparator"!==i[r+1].type||(t.content=t.content.replace(n,"")),a[a.length-1].push(t))})),a},{parseTable:(a=function(n){return function(r,e,u){u.inline=!0;var a=i(r[1],e,u,n),l=function(n,r,e,u){return u&&(n=n.replace(t,"")),n.trim().split("|").map(o)}(r[2],0,0,n),c=function(t,n,r,e){return t.trim().split("\n").map((function(t){return i(t,n,r,e)}))}(r[3],e,u,n);return u.inline=!1,{type:"table",header:a,align:l,cells:c}}})(!0),parseNpTable:a(!1),TABLE_REGEX:/^ *(\|.+)\n *\|( *[-:]+[-| :]*)\n((?: *\|.*(?:\n|$))*)\n*/,NPTABLE_REGEX:/^ *(\S.*\|.*)\n *([-:]+ *\|[-| :]*)\n((?:.*\|.*(?:\n|$))*)\n*/}),I="(?:\\[[^\\]]*\\]|[^\\[\\]]|\\](?=[^\\[]*\\]))*",z="\\s*<?((?:\\([^)]*\\)|[^\\s\\\\]|\\\\.)*?)>?(?:\\s+['\"]([\\s\\S]*?)['\"])?\\s*",G=/mailto:/i,X=function(t,n,r){var e=(t[2]||t[1]).replace(/\s+/g," ").toLowerCase();if(n._defs&&n._defs[e]){var u=n._defs[e];r.target=u.target,r.title=u.title}return n._refs=n._refs||{},n._refs[e]=n._refs[e]||[],n._refs[e].push(r),r},U=0,Z={Array:{react:function(t,n,r){for(var e=r.key,u=[],o=0,i=0;o<t.length;o++,i++){r.key=""+o;var a=t[o];if("text"===a.type)for(a={type:"text",content:a.content};o+1<t.length&&"text"===t[o+1].type;o++)a.content+=t[o+1].content;u.push(n(a,r))}return r.key=e,u},html:function(t,n,r){for(var e="",u=0;u<t.length;u++){var o=t[u];if("text"===o.type)for(o={type:"text",content:o.content};u+1<t.length&&"text"===t[u+1].type;u++)o.content+=t[u+1].content;e+=n(o,r)}return e}},heading:{order:U++,match:g(/^ *(#{1,6})([^\n]+?)#* *(?:\n *)+\n/),parse:function(t){function n(n,r,e){return t.apply(this,arguments)}return n.toString=function(){return t.toString()},n}((function(t,n,r){return{level:t[1].length,content:A(n,t[2].trim(),r)}})),react:function(t,n,r){return v("h"+t.level,r.key,{children:n(t.content,r)})},html:function(t,n,r){return S("h"+t.level,n(t.content,r))}},nptable:{order:U++,match:g(L.NPTABLE_REGEX),parse:L.parseNpTable,react:null,html:null},lheading:{order:U++,match:g(/^([^\n]+)\n *(=|-){3,} *(?:\n *)+\n/),parse:function(t){function n(n,r,e){return t.apply(this,arguments)}return n.toString=function(){return t.toString()},n}((function(t,n,r){return{type:"heading",level:"="===t[2]?1:2,content:A(n,t[1],r)}})),react:null,html:null},hr:{order:U++,match:g(/^( *[-*_]){3,} *(?:\n *)+\n/),parse:O,react:function(t,n,r){return v("hr",r.key,k)},html:function(t,n,r){return"<hr>"}},codeBlock:{order:U++,match:g(/^(?:    [^\n]+\n*)+(?:\n *)+\n/),parse:function(t){function n(n,r,e){return t.apply(this,arguments)}return n.toString=function(){return t.toString()},n}((function(t,n,r){return{lang:void 0,content:t[0].replace(/^    /gm,"").replace(/\n+$/,"")}})),react:function(t,n,r){var e=t.lang?"markdown-code-"+t.lang:void 0;return v("pre",r.key,{children:v("code",null,{className:e,children:t.content})})},html:function(t,n,r){var e=t.lang?"markdown-code-"+t.lang:void 0,u=S("code",_(t.content),{class:e});return S("pre",u)}},fence:{order:U++,match:g(/^ *(`{3,}|~{3,}) *(?:(\S+) *)?\n([\s\S]+?)\n?\1 *(?:\n *)+\n/),parse:function(t){function n(n,r,e){return t.apply(this,arguments)}return n.toString=function(){return t.toString()},n}((function(t,n,r){return{type:"codeBlock",lang:t[2]||void 0,content:t[3]}})),react:null,html:null},blockQuote:{order:U++,match:g(/^( *>[^\n]+(\n[^\n]+)*\n*)+\n{2,}/),parse:function(t){function n(n,r,e){return t.apply(this,arguments)}return n.toString=function(){return t.toString()},n}((function(t,n,r){return{content:n(t[0].replace(/^ *> ?/gm,""),r)}})),react:function(t,n,r){return v("blockquote",r.key,{children:n(t.content,r)})},html:function(t,n,r){return S("blockquote",n(t.content,r))}},list:{order:U++,match:function(t,n){var r=null==n.prevCapture?"":n.prevCapture[0],e=N.exec(r),u=n._list||!n.inline;return e&&u?(t=e[1]+t,B.exec(t)):null},parse:function(t){function n(n,r,e){return t.apply(this,arguments)}return n.toString=function(){return t.toString()},n}((function(t,n,r){var e=t[2],u=e.length>1,o=u?+e:void 0,i=t[0].replace(q,"\n").match(j),a=!1;return{ordered:u,start:o,items:i.map((function(t,e){var u=T.exec(t),o=u?u[0].length:0,l=new RegExp("^ {1,"+o+"}","gm"),c=t.replace(l,"").replace(T,""),f=e===i.length-1,p=-1!==c.indexOf("\n\n")||f&&a;a=p;var s,h=r.inline,d=r._list;r._list=!0,p?(r.inline=!1,s=c.replace(F,"\n\n")):(r.inline=!0,s=c.replace(F,""));var g=n(s,r);return r.inline=h,r._list=d,g}))}})),react:function(t,n,r){var e=t.ordered?"ol":"ul";return v(e,r.key,{start:t.start,children:t.items.map((function(t,e){return v("li",""+e,{children:n(t,r)})}))})},html:function(t,n,r){var e=t.items.map((function(t){return S("li",n(t,r))})).join(""),u=t.ordered?"ol":"ul",o={start:t.start};return S(u,e,o)}},def:{order:U++,match:g(/^ *\[([^\]]+)\]: *<?([^\s>]*)>?(?: +["(]([^\n]+)[")])? *\n(?: *\n)*/),parse:function(t){function n(n,r,e){return t.apply(this,arguments)}return n.toString=function(){return t.toString()},n}((function(t,n,r){var e=t[1].replace(/\s+/g," ").toLowerCase(),u=t[2],o=t[3];return r._refs&&r._refs[e]&&r._refs[e].forEach((function(t){t.target=u,t.title=o})),r._defs=r._defs||{},r._defs[e]={target:u,title:o},{def:e,target:u,title:o}})),react:function(){return null},html:function(){return""}},table:{order:U++,match:g(L.TABLE_REGEX),parse:L.parseTable,react:function(t,n,r){var e=function(n){return null==t.align[n]?{}:{textAlign:t.align[n]}},u=t.header.map((function(t,u){return v("th",""+u,{style:e(u),scope:"col",children:n(t,r)})})),o=t.cells.map((function(t,u){return v("tr",""+u,{children:t.map((function(t,u){return v("td",""+u,{style:e(u),children:n(t,r)})}))})}));return v("table",r.key,{children:[v("thead","thead",{children:v("tr",null,{children:u})}),v("tbody","tbody",{children:o})]})},html:function(t,n,r){var e=function(n){return null==t.align[n]?"":"text-align:"+t.align[n]+";"},u=t.header.map((function(t,u){return S("th",n(t,r),{style:e(u),scope:"col"})})).join(""),o=t.cells.map((function(t){var u=t.map((function(t,u){return S("td",n(t,r),{style:e(u)})})).join("");return S("tr",u)})).join(""),i=S("thead",S("tr",u)),a=S("tbody",o);return S("table",i+a)}},newline:{order:U++,match:g(/^(?:\n *)*\n/),parse:O,react:function(t,n,r){return"\n"},html:function(t,n,r){return"\n"}},paragraph:{order:U++,match:g(/^((?:[^\n]|\n(?! *\n))+)(?:\n *)+\n/),parse:$,react:function(t,n,r){return v("div",r.key,{className:"paragraph",children:n(t.content,r)})},html:function(t,n,r){return S("div",n(t.content,r),{class:"paragraph"})}},escape:{order:U++,match:d(/^\\([^0-9A-Za-z\s])/),parse:function(t){function n(n,r,e){return t.apply(this,arguments)}return n.toString=function(){return t.toString()},n}((function(t,n,r){return{type:"text",content:t[1]}})),react:null,html:null},tableSeparator:{order:U++,match:function(t,n){return n.inTable?/^ *\| */.exec(t):null},parse:function(){return{type:"tableSeparator"}},react:function(){return" | "},html:function(){return" &vert; "}},autolink:{order:U++,match:d(/^<([^: >]+:\/[^ >]+)>/),parse:function(t){function n(n,r,e){return t.apply(this,arguments)}return n.toString=function(){return t.toString()},n}((function(t,n,r){return{type:"link",content:[{type:"text",content:t[1]}],target:t[1]}})),react:null,html:null},mailto:{order:U++,match:d(/^<([^ >]+@[^ >]+)>/),parse:function(t){function n(n,r,e){return t.apply(this,arguments)}return n.toString=function(){return t.toString()},n}((function(t,n,r){var e=t[1],u=t[1];return G.test(u)||(u="mailto:"+u),{type:"link",content:[{type:"text",content:e}],target:u}})),react:null,html:null},url:{order:U++,match:d(/^(https?:\/\/[^\s<]+[^<.,:;"')\]\s])/),parse:function(t){function n(n,r,e){return t.apply(this,arguments)}return n.toString=function(){return t.toString()},n}((function(t,n,r){return{type:"link",content:[{type:"text",content:t[1]}],target:t[1],title:void 0}})),react:null,html:null},link:{order:U++,match:d(new RegExp("^\\[("+I+")\\]\\("+z+"\\)")),parse:function(t){function n(n,r,e){return t.apply(this,arguments)}return n.toString=function(){return t.toString()},n}((function(t,n,r){return{content:n(t[1],r),target:R(t[2]),title:t[3]}})),react:function(t,n,r){return v("a",r.key,{href:w(t.target),title:t.title,children:n(t.content,r)})},html:function(t,n,r){var e={href:w(t.target),title:t.title};return S("a",n(t.content,r),e)}},image:{order:U++,match:d(new RegExp("^!\\[("+I+")\\]\\("+z+"\\)")),parse:function(t){function n(n,r,e){return t.apply(this,arguments)}return n.toString=function(){return t.toString()},n}((function(t,n,r){return{alt:t[1],target:R(t[2]),title:t[3]}})),react:function(t,n,r){return v("img",r.key,{src:w(t.target),alt:t.alt,title:t.title})},html:function(t,n,r){var e={src:w(t.target),alt:t.alt,title:t.title};return S("img","",e,!1)}},reflink:{order:U++,match:d(new RegExp("^\\[("+I+")\\]\\s*\\[([^\\]]*)\\]")),parse:function(t){function n(n,r,e){return t.apply(this,arguments)}return n.toString=function(){return t.toString()},n}((function(t,n,r){return X(t,r,{type:"link",content:n(t[1],r)})})),react:null,html:null},refimage:{order:U++,match:d(new RegExp("^!\\[("+I+")\\]\\s*\\[([^\\]]*)\\]")),parse:function(t){function n(n,r,e){return t.apply(this,arguments)}return n.toString=function(){return t.toString()},n}((function(t,n,r){return X(t,r,{type:"image",alt:t[1]})})),react:null,html:null},em:{order:U,match:d(new RegExp("^\\b_((?:__|\\\\[\\s\\S]|[^\\\\_])+?)_\\b|^\\*(?=\\S)((?:\\*\\*|\\\\[\\s\\S]|\\s+(?:\\\\[\\s\\S]|[^\\s\\*\\\\]|\\*\\*)|[^\\s\\*\\\\])+?)\\*(?!\\*)")),quality:function(t){return t[0].length+.2},parse:function(t){function n(n,r,e){return t.apply(this,arguments)}return n.toString=function(){return t.toString()},n}((function(t,n,r){return{content:n(t[2]||t[1],r)}})),react:function(t,n,r){return v("em",r.key,{children:n(t.content,r)})},html:function(t,n,r){return S("em",n(t.content,r))}},strong:{order:U,match:d(/^\*\*((?:\\[\s\S]|[^\\])+?)\*\*(?!\*)/),quality:function(t){return t[0].length+.1},parse:$,react:function(t,n,r){return v("strong",r.key,{children:n(t.content,r)})},html:function(t,n,r){return S("strong",n(t.content,r))}},u:{order:U++,match:d(/^__((?:\\[\s\S]|[^\\])+?)__(?!_)/),quality:function(t){return t[0].length},parse:$,react:function(t,n,r){return v("u",r.key,{children:n(t.content,r)})},html:function(t,n,r){return S("u",n(t.content,r))}},del:{order:U++,match:d(/^~~(?=\S)((?:\\[\s\S]|~(?!~)|[^\s~\\]|\s(?!~~))+?)~~/),parse:$,react:function(t,n,r){return v("del",r.key,{children:n(t.content,r)})},html:function(t,n,r){return S("del",n(t.content,r))}},inlineCode:{order:U++,match:d(/^(`+)([\s\S]*?[^`])\1(?!`)/),parse:function(t){function n(n,r,e){return t.apply(this,arguments)}return n.toString=function(){return t.toString()},n}((function(t,n,r){return{content:t[2].replace(C,"$1")}})),react:function(t,n,r){return v("code",r.key,{children:t.content})},html:function(t,n,r){return S("code",_(t.content))}},br:{order:U++,match:m(/^ {2,}\n/),parse:O,react:function(t,n,r){return v("br",r.key,k)},html:function(t,n,r){return"<br>"}},text:{order:U++,match:m(/^[\s\S]+?(?=[^0-9A-Za-z\s\u00c0-\uffff]|\n\n| {2,}\n|\w+:\S|$)/),parse:function(t){function n(n,r,e){return t.apply(this,arguments)}return n.toString=function(){return t.toString()},n}((function(t,n,r){return{content:t[0]}})),react:function(t,n,r){return t.content},html:function(t,n,r){return _(t.content)}}},H=function(t,n){var r,e=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};if(!n)throw new Error("simple-markdown: outputFor: `property` must be defined. if you just upgraded, you probably need to replace `outputFor` with `reactFor`");var u=t.Array||Z.Array,o=u[n];if(!o)throw new Error("simple-markdown: outputFor: to join nodes of type `"+n+"` you must provide an `Array:` joiner rule with that type, Please see the docs for details on specifying an Array rule.");var i=o,a=function e(u,o){return r=o=o||r,Array.isArray(u)?i(u,e,o):t[u.type][n](u,e,o)},l=function(t,n){return r=s(n,e),a(t,r)};return l},D=h(Z),M=function(t,n){return(n=n||{}).inline=!1,D(t,n)},Q=function(t,n){var r=P.test(t);return(n=n||{}).inline=!r,D(t,n)},J=H(Z,"react"),K=H(Z,"html"),V=function(t,n){return J(M(t,n),n)},W={defaultRules:Z,parserFor:h,outputFor:H,inlineRegex:d,blockRegex:g,anyScopeRegex:m,parseInline:A,parseBlock:function(t,n,r){var e=r.inline||!1;r.inline=!1;var u=t(n+"\n\n",r);return r.inline=e,u},markdownToReact:V,markdownToHtml:function(t,n){return K(M(t,n),n)},ReactMarkdown:function(t){var n={};for(var r in t)"source"!==r&&Object.prototype.hasOwnProperty.call(t,r)&&(n[r]=t[r]);return n.children=V(t.source),v("div",null,n)},defaultBlockParse:M,defaultInlineParse:function(t,n){return(n=n||{}).inline=!0,D(t,n)},defaultImplicitParse:Q,defaultReactOutput:J,defaultHtmlOutput:K,preprocess:p,sanitizeText:_,sanitizeUrl:w,unescapeUrl:R,htmlTag:S,reactElement:v,defaultRawParse:D,ruleOutput:function(t,n){n||"undefined"==typeof console||console.warn("simple-markdown ruleOutput should take 'react' or 'html' as the second argument.");return function(r,e,u){return t[r.type][n](r,e,u)}},reactFor:function(t){return function n(r,e){if(e=e||{},Array.isArray(r)){for(var u=e.key,o=[],i=null,a=0;a<r.length;a++){e.key=""+a;var l=n(r[a],e);"string"==typeof l&&"string"==typeof i?(i+=l,o[o.length-1]=i):(o.push(l),i=l)}return e.key=u,o}return t(r,n,e)}},htmlFor:function(t){return function n(r,e){return e=e||{},Array.isArray(r)?r.map((function(t){return n(t,e)})).join(""):t(r,n,e)}},defaultParse:function(){return"undefined"!=typeof console&&console.warn("defaultParse is deprecated, please use `defaultImplicitParse`"),Q.apply(null,arguments)},defaultOutput:function(){return"undefined"!=typeof console&&console.warn("defaultOutput is deprecated, please use `defaultReactOutput`"),J.apply(null,arguments)}};export{W as default};
+/* eslint-disable prefer-spread, no-regex-spaces, no-unused-vars, guard-for-in, no-console, no-var */
+
+/**
+ * Simple-Markdown
+ * ===============
+ *
+ * Simple-Markdown's primary goal is to be easy to adapt. It aims
+ * to be compliant with John Gruber's [Markdown Syntax page][1],
+ * but compatiblity with other markdown implementations' edge-cases
+ * will be sacrificed where it conflicts with simplicity or
+ * extensibility.
+ *
+ * If your goal is to simply embed a standard markdown implementation
+ * in your website, simple-markdown is probably not the best library
+ * for you (although it should work). But if you have struggled to
+ * customize an existing library to meet your needs, simple-markdown
+ * might be able to help.
+ *
+ * Many of the regexes and original logic has been adapted from
+ * the wonderful [marked.js](https://github.com/chjj/marked)
+ */
+// Flow Type Definitions:
+// We want to clarify our defaultRules types a little bit more so clients can
+// reuse defaultRules built-ins. So we make some stronger guarantess when
+// we can:
+// End Flow Definitions
+var CR_NEWLINE_R = /\r\n?/g;
+var TAB_R = /\t/g;
+var FORMFEED_R = /\f/g;
+/**
+ * Turn various whitespace into easy-to-process whitespace
+ */
+
+var preprocess = function preprocess(source) {
+  return source.replace(CR_NEWLINE_R, "\n").replace(FORMFEED_R, "").replace(TAB_R, "    ");
+};
+
+var populateInitialState = function populateInitialState(givenState, defaultState) {
+  var state = givenState || {};
+
+  if (defaultState != null) {
+    for (var prop in defaultState) {
+      // $FlowFixMe
+      if (Object.prototype.hasOwnProperty.call(defaultState, prop)) {
+        state[prop] = defaultState[prop];
+      }
+    }
+  }
+
+  return state;
+};
+/**
+ * Creates a parser for a given set of rules, with the precedence
+ * specified as a list of rules.
+ *
+ * @param {SimpleMarkdown.ParserRules} rules
+ *     an object containing
+ *     rule type -> {match, order, parse} objects
+ *     (lower order is higher precedence)
+ * @param {SimpleMarkdown.OptionalState} [defaultState]
+ *
+ * @returns {SimpleMarkdown.Parser}
+ *     The resulting parse function, with the following parameters:
+ *     @source: the input source string to be parsed
+ *     @state: an optional object to be threaded through parse
+ *         calls. Allows clients to add stateful operations to
+ *         parsing, such as keeping track of how many levels deep
+ *         some nesting is. For an example use-case, see passage-ref
+ *         parsing in src/widgets/passage/passage-markdown.jsx
+ */
+
+
+var parserFor = function parserFor(rules, defaultState) {
+  // Sorts rules in order of increasing order, then
+  // ascending rule name in case of ties.
+  var ruleList = Object.keys(rules).filter(function (type) {
+    var rule = rules[type];
+
+    if (rule == null || rule.match == null) {
+      return false;
+    }
+
+    var order = rule.order;
+
+    if ((typeof order !== "number" || !isFinite(order)) && typeof console !== "undefined") {
+      console.warn("simple-markdown: Invalid order for rule `" + type + "`: " + String(order));
+    }
+
+    return true;
+  });
+  ruleList.sort(function (typeA, typeB) {
+    var ruleA = rules[typeA];
+    var ruleB = rules[typeB];
+    var orderA = ruleA.order;
+    var orderB = ruleB.order; // First sort based on increasing order
+
+    if (orderA !== orderB) {
+      return orderA - orderB;
+    }
+
+    var secondaryOrderA = ruleA.quality ? 0 : 1;
+    var secondaryOrderB = ruleB.quality ? 0 : 1;
+
+    if (secondaryOrderA !== secondaryOrderB) {
+      return secondaryOrderA - secondaryOrderB; // Then based on increasing unicode lexicographic ordering
+    } else if (typeA < typeB) {
+      return -1;
+    } else if (typeA > typeB) {
+      return 1;
+    } else {
+      // Rules should never have the same name,
+      // but this is provided for completeness.
+      return 0;
+    }
+  });
+  var latestState;
+
+  var nestedParse = function nestedParse(source, state) {
+    var result = [];
+    state = state || latestState;
+    latestState = state;
+
+    while (source) {
+      // store the best match, it's rule, and quality:
+      var ruleType = null;
+      var rule = null;
+      var capture = null;
+      var quality = NaN; // loop control variables:
+
+      var i = 0;
+      var currRuleType = ruleList[0]; // $FlowFixMe
+
+      var currRule = rules[currRuleType];
+
+      do {
+        var currOrder = currRule.order;
+        var prevCaptureStr = state.prevCapture == null ? "" : state.prevCapture[0];
+        var currCapture = currRule.match(source, state, prevCaptureStr);
+
+        if (currCapture) {
+          var currQuality = currRule.quality ? currRule.quality(currCapture, state, prevCaptureStr) : 0; // This should always be true the first time because
+          // the initial quality is NaN (that's why there's the
+          // condition negation).
+
+          if (!(currQuality <= quality)) {
+            ruleType = currRuleType;
+            rule = currRule;
+            capture = currCapture;
+            quality = currQuality;
+          }
+        } // Move on to the next item.
+        // Note that this makes `currRule` be the next item
+
+
+        i++;
+        currRuleType = ruleList[i]; // $FlowFixMe
+
+        currRule = rules[currRuleType];
+      } while ( // keep looping while we're still within the ruleList
+      currRule && ( // if we don't have a match yet, continue
+      !capture || // or if we have a match, but the next rule is
+      // at the same order, and has a quality measurement
+      // functions, then this rule must have a quality
+      // measurement function (since they are sorted before
+      // those without), and we need to check if there is
+      // a better quality match
+      currRule.order === currOrder && currRule.quality)); // TODO(aria): Write tests for these
+
+
+      if (rule == null || capture == null) {
+        throw new Error("Could not find a matching rule for the below " + "content. The rule with highest `order` should " + "always match content provided to it. Check " + "the definition of `match` for '" + ruleList[ruleList.length - 1] + "'. It seems to not match the following source:\n" + source);
+      }
+
+      if (capture.index) {
+        // If present and non-zero, i.e. a non-^ regexp result:
+        throw new Error("`match` must return a capture starting at index 0 " + "(the current parse index). Did you forget a ^ at the " + "start of the RegExp?");
+      } // $FlowFixMe
+
+
+      var parsed = rule.parse(capture, nestedParse, state); // We maintain the same object here so that rules can
+      // store references to the objects they return and
+      // modify them later. (oops sorry! but this adds a lot
+      // of power--see reflinks.)
+
+      if (Array.isArray(parsed)) {
+        // $FlowFixMe
+        Array.prototype.push.apply(result, parsed);
+      } else {
+        // We also let rules override the default type of
+        // their parsed node if they would like to, so that
+        // there can be a single output function for all links,
+        // even if there are several rules to parse them.
+        if (parsed.type == null) {
+          // $FlowFixMe
+          parsed.type = ruleType;
+        }
+
+        result.push(parsed);
+      }
+
+      state.prevCapture = capture;
+      source = source.substring(state.prevCapture[0].length);
+    } // $FlowFixMe
+
+
+    return result;
+  };
+
+  var outerParse = function outerParse(source, state) {
+    latestState = populateInitialState(state, defaultState);
+
+    if (!latestState.inline && !latestState.disableAutoBlockNewlines) {
+      source = source + "\n\n";
+    } // We store the previous capture so that match functions can
+    // use some limited amount of lookbehind. Lists use this to
+    // ensure they don't match arbitrary '- ' or '* ' in inline
+    // text (see the list rule for more information). This stores
+    // the full regex capture object, if there is one.
+
+
+    latestState.prevCapture = null;
+    return nestedParse(preprocess(source), latestState);
+  }; // $FlowFixMe
+
+
+  return outerParse;
+}; // Creates a match function for an inline scoped element from a regex
+
+
+var inlineRegex = function inlineRegex(regex) {
+  var match = function match(source, state, prevCapture) {
+    if (state.inline) {
+      // $FlowFixMe
+      return regex.exec(source);
+    } else {
+      return null;
+    }
+  };
+
+  match.regex = regex;
+  return match;
+}; // Creates a match function for a block scoped element from a regex
+
+
+var blockRegex = function blockRegex(regex) {
+  // $FlowFixMe
+  var match = function match(source, state) {
+    if (state.inline) {
+      return null;
+    } else {
+      return regex.exec(source);
+    }
+  };
+
+  match.regex = regex;
+  return match;
+}; // Creates a match function from a regex, ignoring block/inline scope
+
+
+var anyScopeRegex = function anyScopeRegex(regex) {
+  // $FlowFixMe
+  var match = function match(source, state) {
+    return regex.exec(source);
+  };
+
+  match.regex = regex;
+  return match;
+};
+
+var TYPE_SYMBOL = typeof Symbol === "function" && Symbol.for && Symbol.for("react.element") || 0xeac7;
+
+var reactElement = function reactElement(type, key, props) {
+  var element = {
+    $$typeof: TYPE_SYMBOL,
+    type: type,
+    key: key == null ? undefined : key,
+    ref: null,
+    props: props,
+    _owner: null
+  };
+  return element;
+};
+/** Returns a closed HTML tag.
+ * @param {string} tagName - Name of HTML tag (eg. "em" or "a")
+ * @param {string} content - Inner content of tag
+ * @param {{ [attr: string]: SimpleMarkdown.Attr }} [attributes] - Optional extra attributes of tag as an object of key-value pairs
+ *   eg. { "href": "http://google.com" }. Falsey attributes are filtered out.
+ * @param {boolean} [isClosed] - boolean that controls whether tag is closed or not (eg. img tags).
+ *   defaults to true
+ */
+
+
+var htmlTag = function htmlTag(tagName, content, attributes, isClosed) {
+  attributes = attributes || {};
+  isClosed = typeof isClosed !== "undefined" ? isClosed : true;
+  var attributeString = "";
+
+  for (var attr in attributes) {
+    var attribute = attributes[attr]; // Removes falsey attributes
+
+    if ( // $FlowFixMe
+    Object.prototype.hasOwnProperty.call(attributes, attr) && attribute) {
+      attributeString += " " + sanitizeText(attr) + '="' + sanitizeText(attribute) + '"';
+    }
+  }
+
+  var unclosedTag = "<" + tagName + attributeString + ">";
+
+  if (isClosed) {
+    return unclosedTag + content + "</" + tagName + ">";
+  } else {
+    return unclosedTag;
+  }
+};
+
+var EMPTY_PROPS = {};
+/**
+ * @param {string | null | undefined} url - url to sanitize
+ * @returns {string | null} - url if safe, or null if a safe url could not be made
+ */
+
+var sanitizeUrl = function sanitizeUrl(url) {
+  if (url == null) {
+    return null;
+  }
+
+  try {
+    var prot = new URL(url, "https://localhost").protocol;
+
+    if (prot.indexOf("javascript:") === 0 || prot.indexOf("vbscript:") === 0 || prot.indexOf("data:") === 0) {
+      return null;
+    }
+  } catch (e) {
+    // invalid URLs should throw a TypeError
+    // see for instance: `new URL("");`
+    return null;
+  }
+
+  return url;
+};
+
+var SANITIZE_TEXT_R = /[<>&"']/g;
+var SANITIZE_TEXT_CODES = {
+  "<": "&lt;",
+  ">": "&gt;",
+  "&": "&amp;",
+  '"': "&quot;",
+  "'": "&#x27;",
+  "/": "&#x2F;",
+  "`": "&#96;"
+};
+
+var sanitizeText = function sanitizeText(text) {
+  return String(text).replace(SANITIZE_TEXT_R, function (chr) {
+    return SANITIZE_TEXT_CODES[chr];
+  });
+};
+
+var UNESCAPE_URL_R = /\\([^0-9A-Za-z\s])/g;
+
+var unescapeUrl = function unescapeUrl(rawUrlString) {
+  return rawUrlString.replace(UNESCAPE_URL_R, "$1");
+};
+/**
+ * Parse some content with the parser `parse`, with state.inline
+ * set to true. Useful for block elements; not generally necessary
+ * to be used by inline elements (where state.inline is already true.
+ */
+
+
+var parseInline = function parseInline(parse, content, state) {
+  var isCurrentlyInline = state.inline || false;
+  state.inline = true;
+  var result = parse(content, state);
+  state.inline = isCurrentlyInline;
+  return result;
+};
+
+var parseBlock = function parseBlock(parse, content, state) {
+  var isCurrentlyInline = state.inline || false;
+  state.inline = false;
+  var result = parse(content + "\n\n", state);
+  state.inline = isCurrentlyInline;
+  return result;
+};
+
+var parseCaptureInline = function parseCaptureInline(capture, parse, state) {
+  return {
+    content: parseInline(parse, capture[1], state)
+  };
+};
+
+var ignoreCapture = function ignoreCapture() {
+  return {};
+}; // recognize a `*` `-`, `+`, `1.`, `2.`... list bullet
+
+
+var LIST_BULLET = "(?:[*+-]|\\d+\\.)"; // recognize the start of a list item:
+// leading space plus a bullet plus a space (`   * `)
+
+var LIST_ITEM_PREFIX = "( *)(" + LIST_BULLET + ") +";
+var LIST_ITEM_PREFIX_R = new RegExp("^" + LIST_ITEM_PREFIX); // recognize an individual list item:
+//  * hi
+//    this is part of the same item
+//
+//    as is this, which is a new paragraph in the same item
+//
+//  * but this is not part of the same item
+
+var LIST_ITEM_R = new RegExp(LIST_ITEM_PREFIX + "[^\\n]*(?:\\n" + "(?!\\1" + LIST_BULLET + " )[^\\n]*)*(\n|$)", "gm");
+var BLOCK_END_R = /\n{2,}$/;
+var INLINE_CODE_ESCAPE_BACKTICKS_R = /^ (?= *`)|(` *) $/g; // recognize the end of a paragraph block inside a list item:
+// two or more newlines at end end of the item
+
+var LIST_BLOCK_END_R = BLOCK_END_R;
+var LIST_ITEM_END_R = / *\n+$/; // check whether a list item has paragraphs: if it does,
+// we leave the newlines at the end
+
+var LIST_R = new RegExp("^( *)(" + LIST_BULLET + ") " + "[\\s\\S]+?(?:\n{2,}(?! )" + "(?!\\1" + LIST_BULLET + " )\\n*" + // the \\s*$ here is so that we can parse the inside of nested
+// lists, where our content might end before we receive two `\n`s
+"|\\s*\n*$)");
+var LIST_LOOKBEHIND_R = /(?:^|\n)( *)$/;
+
+var TABLES = function () {
+  var TABLE_ROW_SEPARATOR_TRIM = /^ *\| *| *\| *$/g;
+  var TABLE_CELL_END_TRIM = / *$/;
+  var TABLE_RIGHT_ALIGN = /^ *-+: *$/;
+  var TABLE_CENTER_ALIGN = /^ *:-+: *$/;
+  var TABLE_LEFT_ALIGN = /^ *:-+ *$/; // TODO: This needs a real type
+
+  var parseTableAlignCapture = function parseTableAlignCapture(alignCapture) {
+    if (TABLE_RIGHT_ALIGN.test(alignCapture)) {
+      return "right";
+    } else if (TABLE_CENTER_ALIGN.test(alignCapture)) {
+      return "center";
+    } else if (TABLE_LEFT_ALIGN.test(alignCapture)) {
+      return "left";
+    } else {
+      return null;
+    }
+  };
+
+  var parseTableAlign = function parseTableAlign(source, parse, state, trimEndSeparators) {
+    if (trimEndSeparators) {
+      source = source.replace(TABLE_ROW_SEPARATOR_TRIM, "");
+    }
+
+    var alignText = source.trim().split("|");
+    return alignText.map(parseTableAlignCapture);
+  };
+
+  var parseTableRow = function parseTableRow(source, parse, state, trimEndSeparators) {
+    var prevInTable = state.inTable;
+    state.inTable = true;
+    var tableRow = parse(source.trim(), state);
+    state.inTable = prevInTable;
+    var cells = [[]];
+    tableRow.forEach(function (node, i) {
+      if (node.type === "tableSeparator") {
+        // Filter out empty table separators at the start/end:
+        if (!trimEndSeparators || 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;
+  };
+  /**
+   * @param {string} source
+   * @param {SimpleMarkdown.Parser} parse
+   * @param {SimpleMarkdown.State} state
+   * @param {boolean} trimEndSeparators
+   * @returns {SimpleMarkdown.ASTNode[][]}
+   */
+
+
+  var parseTableCells = function parseTableCells(source, parse, state, trimEndSeparators) {
+    var rowsText = source.trim().split("\n");
+    return rowsText.map(function (rowText) {
+      // $FlowFixMe
+      return parseTableRow(rowText, parse, state, trimEndSeparators);
+    });
+  };
+  /**
+   * @param {boolean} trimEndSeparators
+   * @returns {SimpleMarkdown.SingleNodeParseFunction}
+   */
+
+
+  var parseTable = function parseTable(trimEndSeparators) {
+    return function (capture, parse, state) {
+      state.inline = true;
+      var header = parseTableRow(capture[1], parse, state, trimEndSeparators);
+      var align = parseTableAlign(capture[2], parse, state, trimEndSeparators);
+      var cells = parseTableCells(capture[3], parse, state, trimEndSeparators);
+      state.inline = false;
+      return {
+        type: "table",
+        header: header,
+        align: align,
+        cells: cells
+      };
+    };
+  };
+
+  return {
+    parseTable: parseTable(true),
+    parseNpTable: parseTable(false),
+    TABLE_REGEX: /^ *(\|.+)\n *\|( *[-:]+[-| :]*)\n((?: *\|.*(?:\n|$))*)\n*/,
+    NPTABLE_REGEX: /^ *(\S.*\|.*)\n *([-:]+ *\|[-| :]*)\n((?:.*\|.*(?:\n|$))*)\n*/
+  };
+}();
+
+var LINK_INSIDE = "(?:\\[[^\\]]*\\]|[^\\[\\]]|\\](?=[^\\[]*\\]))*";
+var LINK_HREF_AND_TITLE = "\\s*<?((?:\\([^)]*\\)|[^\\s\\\\]|\\\\.)*?)>?(?:\\s+['\"]([\\s\\S]*?)['\"])?\\s*";
+var AUTOLINK_MAILTO_CHECK_R = /mailto:/i;
+
+var parseRef = function parseRef(capture, state, refNode) {
+  var ref = (capture[2] || capture[1]).replace(/\s+/g, " ").toLowerCase(); // We store information about previously seen defs on
+  // state._defs (_ to deconflict with client-defined
+  // state). If the def for this reflink/refimage has
+  // already been seen, we can use its target/source
+  // and title here:
+
+  if (state._defs && state._defs[ref]) {
+    var def = state._defs[ref]; // `refNode` can be a link or an image. Both use
+    // target and title properties.
+
+    refNode.target = def.target;
+    refNode.title = def.title;
+  } // In case we haven't seen our def yet (or if someone
+  // overwrites that def later on), we add this node
+  // to the list of ref nodes for that def. Then, when
+  // we find the def, we can modify this link/image AST
+  // node :).
+  // I'm sorry.
+
+
+  state._refs = state._refs || {};
+  state._refs[ref] = state._refs[ref] || [];
+
+  state._refs[ref].push(refNode);
+
+  return refNode;
+};
+
+var currOrder = 0;
+var defaultRules = {
+  Array: {
+    react: function react(arr, output, state) {
+      var oldKey = state.key;
+      var result = []; // map output over the ast, except group any text
+      // nodes together into a single string output.
+
+      for (var i = 0, key = 0; i < arr.length; i++, key++) {
+        // `key` is our numerical `state.key`, which we increment for
+        // every output node, but don't change for joined text nodes.
+        // (i, however, must change for joined text nodes)
+        state.key = "" + i;
+        var node = arr[i];
+
+        if (node.type === "text") {
+          node = {
+            type: "text",
+            content: node.content
+          };
+
+          for (; i + 1 < arr.length && arr[i + 1].type === "text"; i++) {
+            node.content += arr[i + 1].content;
+          }
+        }
+
+        result.push(output(node, state));
+      }
+
+      state.key = oldKey;
+      return result;
+    },
+    html: function html(arr, output, state) {
+      var result = ""; // map output over the ast, except group any text
+      // nodes together into a single string output.
+
+      for (var i = 0; i < arr.length; i++) {
+        var node = arr[i];
+
+        if (node.type === "text") {
+          node = {
+            type: "text",
+            content: node.content
+          };
+
+          for (; i + 1 < arr.length && arr[i + 1].type === "text"; i++) {
+            node.content += arr[i + 1].content;
+          }
+        }
+
+        result += output(node, state);
+      }
+
+      return result;
+    }
+  },
+  heading: {
+    order: currOrder++,
+    match: blockRegex(/^ *(#{1,6})([^\n]+?)#* *(?:\n *)+\n/),
+    parse: function (_parse) {
+      function parse(_x, _x2, _x3) {
+        return _parse.apply(this, arguments);
+      }
+
+      parse.toString = function () {
+        return _parse.toString();
+      };
+
+      return parse;
+    }(function (capture, parse, state) {
+      return {
+        level: capture[1].length,
+        content: parseInline(parse, capture[2].trim(), state)
+      };
+    }),
+    react: function react(node, output, state) {
+      return reactElement("h" + node.level, state.key, {
+        children: output(node.content, state)
+      });
+    },
+    html: function html(node, output, state) {
+      return htmlTag("h" + node.level, output(node.content, state));
+    }
+  },
+  nptable: {
+    order: currOrder++,
+    match: blockRegex(TABLES.NPTABLE_REGEX),
+    parse: TABLES.parseNpTable,
+    react: null,
+    html: null
+  },
+  lheading: {
+    order: currOrder++,
+    match: blockRegex(/^([^\n]+)\n *(=|-){3,} *(?:\n *)+\n/),
+    parse: function (_parse2) {
+      function parse(_x4, _x5, _x6) {
+        return _parse2.apply(this, arguments);
+      }
+
+      parse.toString = function () {
+        return _parse2.toString();
+      };
+
+      return parse;
+    }(function (capture, parse, state) {
+      return {
+        type: "heading",
+        level: capture[2] === "=" ? 1 : 2,
+        content: parseInline(parse, capture[1], state)
+      };
+    }),
+    react: null,
+    html: null
+  },
+  hr: {
+    order: currOrder++,
+    match: blockRegex(/^( *[-*_]){3,} *(?:\n *)+\n/),
+    parse: ignoreCapture,
+    react: function react(node, output, state) {
+      return reactElement("hr", state.key, EMPTY_PROPS);
+    },
+    html: function html(node, output, state) {
+      return "<hr>";
+    }
+  },
+  codeBlock: {
+    order: currOrder++,
+    match: blockRegex(/^(?:    [^\n]+\n*)+(?:\n *)+\n/),
+    parse: function (_parse3) {
+      function parse(_x7, _x8, _x9) {
+        return _parse3.apply(this, arguments);
+      }
+
+      parse.toString = function () {
+        return _parse3.toString();
+      };
+
+      return parse;
+    }(function (capture, parse, state) {
+      var content = capture[0].replace(/^    /gm, "").replace(/\n+$/, "");
+      return {
+        lang: undefined,
+        content: content
+      };
+    }),
+    react: function react(node, output, state) {
+      var className = node.lang ? "markdown-code-" + node.lang : undefined;
+      return reactElement("pre", state.key, {
+        children: reactElement("code", null, {
+          className: className,
+          children: node.content
+        })
+      });
+    },
+    html: function html(node, output, state) {
+      var className = node.lang ? "markdown-code-" + node.lang : undefined;
+      var codeBlock = htmlTag("code", sanitizeText(node.content), {
+        class: className
+      });
+      return htmlTag("pre", codeBlock);
+    }
+  },
+  fence: {
+    order: currOrder++,
+    match: blockRegex(/^ *(`{3,}|~{3,}) *(?:(\S+) *)?\n([\s\S]+?)\n?\1 *(?:\n *)+\n/),
+    parse: function (_parse4) {
+      function parse(_x10, _x11, _x12) {
+        return _parse4.apply(this, arguments);
+      }
+
+      parse.toString = function () {
+        return _parse4.toString();
+      };
+
+      return parse;
+    }(function (capture, parse, state) {
+      return {
+        type: "codeBlock",
+        lang: capture[2] || undefined,
+        content: capture[3]
+      };
+    }),
+    react: null,
+    html: null
+  },
+  blockQuote: {
+    order: currOrder++,
+    match: blockRegex(/^( *>[^\n]+(\n[^\n]+)*\n*)+\n{2,}/),
+    parse: function (_parse5) {
+      function parse(_x13, _x14, _x15) {
+        return _parse5.apply(this, arguments);
+      }
+
+      parse.toString = function () {
+        return _parse5.toString();
+      };
+
+      return parse;
+    }(function (capture, parse, state) {
+      var content = capture[0].replace(/^ *> ?/gm, "");
+      return {
+        content: parse(content, state)
+      };
+    }),
+    react: function react(node, output, state) {
+      return reactElement("blockquote", state.key, {
+        children: output(node.content, state)
+      });
+    },
+    html: function html(node, output, state) {
+      return htmlTag("blockquote", output(node.content, state));
+    }
+  },
+  list: {
+    order: currOrder++,
+    // $FlowFixMe
+    match: function match(source, state) {
+      // We only want to break into a list if we are at the start of a
+      // line. This is to avoid parsing "hi * there" with "* there"
+      // becoming a part of a list.
+      // You might wonder, "but that's inline, so of course it wouldn't
+      // start a list?". You would be correct! Except that some of our
+      // lists can be inline, because they might be inside another list,
+      // in which case we can parse with inline scope, but need to allow
+      // nested lists inside this inline scope.
+      var prevCaptureStr = state.prevCapture == null ? "" : state.prevCapture[0];
+      var isStartOfLineCapture = LIST_LOOKBEHIND_R.exec(prevCaptureStr);
+      var isListBlock = state._list || !state.inline;
+
+      if (isStartOfLineCapture && isListBlock) {
+        source = isStartOfLineCapture[1] + source;
+        return LIST_R.exec(source);
+      } else {
+        return null;
+      }
+    },
+    parse: function (_parse6) {
+      function parse(_x16, _x17, _x18) {
+        return _parse6.apply(this, arguments);
+      }
+
+      parse.toString = function () {
+        return _parse6.toString();
+      };
+
+      return parse;
+    }(function (capture, parse, state) {
+      var bullet = capture[2];
+      var ordered = bullet.length > 1;
+      var start = ordered ? +bullet : undefined;
+      var items = capture[0].replace(LIST_BLOCK_END_R, "\n").match(LIST_ITEM_R); // We know this will match here, because of how the regexes are
+      // defined
+
+      var lastItemWasAParagraph = false;
+      var itemContent = items.map(function (item, i) {
+        // We need to see how far indented this item is:
+        var prefixCapture = LIST_ITEM_PREFIX_R.exec(item);
+        var space = prefixCapture ? prefixCapture[0].length : 0; // And then we construct a regex to "unindent" the subsequent
+        // lines of the items by that amount:
+
+        var spaceRegex = new RegExp("^ {1," + space + "}", "gm"); // Before processing the item, we need a couple things
+
+        var content = item // remove indents on trailing lines:
+        .replace(spaceRegex, "") // remove the bullet:
+        .replace(LIST_ITEM_PREFIX_R, ""); // I'm not sur4 why this is necessary again?
+        // Handling "loose" lists, like:
+        //
+        //  * this is wrapped in a paragraph
+        //
+        //  * as is this
+        //
+        //  * as is this
+
+        var isLastItem = i === items.length - 1;
+        var containsBlocks = content.indexOf("\n\n") !== -1; // Any element in a list is a block if it contains multiple
+        // newlines. The last element in the list can also be a block
+        // if the previous item in the list was a block (this is
+        // because non-last items in the list can end with \n\n, but
+        // the last item can't, so we just "inherit" this property
+        // from our previous element).
+
+        var thisItemIsAParagraph = containsBlocks || isLastItem && lastItemWasAParagraph;
+        lastItemWasAParagraph = thisItemIsAParagraph; // backup our state for restoration afterwards. We're going to
+        // want to set state._list to true, and state.inline depending
+        // on our list's looseness.
+
+        var oldStateInline = state.inline;
+        var oldStateList = state._list;
+        state._list = true; // Parse inline if we're in a tight list, or block if we're in
+        // a loose list.
+
+        var adjustedContent;
+
+        if (thisItemIsAParagraph) {
+          state.inline = false;
+          adjustedContent = content.replace(LIST_ITEM_END_R, "\n\n");
+        } else {
+          state.inline = true;
+          adjustedContent = content.replace(LIST_ITEM_END_R, "");
+        }
+
+        var result = parse(adjustedContent, state); // Restore our state before returning
+
+        state.inline = oldStateInline;
+        state._list = oldStateList;
+        return result;
+      });
+      return {
+        ordered: ordered,
+        start: start,
+        items: itemContent
+      };
+    }),
+    react: function react(node, output, state) {
+      var ListWrapper = node.ordered ? "ol" : "ul";
+      return reactElement(ListWrapper, state.key, {
+        start: node.start,
+        children: node.items.map(function (item, i) {
+          return reactElement("li", "" + i, {
+            children: output(item, state)
+          });
+        })
+      });
+    },
+    html: function html(node, output, state) {
+      var listItems = node.items.map(function (item) {
+        return htmlTag("li", output(item, state));
+      }).join("");
+      var listTag = node.ordered ? "ol" : "ul";
+      var attributes = {
+        start: node.start
+      };
+      return htmlTag(listTag, listItems, attributes);
+    }
+  },
+  def: {
+    order: currOrder++,
+    // TODO(aria): This will match without a blank line before the next
+    // block element, which is inconsistent with most of the rest of
+    // simple-markdown.
+    match: blockRegex(/^ *\[([^\]]+)\]: *<?([^\s>]*)>?(?: +["(]([^\n]+)[")])? *\n(?: *\n)*/),
+    parse: function (_parse7) {
+      function parse(_x19, _x20, _x21) {
+        return _parse7.apply(this, arguments);
+      }
+
+      parse.toString = function () {
+        return _parse7.toString();
+      };
+
+      return parse;
+    }(function (capture, parse, state) {
+      var def = capture[1].replace(/\s+/g, " ").toLowerCase();
+      var target = capture[2];
+      var title = capture[3]; // Look for previous links/images using this def
+      // If any links/images using this def have already been declared,
+      // they will have added themselves to the state._refs[def] list
+      // (_ to deconflict with client-defined state). We look through
+      // that list of reflinks for this def, and modify those AST nodes
+      // with our newly found information now.
+      // Sorry :(.
+
+      if (state._refs && state._refs[def]) {
+        // `refNode` can be a link or an image
+        state._refs[def].forEach(function (refNode) {
+          refNode.target = target;
+          refNode.title = title;
+        });
+      } // Add this def to our map of defs for any future links/images
+      // In case we haven't found any or all of the refs referring to
+      // this def yet, we add our def to the table of known defs, so
+      // that future reflinks can modify themselves appropriately with
+      // this information.
+
+
+      state._defs = state._defs || {};
+      state._defs[def] = {
+        target: target,
+        title: title
+      }; // return the relevant parsed information
+      // for debugging only.
+
+      return {
+        def: def,
+        target: target,
+        title: title
+      };
+    }),
+    react: function react() {
+      return null;
+    },
+    html: function html() {
+      return "";
+    }
+  },
+  table: {
+    order: currOrder++,
+    match: blockRegex(TABLES.TABLE_REGEX),
+    parse: TABLES.parseTable,
+    react: function react(node, output, state) {
+      var getStyle = function getStyle(colIndex) {
+        return node.align[colIndex] == null ? {} : {
+          textAlign: node.align[colIndex]
+        };
+      };
+
+      var headers = node.header.map(function (content, i) {
+        return reactElement("th", "" + i, {
+          style: getStyle(i),
+          scope: "col",
+          children: output(content, state)
+        });
+      });
+      var rows = node.cells.map(function (row, r) {
+        return reactElement("tr", "" + r, {
+          children: row.map(function (content, c) {
+            return reactElement("td", "" + c, {
+              style: getStyle(c),
+              children: output(content, state)
+            });
+          })
+        });
+      });
+      return reactElement("table", state.key, {
+        children: [reactElement("thead", "thead", {
+          children: reactElement("tr", null, {
+            children: headers
+          })
+        }), reactElement("tbody", "tbody", {
+          children: rows
+        })]
+      });
+    },
+    html: function html(node, output, state) {
+      var getStyle = function getStyle(colIndex) {
+        return node.align[colIndex] == null ? "" : "text-align:" + node.align[colIndex] + ";";
+      };
+
+      var headers = node.header.map(function (content, i) {
+        return htmlTag("th", output(content, state), {
+          style: getStyle(i),
+          scope: "col"
+        });
+      }).join("");
+      var rows = node.cells.map(function (row) {
+        var cols = row.map(function (content, c) {
+          return htmlTag("td", output(content, state), {
+            style: getStyle(c)
+          });
+        }).join("");
+        return htmlTag("tr", cols);
+      }).join("");
+      var thead = htmlTag("thead", htmlTag("tr", headers));
+      var tbody = htmlTag("tbody", rows);
+      return htmlTag("table", thead + tbody);
+    }
+  },
+  newline: {
+    order: currOrder++,
+    match: blockRegex(/^(?:\n *)*\n/),
+    parse: ignoreCapture,
+    react: function react(node, output, state) {
+      return "\n";
+    },
+    html: function html(node, output, state) {
+      return "\n";
+    }
+  },
+  paragraph: {
+    order: currOrder++,
+    match: blockRegex(/^((?:[^\n]|\n(?! *\n))+)(?:\n *)+\n/),
+    parse: parseCaptureInline,
+    react: function react(node, output, state) {
+      return reactElement("div", state.key, {
+        className: "paragraph",
+        children: output(node.content, state)
+      });
+    },
+    html: function html(node, output, state) {
+      var attributes = {
+        class: "paragraph"
+      };
+      return htmlTag("div", output(node.content, state), attributes);
+    }
+  },
+  escape: {
+    order: currOrder++,
+    // We don't allow escaping numbers, letters, or spaces here so that
+    // backslashes used in plain text still get rendered. But allowing
+    // escaping anything else provides a very flexible escape mechanism,
+    // regardless of how this grammar is extended.
+    match: inlineRegex(/^\\([^0-9A-Za-z\s])/),
+    parse: function (_parse8) {
+      function parse(_x22, _x23, _x24) {
+        return _parse8.apply(this, arguments);
+      }
+
+      parse.toString = function () {
+        return _parse8.toString();
+      };
+
+      return parse;
+    }(function (capture, parse, state) {
+      return {
+        type: "text",
+        content: capture[1]
+      };
+    }),
+    react: null,
+    html: null
+  },
+  tableSeparator: {
+    order: currOrder++,
+    // $FlowFixMe
+    match: function match(source, state) {
+      if (!state.inTable) {
+        return null;
+      }
+
+      return /^ *\| */.exec(source);
+    },
+    parse: function parse() {
+      return {
+        type: "tableSeparator"
+      };
+    },
+    // These shouldn't be reached, but in case they are, be reasonable:
+    react: function react() {
+      return " | ";
+    },
+    html: function html() {
+      return " &vert; ";
+    }
+  },
+  autolink: {
+    order: currOrder++,
+    match: inlineRegex(/^<([^: >]+:\/[^ >]+)>/),
+    parse: function (_parse9) {
+      function parse(_x25, _x26, _x27) {
+        return _parse9.apply(this, arguments);
+      }
+
+      parse.toString = function () {
+        return _parse9.toString();
+      };
+
+      return parse;
+    }(function (capture, parse, state) {
+      return {
+        type: "link",
+        content: [{
+          type: "text",
+          content: capture[1]
+        }],
+        target: capture[1]
+      };
+    }),
+    react: null,
+    html: null
+  },
+  mailto: {
+    order: currOrder++,
+    match: inlineRegex(/^<([^ >]+@[^ >]+)>/),
+    parse: function (_parse10) {
+      function parse(_x28, _x29, _x30) {
+        return _parse10.apply(this, arguments);
+      }
+
+      parse.toString = function () {
+        return _parse10.toString();
+      };
+
+      return parse;
+    }(function (capture, parse, state) {
+      var address = capture[1];
+      var target = capture[1]; // Check for a `mailto:` already existing in the link:
+
+      if (!AUTOLINK_MAILTO_CHECK_R.test(target)) {
+        target = "mailto:" + target;
+      }
+
+      return {
+        type: "link",
+        content: [{
+          type: "text",
+          content: address
+        }],
+        target: target
+      };
+    }),
+    react: null,
+    html: null
+  },
+  url: {
+    order: currOrder++,
+    match: inlineRegex(/^(https?:\/\/[^\s<]+[^<.,:;"')\]\s])/),
+    parse: function (_parse11) {
+      function parse(_x31, _x32, _x33) {
+        return _parse11.apply(this, arguments);
+      }
+
+      parse.toString = function () {
+        return _parse11.toString();
+      };
+
+      return parse;
+    }(function (capture, parse, state) {
+      return {
+        type: "link",
+        content: [{
+          type: "text",
+          content: capture[1]
+        }],
+        target: capture[1],
+        title: undefined
+      };
+    }),
+    react: null,
+    html: null
+  },
+  link: {
+    order: currOrder++,
+    match: inlineRegex(new RegExp("^\\[(" + LINK_INSIDE + ")\\]\\(" + LINK_HREF_AND_TITLE + "\\)")),
+    parse: function (_parse12) {
+      function parse(_x34, _x35, _x36) {
+        return _parse12.apply(this, arguments);
+      }
+
+      parse.toString = function () {
+        return _parse12.toString();
+      };
+
+      return parse;
+    }(function (capture, parse, state) {
+      var link = {
+        content: parse(capture[1], state),
+        target: unescapeUrl(capture[2]),
+        title: capture[3]
+      };
+      return link;
+    }),
+    react: function react(node, output, state) {
+      return reactElement("a", state.key, {
+        href: sanitizeUrl(node.target),
+        title: node.title,
+        children: output(node.content, state)
+      });
+    },
+    html: function html(node, output, state) {
+      var attributes = {
+        href: sanitizeUrl(node.target),
+        title: node.title
+      };
+      return htmlTag("a", output(node.content, state), attributes);
+    }
+  },
+  image: {
+    order: currOrder++,
+    match: inlineRegex(new RegExp("^!\\[(" + LINK_INSIDE + ")\\]\\(" + LINK_HREF_AND_TITLE + "\\)")),
+    parse: function (_parse13) {
+      function parse(_x37, _x38, _x39) {
+        return _parse13.apply(this, arguments);
+      }
+
+      parse.toString = function () {
+        return _parse13.toString();
+      };
+
+      return parse;
+    }(function (capture, parse, state) {
+      var image = {
+        alt: capture[1],
+        target: unescapeUrl(capture[2]),
+        title: capture[3]
+      };
+      return image;
+    }),
+    react: function react(node, output, state) {
+      return reactElement("img", state.key, {
+        src: sanitizeUrl(node.target),
+        alt: node.alt,
+        title: node.title
+      });
+    },
+    html: function html(node, output, state) {
+      var attributes = {
+        src: sanitizeUrl(node.target),
+        alt: node.alt,
+        title: node.title
+      };
+      return htmlTag("img", "", attributes, false);
+    }
+  },
+  reflink: {
+    order: currOrder++,
+    match: inlineRegex(new RegExp( // The first [part] of the link
+    "^\\[(" + LINK_INSIDE + ")\\]" + // The [ref] target of the link
+    "\\s*\\[([^\\]]*)\\]")),
+    parse: function (_parse14) {
+      function parse(_x40, _x41, _x42) {
+        return _parse14.apply(this, arguments);
+      }
+
+      parse.toString = function () {
+        return _parse14.toString();
+      };
+
+      return parse;
+    }(function (capture, parse, state) {
+      return parseRef(capture, state, {
+        type: "link",
+        content: parse(capture[1], state)
+      });
+    }),
+    react: null,
+    html: null
+  },
+  refimage: {
+    order: currOrder++,
+    match: inlineRegex(new RegExp( // The first [part] of the link
+    "^!\\[(" + LINK_INSIDE + ")\\]" + // The [ref] target of the link
+    "\\s*\\[([^\\]]*)\\]")),
+    parse: function (_parse15) {
+      function parse(_x43, _x44, _x45) {
+        return _parse15.apply(this, arguments);
+      }
+
+      parse.toString = function () {
+        return _parse15.toString();
+      };
+
+      return parse;
+    }(function (capture, parse, state) {
+      return parseRef(capture, state, {
+        type: "image",
+        alt: capture[1]
+      });
+    }),
+    react: null,
+    html: null
+  },
+  em: {
+    order: currOrder
+    /* same as strong/u */
+    ,
+    match: inlineRegex(new RegExp( // only match _s surrounding words.
+    "^\\b_" + "((?:__|\\\\[\\s\\S]|[^\\\\_])+?)_" + "\\b" + // Or match *s:
+    "|" + // Only match *s that are followed by a non-space:
+    "^\\*(?=\\S)(" + // Match at least one of:
+    "(?:" + //  - `**`: so that bolds inside italics don't close the
+    //          italics
+    "\\*\\*|" + //  - escape sequence: so escaped *s don't close us
+    "\\\\[\\s\\S]|" + //  - whitespace: followed by a non-* (we don't
+    //          want ' *' to close an italics--it might
+    //          start a list)
+    "\\s+(?:\\\\[\\s\\S]|[^\\s\\*\\\\]|\\*\\*)|" + //  - non-whitespace, non-*, non-backslash characters
+    "[^\\s\\*\\\\]" + ")+?" + // followed by a non-space, non-* then *
+    ")\\*(?!\\*)")),
+    quality: function quality(capture) {
+      // precedence by length, `em` wins ties:
+      return capture[0].length + 0.2;
+    },
+    parse: function (_parse16) {
+      function parse(_x46, _x47, _x48) {
+        return _parse16.apply(this, arguments);
+      }
+
+      parse.toString = function () {
+        return _parse16.toString();
+      };
+
+      return parse;
+    }(function (capture, parse, state) {
+      return {
+        content: parse(capture[2] || capture[1], state)
+      };
+    }),
+    react: function react(node, output, state) {
+      return reactElement("em", state.key, {
+        children: output(node.content, state)
+      });
+    },
+    html: function html(node, output, state) {
+      return htmlTag("em", output(node.content, state));
+    }
+  },
+  strong: {
+    order: currOrder
+    /* same as em */
+    ,
+    match: inlineRegex(/^\*\*((?:\\[\s\S]|[^\\])+?)\*\*(?!\*)/),
+    quality: function quality(capture) {
+      // precedence by length, wins ties vs `u`:
+      return capture[0].length + 0.1;
+    },
+    parse: parseCaptureInline,
+    react: function react(node, output, state) {
+      return reactElement("strong", state.key, {
+        children: output(node.content, state)
+      });
+    },
+    html: function html(node, output, state) {
+      return htmlTag("strong", output(node.content, state));
+    }
+  },
+  u: {
+    order: currOrder++
+    /* same as em&strong; increment for next rule */
+    ,
+    match: inlineRegex(/^__((?:\\[\s\S]|[^\\])+?)__(?!_)/),
+    quality: function quality(capture) {
+      // precedence by length, loses all ties
+      return capture[0].length;
+    },
+    parse: parseCaptureInline,
+    react: function react(node, output, state) {
+      return reactElement("u", state.key, {
+        children: output(node.content, state)
+      });
+    },
+    html: function html(node, output, state) {
+      return htmlTag("u", output(node.content, state));
+    }
+  },
+  del: {
+    order: currOrder++,
+    match: inlineRegex(/^~~(?=\S)((?:\\[\s\S]|~(?!~)|[^\s~\\]|\s(?!~~))+?)~~/),
+    parse: parseCaptureInline,
+    react: function react(node, output, state) {
+      return reactElement("del", state.key, {
+        children: output(node.content, state)
+      });
+    },
+    html: function html(node, output, state) {
+      return htmlTag("del", output(node.content, state));
+    }
+  },
+  inlineCode: {
+    order: currOrder++,
+    match: inlineRegex(/^(`+)([\s\S]*?[^`])\1(?!`)/),
+    parse: function (_parse17) {
+      function parse(_x49, _x50, _x51) {
+        return _parse17.apply(this, arguments);
+      }
+
+      parse.toString = function () {
+        return _parse17.toString();
+      };
+
+      return parse;
+    }(function (capture, parse, state) {
+      return {
+        content: capture[2].replace(INLINE_CODE_ESCAPE_BACKTICKS_R, "$1")
+      };
+    }),
+    react: function react(node, output, state) {
+      return reactElement("code", state.key, {
+        children: node.content
+      });
+    },
+    html: function html(node, output, state) {
+      return htmlTag("code", sanitizeText(node.content));
+    }
+  },
+  br: {
+    order: currOrder++,
+    match: anyScopeRegex(/^ {2,}\n/),
+    parse: ignoreCapture,
+    react: function react(node, output, state) {
+      return reactElement("br", state.key, EMPTY_PROPS);
+    },
+    html: function html(node, output, state) {
+      return "<br>";
+    }
+  },
+  text: {
+    order: currOrder++,
+    // Here we look for anything followed by non-symbols,
+    // double newlines, or double-space-newlines
+    // We break on any symbol characters so that this grammar
+    // is easy to extend without needing to modify this regex
+    match: anyScopeRegex(/^[\s\S]+?(?=[^0-9A-Za-z\s\u00c0-\uffff]|\n\n| {2,}\n|\w+:\S|$)/),
+    parse: function (_parse18) {
+      function parse(_x52, _x53, _x54) {
+        return _parse18.apply(this, arguments);
+      }
+
+      parse.toString = function () {
+        return _parse18.toString();
+      };
+
+      return parse;
+    }(function (capture, parse, state) {
+      return {
+        content: capture[0]
+      };
+    }),
+    react: function react(node, output, state) {
+      return node.content;
+    },
+    html: function html(node, output, state) {
+      return sanitizeText(node.content);
+    }
+  }
+};
+/** (deprecated) */
+
+var ruleOutput = function ruleOutput( // $FlowFixMe
+rules, property) {
+  if (!property && typeof console !== "undefined") {
+    console.warn("simple-markdown ruleOutput should take 'react' or " + "'html' as the second argument.");
+  }
+
+  var nestedRuleOutput = function nestedRuleOutput(ast, outputFunc, state) {
+    return rules[ast.type][property](ast, outputFunc, state);
+  };
+
+  return nestedRuleOutput;
+};
+/** (deprecated)
+ */
+
+
+var reactFor = function reactFor(outputFunc) {
+  var nestedOutput = function nestedOutput(ast, state) {
+    state = state || {};
+
+    if (Array.isArray(ast)) {
+      var oldKey = state.key;
+      var result = []; // map nestedOutput over the ast, except group any text
+      // nodes together into a single string output.
+
+      var lastResult = null;
+
+      for (var i = 0; i < ast.length; i++) {
+        state.key = "" + i;
+        var nodeOut = nestedOutput(ast[i], state);
+
+        if (typeof nodeOut === "string" && typeof lastResult === "string") {
+          lastResult = lastResult + nodeOut;
+          result[result.length - 1] = lastResult;
+        } else {
+          result.push(nodeOut);
+          lastResult = nodeOut;
+        }
+      }
+
+      state.key = oldKey;
+      return result;
+    } else {
+      return outputFunc(ast, nestedOutput, state);
+    }
+  };
+
+  return nestedOutput;
+};
+/** (deprecated)
+ */
+
+
+var htmlFor = function htmlFor(outputFunc) {
+  var nestedOutput = function nestedOutput(ast, state) {
+    state = state || {};
+
+    if (Array.isArray(ast)) {
+      return ast.map(function (node) {
+        return nestedOutput(node, state);
+      }).join("");
+    } else {
+      return outputFunc(ast, nestedOutput, state);
+    }
+  };
+
+  return nestedOutput;
+};
+
+var outputFor = function outputFor(rules, property) {
+  var defaultState = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+  if (!property) {
+    throw new Error("simple-markdown: outputFor: `property` must be " + "defined. " + "if you just upgraded, you probably need to replace `outputFor` " + "with `reactFor`");
+  }
+
+  var latestState; // $FlowFixMe[incompatible-type]
+
+  var arrayRule = rules.Array || defaultRules.Array; // Tricks to convince tsc that this var is not null:
+
+  var arrayRuleCheck = arrayRule[property];
+
+  if (!arrayRuleCheck) {
+    throw new Error("simple-markdown: outputFor: to join nodes of type `" + property + "` you must provide an `Array:` joiner rule with that type, " + "Please see the docs for details on specifying an Array rule.");
+  }
+
+  var arrayRuleOutput = arrayRuleCheck;
+
+  var nestedOutput = function nestedOutput(ast, state) {
+    state = state || latestState;
+    latestState = state;
+
+    if (Array.isArray(ast)) {
+      return arrayRuleOutput(ast, nestedOutput, state);
+    } else {
+      return rules[ast.type][property](ast, nestedOutput, state);
+    }
+  };
+
+  var outerOutput = function outerOutput(ast, state) {
+    latestState = populateInitialState(state, defaultState);
+    return nestedOutput(ast, latestState);
+  };
+
+  return outerOutput;
+}; // $FlowFixMe[incompatible-call]
+
+
+var defaultRawParse = parserFor(defaultRules);
+
+var defaultBlockParse = function defaultBlockParse(source, state) {
+  state = state || {};
+  state.inline = false;
+  return defaultRawParse(source, state);
+};
+
+var defaultInlineParse = function defaultInlineParse(source, state) {
+  state = state || {};
+  state.inline = true;
+  return defaultRawParse(source, state);
+};
+
+var defaultImplicitParse = function defaultImplicitParse(source, state) {
+  var isBlock = BLOCK_END_R.test(source);
+  state = state || {};
+  state.inline = !isBlock;
+  return defaultRawParse(source, state);
+}; // $FlowFixMe[incompatible-call]
+
+
+var defaultReactOutput = outputFor(defaultRules, "react"); // $FlowFixMe[incompatible-call]
+
+var defaultHtmlOutput = outputFor(defaultRules, "html");
+
+var markdownToReact = function markdownToReact(source, state) {
+  return defaultReactOutput(defaultBlockParse(source, state), state);
+};
+
+var markdownToHtml = function markdownToHtml(source, state) {
+  return defaultHtmlOutput(defaultBlockParse(source, state), state);
+}; // TODO: This needs definition
+
+
+var ReactMarkdown = function ReactMarkdown(props) {
+  var divProps = {};
+
+  for (var prop in props) {
+    if (prop !== "source" && // $FlowFixMe
+    Object.prototype.hasOwnProperty.call(props, prop)) {
+      divProps[prop] = props[prop];
+    }
+  }
+
+  divProps.children = markdownToReact(props.source);
+  return reactElement("div", null, divProps);
+};
+
+// $FlowFixMe
+var SimpleMarkdown = {
+  defaultRules: defaultRules,
+  parserFor: parserFor,
+  outputFor: outputFor,
+  inlineRegex: inlineRegex,
+  blockRegex: blockRegex,
+  anyScopeRegex: anyScopeRegex,
+  parseInline: parseInline,
+  parseBlock: parseBlock,
+  // default wrappers:
+  markdownToReact: markdownToReact,
+  markdownToHtml: markdownToHtml,
+  ReactMarkdown: ReactMarkdown,
+  defaultBlockParse: defaultBlockParse,
+  defaultInlineParse: defaultInlineParse,
+  defaultImplicitParse: defaultImplicitParse,
+  defaultReactOutput: defaultReactOutput,
+  defaultHtmlOutput: defaultHtmlOutput,
+  preprocess: preprocess,
+  sanitizeText: sanitizeText,
+  sanitizeUrl: sanitizeUrl,
+  unescapeUrl: unescapeUrl,
+  htmlTag: htmlTag,
+  reactElement: reactElement,
+  // deprecated:
+  defaultRawParse: defaultRawParse,
+  ruleOutput: ruleOutput,
+  reactFor: reactFor,
+  htmlFor: htmlFor,
+  defaultParse: function defaultParse() {
+    if (typeof console !== "undefined") {
+      console.warn("defaultParse is deprecated, please use `defaultImplicitParse`");
+    }
+
+    return defaultImplicitParse.apply(null, arguments);
+  },
+  defaultOutput: function defaultOutput() {
+    if (typeof console !== "undefined") {
+      console.warn("defaultOutput is deprecated, please use `defaultReactOutput`");
+    }
+
+    return defaultReactOutput.apply(null, arguments);
+  }
+};
+
+export { SimpleMarkdown as default };
 //# sourceMappingURL=index.js.map