@khanacademy/pure-markdown 2.0.0 → 2.0.2

package/dist/es/index.js

@@ -1,275 +1,9 @@
-import _extends from '@babel/runtime/helpers/extends';
 import { addLibraryVersionToPerseusDebug } from '@khanacademy/perseus-utils';
 import SimpleMarkdown from '@khanacademy/simple-markdown';
 
-// This file is processed by a Rollup plugin (replace) to inject the production
-// version number during the release build.
-// In dev, you'll never see the version number.
+const libName="@khanacademy/pure-markdown";const libVersion="2.0.2";addLibraryVersionToPerseusDebug(libName,libVersion);
 
-const libName = "@khanacademy/pure-markdown";
-const libVersion = "2.0.0";
-addLibraryVersionToPerseusDebug(libName, libVersion);
-
-const rWidgetRule = /^\[\[\u2603 (([a-z-]+) ([0-9]+))\]\]/;
-
-/**
- * This match function matches math in `$`s, such as:
- *
- * $y = x + 1$
- *
- * It functions roughly like the following regex:
- * /\$([^\$]*)\$/
- *
- * Unfortunately, math may have other `$`s inside it, as
- * long as they are inside `{` braces `}`, mostly for
- * `\text{ $math$ }`.
- *
- * To parse this, we can't use a regex, since we
- * should support arbitrary nesting (even though
- * MathJax actually only supports two levels of nesting
- * here, which we *could* parse with a regex).
- *
- * Non-regex matchers like this are now a first-class
- * concept in simple-markdown. Yay!
- *
- * This can also match block-math, which is math alone in a paragraph.
- */
-const mathMatcher = (source, state, isBlock) => {
-  const length = source.length;
-  let index = 0;
-
-  // When looking for blocks, skip over leading spaces
-  if (isBlock) {
-    if (state.inline) {
-      return null;
-    }
-    while (index < length && source[index] === " ") {
-      index++;
-    }
-  }
-
-  // Our source must start with a "$"
-  if (!(index < length && source[index] === "$")) {
-    return null;
-  }
-  index++;
-  const startIndex = index;
-  let braceLevel = 0;
-
-  // Loop through the source, looking for a closing '$'
-  // closing '$'s only count if they are not escaped with
-  // a `\`, and we are not in nested `{}` braces.
-  while (index < length) {
-    const character = source[index];
-    if (character === "\\") {
-      // Consume both the `\` and the escaped char as a single
-      // token.
-      // This is so that the second `$` in `$\\$` closes
-      // the math expression, since the first `\` is escaping
-      // the second `\`, but the second `\` is not escaping
-      // the second `$`.
-      // This also handles the case of escaping `$`s or
-      // braces `\{`
-      index++;
-    } else if (braceLevel <= 0 && character === "$") {
-      let endIndex = index + 1;
-      if (isBlock) {
-        // Look for two trailing newlines after the closing `$`
-        const match = /^(?: *\n){2,}/.exec(source.slice(endIndex));
-        // @ts-expect-error - TS2322 - Type 'number | null' is not assignable to type 'number'.
-        endIndex = match ? endIndex + match[0].length : null;
-      }
-
-      // Return an array that looks like the results of a
-      // regex's .exec function:
-      // capture[0] is the whole string
-      // capture[1] is the first "paren" match, which is the
-      //   content of the math here, as if we wrote the regex
-      //   /\$([^\$]*)\$/
-      // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-      if (endIndex) {
-        return [source.substring(0, endIndex), source.substring(startIndex, index)];
-      }
-      return null;
-    } else if (character === "{") {
-      braceLevel++;
-    } else if (character === "}") {
-      braceLevel--;
-    } else if (character === "\n" && source[index - 1] === "\n") {
-      // This is a weird case we supported in the old
-      // math implementation--double newlines break
-      // math. I'm preserving it for now because content
-      // creators might have questions with single '$'s
-      // in paragraphs...
-      return null;
-    }
-    index++;
-  }
-
-  // we didn't find a closing `$`
-  return null;
-};
-const mathMatch = (source, state) => mathMatcher(source, state, false);
-const blockMathMatch = (source, state) => mathMatcher(source, state, true);
-const TITLED_TABLE_REGEX = new RegExp("^\\|\\| +(.*) +\\|\\| *\\n" + "(" +
-// The simple-markdown nptable regex, without
-// the leading `^`
-// @ts-expect-error - TS2532 - Object is possibly 'undefined'.
-SimpleMarkdown.defaultRules.nptable.match.regex.source.substring(1) + ")");
-const crowdinJiptMatcher = SimpleMarkdown.blockRegex(/^(crwdns.*)\n\s*\n/);
-const pureMarkdownRules = _extends({}, SimpleMarkdown.defaultRules, {
-  // NOTE: basically ignored by JIPT. wraps everything at the outer layer
-  columns: {
-    order: -2,
-    match: SimpleMarkdown.blockRegex(/^([\s\S]*\n\n)={5,}\n\n([\s\S]*)/),
-    parse: (capture, parse, state) => {
-      return {
-        col1: parse(capture[1], state),
-        col2: parse(capture[2], state)
-      };
-    }
-  },
-  crowdinId: {
-    order: -1,
-    match: (source, state, prevCapture) => {
-      // Only match on the just-in-place translation site
-      if (state.isJipt) {
-        return crowdinJiptMatcher(source, state, prevCapture);
-      }
-      return null;
-    },
-    parse: (capture, parse, state) => ({
-      id: capture[1]
-    })
-  },
-  // This is pretty much horrible, but we have a regex here to capture an
-  // entire table + a title. capture[1] is the title. capture[2] of the
-  // regex is a copy of the simple-markdown nptable regex. Then we turn
-  // our capture[2] into tableCapture[0], and any further captures in
-  // our table regex into tableCapture[1..], and we pass tableCapture to
-  // our nptable regex
-  titledTable: {
-    // process immediately before nptables
-    order: SimpleMarkdown.defaultRules.nptable.order - 0.5,
-    match: SimpleMarkdown.blockRegex(TITLED_TABLE_REGEX),
-    parse: (capture, parse, state) => {
-      const title = SimpleMarkdown.parseInline(parse, capture[1], state);
-
-      // Remove our [0] and [1] captures, and pass the rest to
-      // the nptable parser
-      const tableCapture = capture.slice(2);
-      const table = SimpleMarkdown.defaultRules.nptable.parse(tableCapture, parse, state);
-      return {
-        title: title,
-        table: table
-      };
-    }
-  },
-  widget: {
-    order: SimpleMarkdown.defaultRules.link.order - 0.75,
-    match: SimpleMarkdown.inlineRegex(rWidgetRule),
-    parse: (capture, parse, state) => {
-      return {
-        id: capture[1],
-        widgetType: capture[2]
-      };
-    }
-  },
-  blockMath: {
-    order: SimpleMarkdown.defaultRules.codeBlock.order + 0.5,
-    match: blockMathMatch,
-    parse: (capture, parse, state) => {
-      return {
-        content: capture[1]
-      };
-    }
-  },
-  math: {
-    order: SimpleMarkdown.defaultRules.link.order - 0.25,
-    match: mathMatch,
-    parse: (capture, parse, state) => {
-      return {
-        content: capture[1]
-      };
-    }
-  },
-  unescapedDollar: {
-    order: SimpleMarkdown.defaultRules.link.order - 0.24,
-    match: SimpleMarkdown.inlineRegex(/^(?!\\)\$/),
-    parse: (capture, parse, state) => {
-      return {};
-    }
-  },
-  fence: _extends({}, SimpleMarkdown.defaultRules.fence, {
-    parse: (capture, parse, state) => {
-      const node = SimpleMarkdown.defaultRules.fence.parse(capture, parse, state);
-
-      // support screenreader-only text with ```alt
-      if (node.lang === "alt") {
-        return {
-          type: "codeBlock",
-          lang: "alt",
-          // default codeBlock parsing doesn't parse the contents.
-          // We need to parse the contents for things like table
-          // support :).
-          // The \n\n is because the inside of the codeblock might
-          // not end in double newlines for block rules, because
-          // ordinarily we don't parse this :).
-          content: parse(node.content + "\n\n", state)
-        };
-      }
-      return node;
-    }
-  }),
-  blockQuote: _extends({}, SimpleMarkdown.defaultRules.blockQuote, {
-    // Replace the less restrictive blockquote regex from SimpleMarkdown
-    // with a more restrictive one. The only difference should be that
-    //
-    // > A blockquote
-    //
-    // > Another blockquote
-    //
-    // will now match as two different blockQuotes instead of a single
-    // blockquote with some paragraph breaks in it.
-    //
-    // The main motivation for doing this is to provide better support for
-    // translators translating blockquotes with multiple paragraphs in
-    // them. When translating articles, we split up paragraphs, translate
-    // them separately, and then recombine them. We do this so that
-    // translators don't have to translate an entire article at a time,
-    // they can instead translate paragraph-by-paragraph.That system
-    // doesn't understand blockquotes, so it will split up blockquotes into
-    // more than one paragraph. A way to solve this would be to make that
-    // system understand blockquotes, but then translators would have to
-    // translate an entire, multi-paragraph blockquote at a time. Instead,
-    // we choose to modify our blockquote matching to split up
-    // multi-paragraph blockquotes into multiple blockquotes.
-    //
-    // There is also precedence for doing this splitting up in other
-    // libraries, for instance CommonMark also splits up blockquotes with
-    // empty lines into multiple blockquotes:
-    // https://spec.commonmark.org/0.28/#example-205
-    match: SimpleMarkdown.blockRegex(/^ *>[^\n]+(\n( *>)?[^\n]+)*\n{2,}/)
-  }),
-  // The lint rule never actually matches anything.
-  // We check for lint after parsing, and, if we find any, we
-  // transform the tree to add lint nodes. This rule is here
-  // just for the react() function
-  lint: {
-    order: 1000,
-    match: s => null,
-    parse: (capture, parse, state) => ({})
-  }
-});
-
-// @ts-expect-error - TS2345 - Argument of type '{ readonly columns: { readonly order: -2; readonly match: any; readonly parse: (capture: any, parse: any, state: any) => any; }; readonly crowdinId: { readonly order: -1; readonly match: (source: any, state: any, prevCapture: any) => any; readonly parse: (capture: any, parse: any, state: any) => any; }; ... 34 more ...' is not assignable to parameter of type 'ParserRules'.
-const builtParser = SimpleMarkdown.parserFor(pureMarkdownRules);
-const parse = (source, state) => {
-  const paragraphedSource = source + "\n\n";
-  return builtParser(paragraphedSource, _extends({}, state, {
-    inline: false
-  }));
-};
+const rWidgetRule=/^\[\[\u2603 (([a-z-]+) ([0-9]+))\]\]/;const mathMatcher=(source,state,isBlock)=>{const length=source.length;let index=0;if(isBlock){if(state.inline){return null}while(index<length&&source[index]===" "){index++;}}if(!(index<length&&source[index]==="$")){return null}index++;const startIndex=index;let braceLevel=0;while(index<length){const character=source[index];if(character==="\\"){index++;}else if(braceLevel<=0&&character==="$"){let endIndex=index+1;if(isBlock){const match=/^(?: *\n){2,}/.exec(source.slice(endIndex));endIndex=match?endIndex+match[0].length:null;}if(endIndex){return [source.substring(0,endIndex),source.substring(startIndex,index)]}return null}else if(character==="{"){braceLevel++;}else if(character==="}"){braceLevel--;}else if(character==="\n"&&source[index-1]==="\n"){return null}index++;}return null};const mathMatch=(source,state)=>mathMatcher(source,state,false);const blockMathMatch=(source,state)=>mathMatcher(source,state,true);const TITLED_TABLE_REGEX=new RegExp("^\\|\\| +(.*) +\\|\\| *\\n"+"("+SimpleMarkdown.defaultRules.nptable.match.regex.source.substring(1)+")");const crowdinJiptMatcher=SimpleMarkdown.blockRegex(/^(crwdns.*)\n\s*\n/);const pureMarkdownRules={...SimpleMarkdown.defaultRules,columns:{order:-2,match:SimpleMarkdown.blockRegex(/^([\s\S]*\n\n)={5,}\n\n([\s\S]*)/),parse:(capture,parse,state)=>{return {col1:parse(capture[1],state),col2:parse(capture[2],state)}}},crowdinId:{order:-1,match:(source,state,prevCapture)=>{if(state.isJipt){return crowdinJiptMatcher(source,state,prevCapture)}return null},parse:(capture,parse,state)=>({id:capture[1]})},titledTable:{order:SimpleMarkdown.defaultRules.nptable.order-.5,match:SimpleMarkdown.blockRegex(TITLED_TABLE_REGEX),parse:(capture,parse,state)=>{const title=SimpleMarkdown.parseInline(parse,capture[1],state);const tableCapture=capture.slice(2);const table=SimpleMarkdown.defaultRules.nptable.parse(tableCapture,parse,state);return {title:title,table:table}}},widget:{order:SimpleMarkdown.defaultRules.link.order-.75,match:SimpleMarkdown.inlineRegex(rWidgetRule),parse:(capture,parse,state)=>{return {id:capture[1],widgetType:capture[2]}}},blockMath:{order:SimpleMarkdown.defaultRules.codeBlock.order+.5,match:blockMathMatch,parse:(capture,parse,state)=>{return {content:capture[1]}}},math:{order:SimpleMarkdown.defaultRules.link.order-.25,match:mathMatch,parse:(capture,parse,state)=>{return {content:capture[1]}}},unescapedDollar:{order:SimpleMarkdown.defaultRules.link.order-.24,match:SimpleMarkdown.inlineRegex(/^(?!\\)\$/),parse:(capture,parse,state)=>{return {}}},fence:{...SimpleMarkdown.defaultRules.fence,parse:(capture,parse,state)=>{const node=SimpleMarkdown.defaultRules.fence.parse(capture,parse,state);if(node.lang==="alt"){return {type:"codeBlock",lang:"alt",content:parse(node.content+"\n\n",state)}}return node}},blockQuote:{...SimpleMarkdown.defaultRules.blockQuote,match:SimpleMarkdown.blockRegex(/^ *>[^\n]+(\n( *>)?[^\n]+)*\n{2,}/)},lint:{order:1e3,match:s=>null,parse:(capture,parse,state)=>({})}};const builtParser=SimpleMarkdown.parserFor(pureMarkdownRules);const parse=(source,state)=>{const paragraphedSource=source+"\n\n";return builtParser(paragraphedSource,{...state,inline:false})};
 
 export { libVersion, parse, pureMarkdownRules };
 //# sourceMappingURL=index.js.map

package/dist/es/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../src/version.ts","../../src/index.ts"],"sourcesContent":["// This file is processed by a Rollup plugin (replace) to inject the production\n// version number during the release build.\n// In dev, you'll never see the version number.\n\nimport {addLibraryVersionToPerseusDebug} from \"@khanacademy/perseus-utils\";\n\nconst libName = \"@khanacademy/pure-markdown\";\nexport const libVersion = \"__lib_version__\";\n\naddLibraryVersionToPerseusDebug(libName, libVersion);\n","/**\n * Contains markdown related functions in pure javascript,\n * extracted from perseus-markdown.jsx\n * Note that this file may be used in stand alone nodejs, thus\n * do not import anything from Perseus\n */\nexport {libVersion} from \"./version\";\n\nimport SimpleMarkdown from \"@khanacademy/simple-markdown\";\n\nconst rWidgetRule = /^\\[\\[\\u2603 (([a-z-]+) ([0-9]+))\\]\\]/;\n\n/**\n * This match function matches math in `$`s, such as:\n *\n * $y = x + 1$\n *\n * It functions roughly like the following regex:\n * /\\$([^\\$]*)\\$/\n *\n * Unfortunately, math may have other `$`s inside it, as\n * long as they are inside `{` braces `}`, mostly for\n * `\\text{ $math$ }`.\n *\n * To parse this, we can't use a regex, since we\n * should support arbitrary nesting (even though\n * MathJax actually only supports two levels of nesting\n * here, which we *could* parse with a regex).\n *\n * Non-regex matchers like this are now a first-class\n * concept in simple-markdown. Yay!\n *\n * This can also match block-math, which is math alone in a paragraph.\n */\nconst mathMatcher = (source: any, state: any, isBlock: boolean) => {\n    const length = source.length;\n    let index = 0;\n\n    // When looking for blocks, skip over leading spaces\n    if (isBlock) {\n        if (state.inline) {\n            return null;\n        }\n        while (index < length && source[index] === \" \") {\n            index++;\n        }\n    }\n\n    // Our source must start with a \"$\"\n    if (!(index < length && source[index] === \"$\")) {\n        return null;\n    }\n\n    index++;\n    const startIndex = index;\n    let braceLevel = 0;\n\n    // Loop through the source, looking for a closing '$'\n    // closing '$'s only count if they are not escaped with\n    // a `\\`, and we are not in nested `{}` braces.\n    while (index < length) {\n        const character = source[index];\n\n        if (character === \"\\\\\") {\n            // Consume both the `\\` and the escaped char as a single\n            // token.\n            // This is so that the second `$` in `$\\\\$` closes\n            // the math expression, since the first `\\` is escaping\n            // the second `\\`, but the second `\\` is not escaping\n            // the second `$`.\n            // This also handles the case of escaping `$`s or\n            // braces `\\{`\n            index++;\n        } else if (braceLevel <= 0 && character === \"$\") {\n            let endIndex = index + 1;\n            if (isBlock) {\n                // Look for two trailing newlines after the closing `$`\n                const match = /^(?: *\\n){2,}/.exec(source.slice(endIndex));\n                // @ts-expect-error - TS2322 - Type 'number | null' is not assignable to type 'number'.\n                endIndex = match ? endIndex + match[0].length : null;\n            }\n\n            // Return an array that looks like the results of a\n            // regex's .exec function:\n            // capture[0] is the whole string\n            // capture[1] is the first \"paren\" match, which is the\n            //   content of the math here, as if we wrote the regex\n            //   /\\$([^\\$]*)\\$/\n            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions\n            if (endIndex) {\n                return [\n                    source.substring(0, endIndex),\n                    source.substring(startIndex, index),\n                ];\n            }\n            return null;\n        } else if (character === \"{\") {\n            braceLevel++;\n        } else if (character === \"}\") {\n            braceLevel--;\n        } else if (character === \"\\n\" && source[index - 1] === \"\\n\") {\n            // This is a weird case we supported in the old\n            // math implementation--double newlines break\n            // math. I'm preserving it for now because content\n            // creators might have questions with single '$'s\n            // in paragraphs...\n            return null;\n        }\n\n        index++;\n    }\n\n    // we didn't find a closing `$`\n    return null;\n};\nconst mathMatch = (source: any, state: any): any =>\n    mathMatcher(source, state, false);\nconst blockMathMatch = (source: any, state: any): any =>\n    mathMatcher(source, state, true);\n\nconst TITLED_TABLE_REGEX = new RegExp(\n    \"^\\\\|\\\\| +(.*) +\\\\|\\\\| *\\\\n\" +\n        \"(\" +\n        // The simple-markdown nptable regex, without\n        // the leading `^`\n        // @ts-expect-error - TS2532 - Object is possibly 'undefined'.\n        SimpleMarkdown.defaultRules.nptable.match.regex.source.substring(1) +\n        \")\",\n);\n\nconst crowdinJiptMatcher = SimpleMarkdown.blockRegex(/^(crwdns.*)\\n\\s*\\n/);\n\nexport const pureMarkdownRules = {\n    ...SimpleMarkdown.defaultRules,\n\n    // NOTE: basically ignored by JIPT. wraps everything at the outer layer\n    columns: {\n        order: -2,\n        match: SimpleMarkdown.blockRegex(\n            /^([\\s\\S]*\\n\\n)={5,}\\n\\n([\\s\\S]*)/,\n        ) as any,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {\n                col1: parse(capture[1], state),\n                col2: parse(capture[2], state),\n            };\n        },\n    },\n    crowdinId: {\n        order: -1,\n        match: (source: any, state: any, prevCapture: any): any => {\n            // Only match on the just-in-place translation site\n            if (state.isJipt) {\n                return crowdinJiptMatcher(source, state, prevCapture);\n            }\n            return null;\n        },\n        parse: (capture: any, parse: any, state: any): any => ({\n            id: capture[1],\n        }),\n    },\n    // This is pretty much horrible, but we have a regex here to capture an\n    // entire table + a title. capture[1] is the title. capture[2] of the\n    // regex is a copy of the simple-markdown nptable regex. Then we turn\n    // our capture[2] into tableCapture[0], and any further captures in\n    // our table regex into tableCapture[1..], and we pass tableCapture to\n    // our nptable regex\n    titledTable: {\n        // process immediately before nptables\n        order: SimpleMarkdown.defaultRules.nptable.order - 0.5,\n        match: SimpleMarkdown.blockRegex(TITLED_TABLE_REGEX) as any,\n        parse: (capture: any, parse: any, state: any): any => {\n            const title = SimpleMarkdown.parseInline(parse, capture[1], state);\n\n            // Remove our [0] and [1] captures, and pass the rest to\n            // the nptable parser\n            const tableCapture = capture.slice(2);\n            const table = SimpleMarkdown.defaultRules.nptable.parse(\n                tableCapture,\n                parse,\n                state,\n            );\n            return {\n                title: title,\n                table: table,\n            };\n        },\n    },\n    widget: {\n        order: SimpleMarkdown.defaultRules.link.order - 0.75,\n        match: SimpleMarkdown.inlineRegex(rWidgetRule) as any,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {\n                id: capture[1],\n                widgetType: capture[2],\n            };\n        },\n    },\n    blockMath: {\n        order: (SimpleMarkdown.defaultRules.codeBlock.order + 0.5) as any,\n        match: blockMathMatch,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {\n                content: capture[1],\n            };\n        },\n    },\n    math: {\n        order: SimpleMarkdown.defaultRules.link.order - 0.25,\n        match: mathMatch,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {\n                content: capture[1],\n            };\n        },\n    },\n    unescapedDollar: {\n        order: SimpleMarkdown.defaultRules.link.order - 0.24,\n        match: SimpleMarkdown.inlineRegex(/^(?!\\\\)\\$/) as any,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {};\n        },\n    },\n    fence: {\n        ...SimpleMarkdown.defaultRules.fence,\n        parse: (capture: any, parse: any, state: any): any => {\n            const node = SimpleMarkdown.defaultRules.fence.parse(\n                capture,\n                parse,\n                state,\n            );\n\n            // support screenreader-only text with ```alt\n            if (node.lang === \"alt\") {\n                return {\n                    type: \"codeBlock\",\n                    lang: \"alt\",\n                    // default codeBlock parsing doesn't parse the contents.\n                    // We need to parse the contents for things like table\n                    // support :).\n                    // The \\n\\n is because the inside of the codeblock might\n                    // not end in double newlines for block rules, because\n                    // ordinarily we don't parse this :).\n                    content: parse(node.content + \"\\n\\n\", state),\n                };\n            }\n            return node;\n        },\n    },\n    blockQuote: {\n        ...SimpleMarkdown.defaultRules.blockQuote,\n        // Replace the less restrictive blockquote regex from SimpleMarkdown\n        // with a more restrictive one. The only difference should be that\n        //\n        // > A blockquote\n        //\n        // > Another blockquote\n        //\n        // will now match as two different blockQuotes instead of a single\n        // blockquote with some paragraph breaks in it.\n        //\n        // The main motivation for doing this is to provide better support for\n        // translators translating blockquotes with multiple paragraphs in\n        // them. When translating articles, we split up paragraphs, translate\n        // them separately, and then recombine them. We do this so that\n        // translators don't have to translate an entire article at a time,\n        // they can instead translate paragraph-by-paragraph.That system\n        // doesn't understand blockquotes, so it will split up blockquotes into\n        // more than one paragraph. A way to solve this would be to make that\n        // system understand blockquotes, but then translators would have to\n        // translate an entire, multi-paragraph blockquote at a time. Instead,\n        // we choose to modify our blockquote matching to split up\n        // multi-paragraph blockquotes into multiple blockquotes.\n        //\n        // There is also precedence for doing this splitting up in other\n        // libraries, for instance CommonMark also splits up blockquotes with\n        // empty lines into multiple blockquotes:\n        // https://spec.commonmark.org/0.28/#example-205\n        match: SimpleMarkdown.blockRegex(\n            /^ *>[^\\n]+(\\n( *>)?[^\\n]+)*\\n{2,}/,\n        ) as any,\n    },\n    // The lint rule never actually matches anything.\n    // We check for lint after parsing, and, if we find any, we\n    // transform the tree to add lint nodes. This rule is here\n    // just for the react() function\n    lint: {\n        order: 1000,\n        match: (s: any): any => null,\n        parse: (capture: any, parse: any, state: any): any => ({}),\n    },\n} as const;\n\n// @ts-expect-error - TS2345 - Argument of type '{ readonly columns: { readonly order: -2; readonly match: any; readonly parse: (capture: any, parse: any, state: any) => any; }; readonly crowdinId: { readonly order: -1; readonly match: (source: any, state: any, prevCapture: any) => any; readonly parse: (capture: any, parse: any, state: any) => any; }; ... 34 more ...' is not assignable to parameter of type 'ParserRules'.\nconst builtParser = SimpleMarkdown.parserFor(pureMarkdownRules);\n\nexport const parse = (source: string, state?: any): any => {\n    const paragraphedSource = source + \"\\n\\n\";\n\n    return builtParser(paragraphedSource, {\n        ...state,\n        inline: false,\n    });\n};\n"],"names":["libName","libVersion","addLibraryVersionToPerseusDebug","rWidgetRule","mathMatcher","source","state","isBlock","length","index","inline","startIndex","braceLevel","character","endIndex","match","exec","slice","substring","mathMatch","blockMathMatch","TITLED_TABLE_REGEX","RegExp","SimpleMarkdown","defaultRules","nptable","regex","crowdinJiptMatcher","blockRegex","pureMarkdownRules","_extends","columns","order","parse","capture","col1","col2","crowdinId","prevCapture","isJipt","id","titledTable","title","parseInline","tableCapture","table","widget","link","inlineRegex","widgetType","blockMath","codeBlock","content","math","unescapedDollar","fence","node","lang","type","blockQuote","lint","s","builtParser","parserFor","paragraphedSource"],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../../src/version.ts","../../src/index.ts"],"sourcesContent":["// This file is processed by a Rollup plugin (replace) to inject the production\n// version number during the release build.\n// In dev, you'll never see the version number.\n\nimport {addLibraryVersionToPerseusDebug} from \"@khanacademy/perseus-utils\";\n\nconst libName = \"@khanacademy/pure-markdown\";\nexport const libVersion = \"__lib_version__\";\n\naddLibraryVersionToPerseusDebug(libName, libVersion);\n","/**\n * Contains markdown related functions in pure javascript,\n * extracted from perseus-markdown.jsx\n * Note that this file may be used in stand alone nodejs, thus\n * do not import anything from Perseus\n */\nexport {libVersion} from \"./version\";\n\nimport SimpleMarkdown from \"@khanacademy/simple-markdown\";\n\nconst rWidgetRule = /^\\[\\[\\u2603 (([a-z-]+) ([0-9]+))\\]\\]/;\n\n/**\n * This match function matches math in `$`s, such as:\n *\n * $y = x + 1$\n *\n * It functions roughly like the following regex:\n * /\\$([^\\$]*)\\$/\n *\n * Unfortunately, math may have other `$`s inside it, as\n * long as they are inside `{` braces `}`, mostly for\n * `\\text{ $math$ }`.\n *\n * To parse this, we can't use a regex, since we\n * should support arbitrary nesting (even though\n * MathJax actually only supports two levels of nesting\n * here, which we *could* parse with a regex).\n *\n * Non-regex matchers like this are now a first-class\n * concept in simple-markdown. Yay!\n *\n * This can also match block-math, which is math alone in a paragraph.\n */\nconst mathMatcher = (source: any, state: any, isBlock: boolean) => {\n    const length = source.length;\n    let index = 0;\n\n    // When looking for blocks, skip over leading spaces\n    if (isBlock) {\n        if (state.inline) {\n            return null;\n        }\n        while (index < length && source[index] === \" \") {\n            index++;\n        }\n    }\n\n    // Our source must start with a \"$\"\n    if (!(index < length && source[index] === \"$\")) {\n        return null;\n    }\n\n    index++;\n    const startIndex = index;\n    let braceLevel = 0;\n\n    // Loop through the source, looking for a closing '$'\n    // closing '$'s only count if they are not escaped with\n    // a `\\`, and we are not in nested `{}` braces.\n    while (index < length) {\n        const character = source[index];\n\n        if (character === \"\\\\\") {\n            // Consume both the `\\` and the escaped char as a single\n            // token.\n            // This is so that the second `$` in `$\\\\$` closes\n            // the math expression, since the first `\\` is escaping\n            // the second `\\`, but the second `\\` is not escaping\n            // the second `$`.\n            // This also handles the case of escaping `$`s or\n            // braces `\\{`\n            index++;\n        } else if (braceLevel <= 0 && character === \"$\") {\n            let endIndex = index + 1;\n            if (isBlock) {\n                // Look for two trailing newlines after the closing `$`\n                const match = /^(?: *\\n){2,}/.exec(source.slice(endIndex));\n                // @ts-expect-error - TS2322 - Type 'number | null' is not assignable to type 'number'.\n                endIndex = match ? endIndex + match[0].length : null;\n            }\n\n            // Return an array that looks like the results of a\n            // regex's .exec function:\n            // capture[0] is the whole string\n            // capture[1] is the first \"paren\" match, which is the\n            //   content of the math here, as if we wrote the regex\n            //   /\\$([^\\$]*)\\$/\n            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions\n            if (endIndex) {\n                return [\n                    source.substring(0, endIndex),\n                    source.substring(startIndex, index),\n                ];\n            }\n            return null;\n        } else if (character === \"{\") {\n            braceLevel++;\n        } else if (character === \"}\") {\n            braceLevel--;\n        } else if (character === \"\\n\" && source[index - 1] === \"\\n\") {\n            // This is a weird case we supported in the old\n            // math implementation--double newlines break\n            // math. I'm preserving it for now because content\n            // creators might have questions with single '$'s\n            // in paragraphs...\n            return null;\n        }\n\n        index++;\n    }\n\n    // we didn't find a closing `$`\n    return null;\n};\nconst mathMatch = (source: any, state: any): any =>\n    mathMatcher(source, state, false);\nconst blockMathMatch = (source: any, state: any): any =>\n    mathMatcher(source, state, true);\n\nconst TITLED_TABLE_REGEX = new RegExp(\n    \"^\\\\|\\\\| +(.*) +\\\\|\\\\| *\\\\n\" +\n        \"(\" +\n        // The simple-markdown nptable regex, without\n        // the leading `^`\n        // @ts-expect-error - TS2532 - Object is possibly 'undefined'.\n        SimpleMarkdown.defaultRules.nptable.match.regex.source.substring(1) +\n        \")\",\n);\n\nconst crowdinJiptMatcher = SimpleMarkdown.blockRegex(/^(crwdns.*)\\n\\s*\\n/);\n\nexport const pureMarkdownRules = {\n    ...SimpleMarkdown.defaultRules,\n\n    // NOTE: basically ignored by JIPT. wraps everything at the outer layer\n    columns: {\n        order: -2,\n        match: SimpleMarkdown.blockRegex(\n            /^([\\s\\S]*\\n\\n)={5,}\\n\\n([\\s\\S]*)/,\n        ) as any,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {\n                col1: parse(capture[1], state),\n                col2: parse(capture[2], state),\n            };\n        },\n    },\n    crowdinId: {\n        order: -1,\n        match: (source: any, state: any, prevCapture: any): any => {\n            // Only match on the just-in-place translation site\n            if (state.isJipt) {\n                return crowdinJiptMatcher(source, state, prevCapture);\n            }\n            return null;\n        },\n        parse: (capture: any, parse: any, state: any): any => ({\n            id: capture[1],\n        }),\n    },\n    // This is pretty much horrible, but we have a regex here to capture an\n    // entire table + a title. capture[1] is the title. capture[2] of the\n    // regex is a copy of the simple-markdown nptable regex. Then we turn\n    // our capture[2] into tableCapture[0], and any further captures in\n    // our table regex into tableCapture[1..], and we pass tableCapture to\n    // our nptable regex\n    titledTable: {\n        // process immediately before nptables\n        order: SimpleMarkdown.defaultRules.nptable.order - 0.5,\n        match: SimpleMarkdown.blockRegex(TITLED_TABLE_REGEX) as any,\n        parse: (capture: any, parse: any, state: any): any => {\n            const title = SimpleMarkdown.parseInline(parse, capture[1], state);\n\n            // Remove our [0] and [1] captures, and pass the rest to\n            // the nptable parser\n            const tableCapture = capture.slice(2);\n            const table = SimpleMarkdown.defaultRules.nptable.parse(\n                tableCapture,\n                parse,\n                state,\n            );\n            return {\n                title: title,\n                table: table,\n            };\n        },\n    },\n    widget: {\n        order: SimpleMarkdown.defaultRules.link.order - 0.75,\n        match: SimpleMarkdown.inlineRegex(rWidgetRule) as any,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {\n                id: capture[1],\n                widgetType: capture[2],\n            };\n        },\n    },\n    blockMath: {\n        order: (SimpleMarkdown.defaultRules.codeBlock.order + 0.5) as any,\n        match: blockMathMatch,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {\n                content: capture[1],\n            };\n        },\n    },\n    math: {\n        order: SimpleMarkdown.defaultRules.link.order - 0.25,\n        match: mathMatch,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {\n                content: capture[1],\n            };\n        },\n    },\n    unescapedDollar: {\n        order: SimpleMarkdown.defaultRules.link.order - 0.24,\n        match: SimpleMarkdown.inlineRegex(/^(?!\\\\)\\$/) as any,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {};\n        },\n    },\n    fence: {\n        ...SimpleMarkdown.defaultRules.fence,\n        parse: (capture: any, parse: any, state: any): any => {\n            const node = SimpleMarkdown.defaultRules.fence.parse(\n                capture,\n                parse,\n                state,\n            );\n\n            // support screenreader-only text with ```alt\n            if (node.lang === \"alt\") {\n                return {\n                    type: \"codeBlock\",\n                    lang: \"alt\",\n                    // default codeBlock parsing doesn't parse the contents.\n                    // We need to parse the contents for things like table\n                    // support :).\n                    // The \\n\\n is because the inside of the codeblock might\n                    // not end in double newlines for block rules, because\n                    // ordinarily we don't parse this :).\n                    content: parse(node.content + \"\\n\\n\", state),\n                };\n            }\n            return node;\n        },\n    },\n    blockQuote: {\n        ...SimpleMarkdown.defaultRules.blockQuote,\n        // Replace the less restrictive blockquote regex from SimpleMarkdown\n        // with a more restrictive one. The only difference should be that\n        //\n        // > A blockquote\n        //\n        // > Another blockquote\n        //\n        // will now match as two different blockQuotes instead of a single\n        // blockquote with some paragraph breaks in it.\n        //\n        // The main motivation for doing this is to provide better support for\n        // translators translating blockquotes with multiple paragraphs in\n        // them. When translating articles, we split up paragraphs, translate\n        // them separately, and then recombine them. We do this so that\n        // translators don't have to translate an entire article at a time,\n        // they can instead translate paragraph-by-paragraph.That system\n        // doesn't understand blockquotes, so it will split up blockquotes into\n        // more than one paragraph. A way to solve this would be to make that\n        // system understand blockquotes, but then translators would have to\n        // translate an entire, multi-paragraph blockquote at a time. Instead,\n        // we choose to modify our blockquote matching to split up\n        // multi-paragraph blockquotes into multiple blockquotes.\n        //\n        // There is also precedence for doing this splitting up in other\n        // libraries, for instance CommonMark also splits up blockquotes with\n        // empty lines into multiple blockquotes:\n        // https://spec.commonmark.org/0.28/#example-205\n        match: SimpleMarkdown.blockRegex(\n            /^ *>[^\\n]+(\\n( *>)?[^\\n]+)*\\n{2,}/,\n        ) as any,\n    },\n    // The lint rule never actually matches anything.\n    // We check for lint after parsing, and, if we find any, we\n    // transform the tree to add lint nodes. This rule is here\n    // just for the react() function\n    lint: {\n        order: 1000,\n        match: (s: any): any => null,\n        parse: (capture: any, parse: any, state: any): any => ({}),\n    },\n} as const;\n\n// @ts-expect-error - TS2345 - Argument of type '{ readonly columns: { readonly order: -2; readonly match: any; readonly parse: (capture: any, parse: any, state: any) => any; }; readonly crowdinId: { readonly order: -1; readonly match: (source: any, state: any, prevCapture: any) => any; readonly parse: (capture: any, parse: any, state: any) => any; }; ... 34 more ...' is not assignable to parameter of type 'ParserRules'.\nconst builtParser = SimpleMarkdown.parserFor(pureMarkdownRules);\n\nexport const parse = (source: string, state?: any): any => {\n    const paragraphedSource = source + \"\\n\\n\";\n\n    return builtParser(paragraphedSource, {\n        ...state,\n        inline: false,\n    });\n};\n"],"names":["libName","libVersion","addLibraryVersionToPerseusDebug","rWidgetRule","mathMatcher","source","state","isBlock","length","index","inline","startIndex","braceLevel","character","endIndex","match","exec","slice","substring","mathMatch","blockMathMatch","TITLED_TABLE_REGEX","RegExp","SimpleMarkdown","defaultRules","nptable","regex","crowdinJiptMatcher","blockRegex","pureMarkdownRules","columns","order","parse","capture","col1","col2","crowdinId","prevCapture","isJipt","id","titledTable","title","parseInline","tableCapture","table","widget","link","inlineRegex","widgetType","blockMath","codeBlock","content","math","unescapedDollar","fence","node","lang","type","blockQuote","lint","s","builtParser","parserFor","paragraphedSource"],"mappings":"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"}

package/dist/index.js

@@ -9,284 +9,9 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 
 var SimpleMarkdown__default = /*#__PURE__*/_interopDefaultCompat(SimpleMarkdown);
 
-// This file is processed by a Rollup plugin (replace) to inject the production
-// version number during the release build.
-// In dev, you'll never see the version number.
+const libName="@khanacademy/pure-markdown";const libVersion="2.0.2";perseusUtils.addLibraryVersionToPerseusDebug(libName,libVersion);
 
-const libName = "@khanacademy/pure-markdown";
-const libVersion = "2.0.0";
-perseusUtils.addLibraryVersionToPerseusDebug(libName, libVersion);
-
-/**
- * Contains markdown related functions in pure javascript,
- * extracted from perseus-markdown.jsx
- * Note that this file may be used in stand alone nodejs, thus
- * do not import anything from Perseus
- */
-const rWidgetRule = /^\[\[\u2603 (([a-z-]+) ([0-9]+))\]\]/;
-
-/**
- * This match function matches math in `$`s, such as:
- *
- * $y = x + 1$
- *
- * It functions roughly like the following regex:
- * /\$([^\$]*)\$/
- *
- * Unfortunately, math may have other `$`s inside it, as
- * long as they are inside `{` braces `}`, mostly for
- * `\text{ $math$ }`.
- *
- * To parse this, we can't use a regex, since we
- * should support arbitrary nesting (even though
- * MathJax actually only supports two levels of nesting
- * here, which we *could* parse with a regex).
- *
- * Non-regex matchers like this are now a first-class
- * concept in simple-markdown. Yay!
- *
- * This can also match block-math, which is math alone in a paragraph.
- */
-const mathMatcher = (source, state, isBlock) => {
-  const length = source.length;
-  let index = 0;
-
-  // When looking for blocks, skip over leading spaces
-  if (isBlock) {
-    if (state.inline) {
-      return null;
-    }
-    while (index < length && source[index] === " ") {
-      index++;
-    }
-  }
-
-  // Our source must start with a "$"
-  if (!(index < length && source[index] === "$")) {
-    return null;
-  }
-  index++;
-  const startIndex = index;
-  let braceLevel = 0;
-
-  // Loop through the source, looking for a closing '$'
-  // closing '$'s only count if they are not escaped with
-  // a `\`, and we are not in nested `{}` braces.
-  while (index < length) {
-    const character = source[index];
-    if (character === "\\") {
-      // Consume both the `\` and the escaped char as a single
-      // token.
-      // This is so that the second `$` in `$\\$` closes
-      // the math expression, since the first `\` is escaping
-      // the second `\`, but the second `\` is not escaping
-      // the second `$`.
-      // This also handles the case of escaping `$`s or
-      // braces `\{`
-      index++;
-    } else if (braceLevel <= 0 && character === "$") {
-      let endIndex = index + 1;
-      if (isBlock) {
-        // Look for two trailing newlines after the closing `$`
-        const match = /^(?: *\n){2,}/.exec(source.slice(endIndex));
-        // @ts-expect-error - TS2322 - Type 'number | null' is not assignable to type 'number'.
-        endIndex = match ? endIndex + match[0].length : null;
-      }
-
-      // Return an array that looks like the results of a
-      // regex's .exec function:
-      // capture[0] is the whole string
-      // capture[1] is the first "paren" match, which is the
-      //   content of the math here, as if we wrote the regex
-      //   /\$([^\$]*)\$/
-      // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-      if (endIndex) {
-        return [source.substring(0, endIndex), source.substring(startIndex, index)];
-      }
-      return null;
-    } else if (character === "{") {
-      braceLevel++;
-    } else if (character === "}") {
-      braceLevel--;
-    } else if (character === "\n" && source[index - 1] === "\n") {
-      // This is a weird case we supported in the old
-      // math implementation--double newlines break
-      // math. I'm preserving it for now because content
-      // creators might have questions with single '$'s
-      // in paragraphs...
-      return null;
-    }
-    index++;
-  }
-
-  // we didn't find a closing `$`
-  return null;
-};
-const mathMatch = (source, state) => mathMatcher(source, state, false);
-const blockMathMatch = (source, state) => mathMatcher(source, state, true);
-const TITLED_TABLE_REGEX = new RegExp("^\\|\\| +(.*) +\\|\\| *\\n" + "(" +
-// The simple-markdown nptable regex, without
-// the leading `^`
-// @ts-expect-error - TS2532 - Object is possibly 'undefined'.
-SimpleMarkdown__default.default.defaultRules.nptable.match.regex.source.substring(1) + ")");
-const crowdinJiptMatcher = SimpleMarkdown__default.default.blockRegex(/^(crwdns.*)\n\s*\n/);
-const pureMarkdownRules = {
-  ...SimpleMarkdown__default.default.defaultRules,
-  // NOTE: basically ignored by JIPT. wraps everything at the outer layer
-  columns: {
-    order: -2,
-    match: SimpleMarkdown__default.default.blockRegex(/^([\s\S]*\n\n)={5,}\n\n([\s\S]*)/),
-    parse: (capture, parse, state) => {
-      return {
-        col1: parse(capture[1], state),
-        col2: parse(capture[2], state)
-      };
-    }
-  },
-  crowdinId: {
-    order: -1,
-    match: (source, state, prevCapture) => {
-      // Only match on the just-in-place translation site
-      if (state.isJipt) {
-        return crowdinJiptMatcher(source, state, prevCapture);
-      }
-      return null;
-    },
-    parse: (capture, parse, state) => ({
-      id: capture[1]
-    })
-  },
-  // This is pretty much horrible, but we have a regex here to capture an
-  // entire table + a title. capture[1] is the title. capture[2] of the
-  // regex is a copy of the simple-markdown nptable regex. Then we turn
-  // our capture[2] into tableCapture[0], and any further captures in
-  // our table regex into tableCapture[1..], and we pass tableCapture to
-  // our nptable regex
-  titledTable: {
-    // process immediately before nptables
-    order: SimpleMarkdown__default.default.defaultRules.nptable.order - 0.5,
-    match: SimpleMarkdown__default.default.blockRegex(TITLED_TABLE_REGEX),
-    parse: (capture, parse, state) => {
-      const title = SimpleMarkdown__default.default.parseInline(parse, capture[1], state);
-
-      // Remove our [0] and [1] captures, and pass the rest to
-      // the nptable parser
-      const tableCapture = capture.slice(2);
-      const table = SimpleMarkdown__default.default.defaultRules.nptable.parse(tableCapture, parse, state);
-      return {
-        title: title,
-        table: table
-      };
-    }
-  },
-  widget: {
-    order: SimpleMarkdown__default.default.defaultRules.link.order - 0.75,
-    match: SimpleMarkdown__default.default.inlineRegex(rWidgetRule),
-    parse: (capture, parse, state) => {
-      return {
-        id: capture[1],
-        widgetType: capture[2]
-      };
-    }
-  },
-  blockMath: {
-    order: SimpleMarkdown__default.default.defaultRules.codeBlock.order + 0.5,
-    match: blockMathMatch,
-    parse: (capture, parse, state) => {
-      return {
-        content: capture[1]
-      };
-    }
-  },
-  math: {
-    order: SimpleMarkdown__default.default.defaultRules.link.order - 0.25,
-    match: mathMatch,
-    parse: (capture, parse, state) => {
-      return {
-        content: capture[1]
-      };
-    }
-  },
-  unescapedDollar: {
-    order: SimpleMarkdown__default.default.defaultRules.link.order - 0.24,
-    match: SimpleMarkdown__default.default.inlineRegex(/^(?!\\)\$/),
-    parse: (capture, parse, state) => {
-      return {};
-    }
-  },
-  fence: {
-    ...SimpleMarkdown__default.default.defaultRules.fence,
-    parse: (capture, parse, state) => {
-      const node = SimpleMarkdown__default.default.defaultRules.fence.parse(capture, parse, state);
-
-      // support screenreader-only text with ```alt
-      if (node.lang === "alt") {
-        return {
-          type: "codeBlock",
-          lang: "alt",
-          // default codeBlock parsing doesn't parse the contents.
-          // We need to parse the contents for things like table
-          // support :).
-          // The \n\n is because the inside of the codeblock might
-          // not end in double newlines for block rules, because
-          // ordinarily we don't parse this :).
-          content: parse(node.content + "\n\n", state)
-        };
-      }
-      return node;
-    }
-  },
-  blockQuote: {
-    ...SimpleMarkdown__default.default.defaultRules.blockQuote,
-    // Replace the less restrictive blockquote regex from SimpleMarkdown
-    // with a more restrictive one. The only difference should be that
-    //
-    // > A blockquote
-    //
-    // > Another blockquote
-    //
-    // will now match as two different blockQuotes instead of a single
-    // blockquote with some paragraph breaks in it.
-    //
-    // The main motivation for doing this is to provide better support for
-    // translators translating blockquotes with multiple paragraphs in
-    // them. When translating articles, we split up paragraphs, translate
-    // them separately, and then recombine them. We do this so that
-    // translators don't have to translate an entire article at a time,
-    // they can instead translate paragraph-by-paragraph.That system
-    // doesn't understand blockquotes, so it will split up blockquotes into
-    // more than one paragraph. A way to solve this would be to make that
-    // system understand blockquotes, but then translators would have to
-    // translate an entire, multi-paragraph blockquote at a time. Instead,
-    // we choose to modify our blockquote matching to split up
-    // multi-paragraph blockquotes into multiple blockquotes.
-    //
-    // There is also precedence for doing this splitting up in other
-    // libraries, for instance CommonMark also splits up blockquotes with
-    // empty lines into multiple blockquotes:
-    // https://spec.commonmark.org/0.28/#example-205
-    match: SimpleMarkdown__default.default.blockRegex(/^ *>[^\n]+(\n( *>)?[^\n]+)*\n{2,}/)
-  },
-  // The lint rule never actually matches anything.
-  // We check for lint after parsing, and, if we find any, we
-  // transform the tree to add lint nodes. This rule is here
-  // just for the react() function
-  lint: {
-    order: 1000,
-    match: s => null,
-    parse: (capture, parse, state) => ({})
-  }
-};
-
-// @ts-expect-error - TS2345 - Argument of type '{ readonly columns: { readonly order: -2; readonly match: any; readonly parse: (capture: any, parse: any, state: any) => any; }; readonly crowdinId: { readonly order: -1; readonly match: (source: any, state: any, prevCapture: any) => any; readonly parse: (capture: any, parse: any, state: any) => any; }; ... 34 more ...' is not assignable to parameter of type 'ParserRules'.
-const builtParser = SimpleMarkdown__default.default.parserFor(pureMarkdownRules);
-const parse = (source, state) => {
-  const paragraphedSource = source + "\n\n";
-  return builtParser(paragraphedSource, {
-    ...state,
-    inline: false
-  });
-};
+const rWidgetRule=/^\[\[\u2603 (([a-z-]+) ([0-9]+))\]\]/;const mathMatcher=(source,state,isBlock)=>{const length=source.length;let index=0;if(isBlock){if(state.inline){return null}while(index<length&&source[index]===" "){index++;}}if(!(index<length&&source[index]==="$")){return null}index++;const startIndex=index;let braceLevel=0;while(index<length){const character=source[index];if(character==="\\"){index++;}else if(braceLevel<=0&&character==="$"){let endIndex=index+1;if(isBlock){const match=/^(?: *\n){2,}/.exec(source.slice(endIndex));endIndex=match?endIndex+match[0].length:null;}if(endIndex){return [source.substring(0,endIndex),source.substring(startIndex,index)]}return null}else if(character==="{"){braceLevel++;}else if(character==="}"){braceLevel--;}else if(character==="\n"&&source[index-1]==="\n"){return null}index++;}return null};const mathMatch=(source,state)=>mathMatcher(source,state,false);const blockMathMatch=(source,state)=>mathMatcher(source,state,true);const TITLED_TABLE_REGEX=new RegExp("^\\|\\| +(.*) +\\|\\| *\\n"+"("+SimpleMarkdown__default.default.defaultRules.nptable.match.regex.source.substring(1)+")");const crowdinJiptMatcher=SimpleMarkdown__default.default.blockRegex(/^(crwdns.*)\n\s*\n/);const pureMarkdownRules={...SimpleMarkdown__default.default.defaultRules,columns:{order:-2,match:SimpleMarkdown__default.default.blockRegex(/^([\s\S]*\n\n)={5,}\n\n([\s\S]*)/),parse:(capture,parse,state)=>{return {col1:parse(capture[1],state),col2:parse(capture[2],state)}}},crowdinId:{order:-1,match:(source,state,prevCapture)=>{if(state.isJipt){return crowdinJiptMatcher(source,state,prevCapture)}return null},parse:(capture,parse,state)=>({id:capture[1]})},titledTable:{order:SimpleMarkdown__default.default.defaultRules.nptable.order-.5,match:SimpleMarkdown__default.default.blockRegex(TITLED_TABLE_REGEX),parse:(capture,parse,state)=>{const title=SimpleMarkdown__default.default.parseInline(parse,capture[1],state);const tableCapture=capture.slice(2);const table=SimpleMarkdown__default.default.defaultRules.nptable.parse(tableCapture,parse,state);return {title:title,table:table}}},widget:{order:SimpleMarkdown__default.default.defaultRules.link.order-.75,match:SimpleMarkdown__default.default.inlineRegex(rWidgetRule),parse:(capture,parse,state)=>{return {id:capture[1],widgetType:capture[2]}}},blockMath:{order:SimpleMarkdown__default.default.defaultRules.codeBlock.order+.5,match:blockMathMatch,parse:(capture,parse,state)=>{return {content:capture[1]}}},math:{order:SimpleMarkdown__default.default.defaultRules.link.order-.25,match:mathMatch,parse:(capture,parse,state)=>{return {content:capture[1]}}},unescapedDollar:{order:SimpleMarkdown__default.default.defaultRules.link.order-.24,match:SimpleMarkdown__default.default.inlineRegex(/^(?!\\)\$/),parse:(capture,parse,state)=>{return {}}},fence:{...SimpleMarkdown__default.default.defaultRules.fence,parse:(capture,parse,state)=>{const node=SimpleMarkdown__default.default.defaultRules.fence.parse(capture,parse,state);if(node.lang==="alt"){return {type:"codeBlock",lang:"alt",content:parse(node.content+"\n\n",state)}}return node}},blockQuote:{...SimpleMarkdown__default.default.defaultRules.blockQuote,match:SimpleMarkdown__default.default.blockRegex(/^ *>[^\n]+(\n( *>)?[^\n]+)*\n{2,}/)},lint:{order:1e3,match:s=>null,parse:(capture,parse,state)=>({})}};const builtParser=SimpleMarkdown__default.default.parserFor(pureMarkdownRules);const parse=(source,state)=>{const paragraphedSource=source+"\n\n";return builtParser(paragraphedSource,{...state,inline:false})};
 
 exports.libVersion = libVersion;
 exports.parse = parse;

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/version.ts","../src/index.ts"],"sourcesContent":["// This file is processed by a Rollup plugin (replace) to inject the production\n// version number during the release build.\n// In dev, you'll never see the version number.\n\nimport {addLibraryVersionToPerseusDebug} from \"@khanacademy/perseus-utils\";\n\nconst libName = \"@khanacademy/pure-markdown\";\nexport const libVersion = \"__lib_version__\";\n\naddLibraryVersionToPerseusDebug(libName, libVersion);\n","/**\n * Contains markdown related functions in pure javascript,\n * extracted from perseus-markdown.jsx\n * Note that this file may be used in stand alone nodejs, thus\n * do not import anything from Perseus\n */\nexport {libVersion} from \"./version\";\n\nimport SimpleMarkdown from \"@khanacademy/simple-markdown\";\n\nconst rWidgetRule = /^\\[\\[\\u2603 (([a-z-]+) ([0-9]+))\\]\\]/;\n\n/**\n * This match function matches math in `$`s, such as:\n *\n * $y = x + 1$\n *\n * It functions roughly like the following regex:\n * /\\$([^\\$]*)\\$/\n *\n * Unfortunately, math may have other `$`s inside it, as\n * long as they are inside `{` braces `}`, mostly for\n * `\\text{ $math$ }`.\n *\n * To parse this, we can't use a regex, since we\n * should support arbitrary nesting (even though\n * MathJax actually only supports two levels of nesting\n * here, which we *could* parse with a regex).\n *\n * Non-regex matchers like this are now a first-class\n * concept in simple-markdown. Yay!\n *\n * This can also match block-math, which is math alone in a paragraph.\n */\nconst mathMatcher = (source: any, state: any, isBlock: boolean) => {\n    const length = source.length;\n    let index = 0;\n\n    // When looking for blocks, skip over leading spaces\n    if (isBlock) {\n        if (state.inline) {\n            return null;\n        }\n        while (index < length && source[index] === \" \") {\n            index++;\n        }\n    }\n\n    // Our source must start with a \"$\"\n    if (!(index < length && source[index] === \"$\")) {\n        return null;\n    }\n\n    index++;\n    const startIndex = index;\n    let braceLevel = 0;\n\n    // Loop through the source, looking for a closing '$'\n    // closing '$'s only count if they are not escaped with\n    // a `\\`, and we are not in nested `{}` braces.\n    while (index < length) {\n        const character = source[index];\n\n        if (character === \"\\\\\") {\n            // Consume both the `\\` and the escaped char as a single\n            // token.\n            // This is so that the second `$` in `$\\\\$` closes\n            // the math expression, since the first `\\` is escaping\n            // the second `\\`, but the second `\\` is not escaping\n            // the second `$`.\n            // This also handles the case of escaping `$`s or\n            // braces `\\{`\n            index++;\n        } else if (braceLevel <= 0 && character === \"$\") {\n            let endIndex = index + 1;\n            if (isBlock) {\n                // Look for two trailing newlines after the closing `$`\n                const match = /^(?: *\\n){2,}/.exec(source.slice(endIndex));\n                // @ts-expect-error - TS2322 - Type 'number | null' is not assignable to type 'number'.\n                endIndex = match ? endIndex + match[0].length : null;\n            }\n\n            // Return an array that looks like the results of a\n            // regex's .exec function:\n            // capture[0] is the whole string\n            // capture[1] is the first \"paren\" match, which is the\n            //   content of the math here, as if we wrote the regex\n            //   /\\$([^\\$]*)\\$/\n            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions\n            if (endIndex) {\n                return [\n                    source.substring(0, endIndex),\n                    source.substring(startIndex, index),\n                ];\n            }\n            return null;\n        } else if (character === \"{\") {\n            braceLevel++;\n        } else if (character === \"}\") {\n            braceLevel--;\n        } else if (character === \"\\n\" && source[index - 1] === \"\\n\") {\n            // This is a weird case we supported in the old\n            // math implementation--double newlines break\n            // math. I'm preserving it for now because content\n            // creators might have questions with single '$'s\n            // in paragraphs...\n            return null;\n        }\n\n        index++;\n    }\n\n    // we didn't find a closing `$`\n    return null;\n};\nconst mathMatch = (source: any, state: any): any =>\n    mathMatcher(source, state, false);\nconst blockMathMatch = (source: any, state: any): any =>\n    mathMatcher(source, state, true);\n\nconst TITLED_TABLE_REGEX = new RegExp(\n    \"^\\\\|\\\\| +(.*) +\\\\|\\\\| *\\\\n\" +\n        \"(\" +\n        // The simple-markdown nptable regex, without\n        // the leading `^`\n        // @ts-expect-error - TS2532 - Object is possibly 'undefined'.\n        SimpleMarkdown.defaultRules.nptable.match.regex.source.substring(1) +\n        \")\",\n);\n\nconst crowdinJiptMatcher = SimpleMarkdown.blockRegex(/^(crwdns.*)\\n\\s*\\n/);\n\nexport const pureMarkdownRules = {\n    ...SimpleMarkdown.defaultRules,\n\n    // NOTE: basically ignored by JIPT. wraps everything at the outer layer\n    columns: {\n        order: -2,\n        match: SimpleMarkdown.blockRegex(\n            /^([\\s\\S]*\\n\\n)={5,}\\n\\n([\\s\\S]*)/,\n        ) as any,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {\n                col1: parse(capture[1], state),\n                col2: parse(capture[2], state),\n            };\n        },\n    },\n    crowdinId: {\n        order: -1,\n        match: (source: any, state: any, prevCapture: any): any => {\n            // Only match on the just-in-place translation site\n            if (state.isJipt) {\n                return crowdinJiptMatcher(source, state, prevCapture);\n            }\n            return null;\n        },\n        parse: (capture: any, parse: any, state: any): any => ({\n            id: capture[1],\n        }),\n    },\n    // This is pretty much horrible, but we have a regex here to capture an\n    // entire table + a title. capture[1] is the title. capture[2] of the\n    // regex is a copy of the simple-markdown nptable regex. Then we turn\n    // our capture[2] into tableCapture[0], and any further captures in\n    // our table regex into tableCapture[1..], and we pass tableCapture to\n    // our nptable regex\n    titledTable: {\n        // process immediately before nptables\n        order: SimpleMarkdown.defaultRules.nptable.order - 0.5,\n        match: SimpleMarkdown.blockRegex(TITLED_TABLE_REGEX) as any,\n        parse: (capture: any, parse: any, state: any): any => {\n            const title = SimpleMarkdown.parseInline(parse, capture[1], state);\n\n            // Remove our [0] and [1] captures, and pass the rest to\n            // the nptable parser\n            const tableCapture = capture.slice(2);\n            const table = SimpleMarkdown.defaultRules.nptable.parse(\n                tableCapture,\n                parse,\n                state,\n            );\n            return {\n                title: title,\n                table: table,\n            };\n        },\n    },\n    widget: {\n        order: SimpleMarkdown.defaultRules.link.order - 0.75,\n        match: SimpleMarkdown.inlineRegex(rWidgetRule) as any,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {\n                id: capture[1],\n                widgetType: capture[2],\n            };\n        },\n    },\n    blockMath: {\n        order: (SimpleMarkdown.defaultRules.codeBlock.order + 0.5) as any,\n        match: blockMathMatch,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {\n                content: capture[1],\n            };\n        },\n    },\n    math: {\n        order: SimpleMarkdown.defaultRules.link.order - 0.25,\n        match: mathMatch,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {\n                content: capture[1],\n            };\n        },\n    },\n    unescapedDollar: {\n        order: SimpleMarkdown.defaultRules.link.order - 0.24,\n        match: SimpleMarkdown.inlineRegex(/^(?!\\\\)\\$/) as any,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {};\n        },\n    },\n    fence: {\n        ...SimpleMarkdown.defaultRules.fence,\n        parse: (capture: any, parse: any, state: any): any => {\n            const node = SimpleMarkdown.defaultRules.fence.parse(\n                capture,\n                parse,\n                state,\n            );\n\n            // support screenreader-only text with ```alt\n            if (node.lang === \"alt\") {\n                return {\n                    type: \"codeBlock\",\n                    lang: \"alt\",\n                    // default codeBlock parsing doesn't parse the contents.\n                    // We need to parse the contents for things like table\n                    // support :).\n                    // The \\n\\n is because the inside of the codeblock might\n                    // not end in double newlines for block rules, because\n                    // ordinarily we don't parse this :).\n                    content: parse(node.content + \"\\n\\n\", state),\n                };\n            }\n            return node;\n        },\n    },\n    blockQuote: {\n        ...SimpleMarkdown.defaultRules.blockQuote,\n        // Replace the less restrictive blockquote regex from SimpleMarkdown\n        // with a more restrictive one. The only difference should be that\n        //\n        // > A blockquote\n        //\n        // > Another blockquote\n        //\n        // will now match as two different blockQuotes instead of a single\n        // blockquote with some paragraph breaks in it.\n        //\n        // The main motivation for doing this is to provide better support for\n        // translators translating blockquotes with multiple paragraphs in\n        // them. When translating articles, we split up paragraphs, translate\n        // them separately, and then recombine them. We do this so that\n        // translators don't have to translate an entire article at a time,\n        // they can instead translate paragraph-by-paragraph.That system\n        // doesn't understand blockquotes, so it will split up blockquotes into\n        // more than one paragraph. A way to solve this would be to make that\n        // system understand blockquotes, but then translators would have to\n        // translate an entire, multi-paragraph blockquote at a time. Instead,\n        // we choose to modify our blockquote matching to split up\n        // multi-paragraph blockquotes into multiple blockquotes.\n        //\n        // There is also precedence for doing this splitting up in other\n        // libraries, for instance CommonMark also splits up blockquotes with\n        // empty lines into multiple blockquotes:\n        // https://spec.commonmark.org/0.28/#example-205\n        match: SimpleMarkdown.blockRegex(\n            /^ *>[^\\n]+(\\n( *>)?[^\\n]+)*\\n{2,}/,\n        ) as any,\n    },\n    // The lint rule never actually matches anything.\n    // We check for lint after parsing, and, if we find any, we\n    // transform the tree to add lint nodes. This rule is here\n    // just for the react() function\n    lint: {\n        order: 1000,\n        match: (s: any): any => null,\n        parse: (capture: any, parse: any, state: any): any => ({}),\n    },\n} as const;\n\n// @ts-expect-error - TS2345 - Argument of type '{ readonly columns: { readonly order: -2; readonly match: any; readonly parse: (capture: any, parse: any, state: any) => any; }; readonly crowdinId: { readonly order: -1; readonly match: (source: any, state: any, prevCapture: any) => any; readonly parse: (capture: any, parse: any, state: any) => any; }; ... 34 more ...' is not assignable to parameter of type 'ParserRules'.\nconst builtParser = SimpleMarkdown.parserFor(pureMarkdownRules);\n\nexport const parse = (source: string, state?: any): any => {\n    const paragraphedSource = source + \"\\n\\n\";\n\n    return builtParser(paragraphedSource, {\n        ...state,\n        inline: false,\n    });\n};\n"],"names":["libName","libVersion","addLibraryVersionToPerseusDebug","rWidgetRule","mathMatcher","source","state","isBlock","length","index","inline","startIndex","braceLevel","character","endIndex","match","exec","slice","substring","mathMatch","blockMathMatch","TITLED_TABLE_REGEX","RegExp","SimpleMarkdown","defaultRules","nptable","regex","crowdinJiptMatcher","blockRegex","pureMarkdownRules","columns","order","parse","capture","col1","col2","crowdinId","prevCapture","isJipt","id","titledTable","title","parseInline","tableCapture","table","widget","link","inlineRegex","widgetType","blockMath","codeBlock","content","math","unescapedDollar","fence","node","lang","type","blockQuote","lint","s","builtParser","parserFor","paragraphedSource"],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../src/version.ts","../src/index.ts"],"sourcesContent":["// This file is processed by a Rollup plugin (replace) to inject the production\n// version number during the release build.\n// In dev, you'll never see the version number.\n\nimport {addLibraryVersionToPerseusDebug} from \"@khanacademy/perseus-utils\";\n\nconst libName = \"@khanacademy/pure-markdown\";\nexport const libVersion = \"__lib_version__\";\n\naddLibraryVersionToPerseusDebug(libName, libVersion);\n","/**\n * Contains markdown related functions in pure javascript,\n * extracted from perseus-markdown.jsx\n * Note that this file may be used in stand alone nodejs, thus\n * do not import anything from Perseus\n */\nexport {libVersion} from \"./version\";\n\nimport SimpleMarkdown from \"@khanacademy/simple-markdown\";\n\nconst rWidgetRule = /^\\[\\[\\u2603 (([a-z-]+) ([0-9]+))\\]\\]/;\n\n/**\n * This match function matches math in `$`s, such as:\n *\n * $y = x + 1$\n *\n * It functions roughly like the following regex:\n * /\\$([^\\$]*)\\$/\n *\n * Unfortunately, math may have other `$`s inside it, as\n * long as they are inside `{` braces `}`, mostly for\n * `\\text{ $math$ }`.\n *\n * To parse this, we can't use a regex, since we\n * should support arbitrary nesting (even though\n * MathJax actually only supports two levels of nesting\n * here, which we *could* parse with a regex).\n *\n * Non-regex matchers like this are now a first-class\n * concept in simple-markdown. Yay!\n *\n * This can also match block-math, which is math alone in a paragraph.\n */\nconst mathMatcher = (source: any, state: any, isBlock: boolean) => {\n    const length = source.length;\n    let index = 0;\n\n    // When looking for blocks, skip over leading spaces\n    if (isBlock) {\n        if (state.inline) {\n            return null;\n        }\n        while (index < length && source[index] === \" \") {\n            index++;\n        }\n    }\n\n    // Our source must start with a \"$\"\n    if (!(index < length && source[index] === \"$\")) {\n        return null;\n    }\n\n    index++;\n    const startIndex = index;\n    let braceLevel = 0;\n\n    // Loop through the source, looking for a closing '$'\n    // closing '$'s only count if they are not escaped with\n    // a `\\`, and we are not in nested `{}` braces.\n    while (index < length) {\n        const character = source[index];\n\n        if (character === \"\\\\\") {\n            // Consume both the `\\` and the escaped char as a single\n            // token.\n            // This is so that the second `$` in `$\\\\$` closes\n            // the math expression, since the first `\\` is escaping\n            // the second `\\`, but the second `\\` is not escaping\n            // the second `$`.\n            // This also handles the case of escaping `$`s or\n            // braces `\\{`\n            index++;\n        } else if (braceLevel <= 0 && character === \"$\") {\n            let endIndex = index + 1;\n            if (isBlock) {\n                // Look for two trailing newlines after the closing `$`\n                const match = /^(?: *\\n){2,}/.exec(source.slice(endIndex));\n                // @ts-expect-error - TS2322 - Type 'number | null' is not assignable to type 'number'.\n                endIndex = match ? endIndex + match[0].length : null;\n            }\n\n            // Return an array that looks like the results of a\n            // regex's .exec function:\n            // capture[0] is the whole string\n            // capture[1] is the first \"paren\" match, which is the\n            //   content of the math here, as if we wrote the regex\n            //   /\\$([^\\$]*)\\$/\n            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions\n            if (endIndex) {\n                return [\n                    source.substring(0, endIndex),\n                    source.substring(startIndex, index),\n                ];\n            }\n            return null;\n        } else if (character === \"{\") {\n            braceLevel++;\n        } else if (character === \"}\") {\n            braceLevel--;\n        } else if (character === \"\\n\" && source[index - 1] === \"\\n\") {\n            // This is a weird case we supported in the old\n            // math implementation--double newlines break\n            // math. I'm preserving it for now because content\n            // creators might have questions with single '$'s\n            // in paragraphs...\n            return null;\n        }\n\n        index++;\n    }\n\n    // we didn't find a closing `$`\n    return null;\n};\nconst mathMatch = (source: any, state: any): any =>\n    mathMatcher(source, state, false);\nconst blockMathMatch = (source: any, state: any): any =>\n    mathMatcher(source, state, true);\n\nconst TITLED_TABLE_REGEX = new RegExp(\n    \"^\\\\|\\\\| +(.*) +\\\\|\\\\| *\\\\n\" +\n        \"(\" +\n        // The simple-markdown nptable regex, without\n        // the leading `^`\n        // @ts-expect-error - TS2532 - Object is possibly 'undefined'.\n        SimpleMarkdown.defaultRules.nptable.match.regex.source.substring(1) +\n        \")\",\n);\n\nconst crowdinJiptMatcher = SimpleMarkdown.blockRegex(/^(crwdns.*)\\n\\s*\\n/);\n\nexport const pureMarkdownRules = {\n    ...SimpleMarkdown.defaultRules,\n\n    // NOTE: basically ignored by JIPT. wraps everything at the outer layer\n    columns: {\n        order: -2,\n        match: SimpleMarkdown.blockRegex(\n            /^([\\s\\S]*\\n\\n)={5,}\\n\\n([\\s\\S]*)/,\n        ) as any,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {\n                col1: parse(capture[1], state),\n                col2: parse(capture[2], state),\n            };\n        },\n    },\n    crowdinId: {\n        order: -1,\n        match: (source: any, state: any, prevCapture: any): any => {\n            // Only match on the just-in-place translation site\n            if (state.isJipt) {\n                return crowdinJiptMatcher(source, state, prevCapture);\n            }\n            return null;\n        },\n        parse: (capture: any, parse: any, state: any): any => ({\n            id: capture[1],\n        }),\n    },\n    // This is pretty much horrible, but we have a regex here to capture an\n    // entire table + a title. capture[1] is the title. capture[2] of the\n    // regex is a copy of the simple-markdown nptable regex. Then we turn\n    // our capture[2] into tableCapture[0], and any further captures in\n    // our table regex into tableCapture[1..], and we pass tableCapture to\n    // our nptable regex\n    titledTable: {\n        // process immediately before nptables\n        order: SimpleMarkdown.defaultRules.nptable.order - 0.5,\n        match: SimpleMarkdown.blockRegex(TITLED_TABLE_REGEX) as any,\n        parse: (capture: any, parse: any, state: any): any => {\n            const title = SimpleMarkdown.parseInline(parse, capture[1], state);\n\n            // Remove our [0] and [1] captures, and pass the rest to\n            // the nptable parser\n            const tableCapture = capture.slice(2);\n            const table = SimpleMarkdown.defaultRules.nptable.parse(\n                tableCapture,\n                parse,\n                state,\n            );\n            return {\n                title: title,\n                table: table,\n            };\n        },\n    },\n    widget: {\n        order: SimpleMarkdown.defaultRules.link.order - 0.75,\n        match: SimpleMarkdown.inlineRegex(rWidgetRule) as any,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {\n                id: capture[1],\n                widgetType: capture[2],\n            };\n        },\n    },\n    blockMath: {\n        order: (SimpleMarkdown.defaultRules.codeBlock.order + 0.5) as any,\n        match: blockMathMatch,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {\n                content: capture[1],\n            };\n        },\n    },\n    math: {\n        order: SimpleMarkdown.defaultRules.link.order - 0.25,\n        match: mathMatch,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {\n                content: capture[1],\n            };\n        },\n    },\n    unescapedDollar: {\n        order: SimpleMarkdown.defaultRules.link.order - 0.24,\n        match: SimpleMarkdown.inlineRegex(/^(?!\\\\)\\$/) as any,\n        parse: (capture: any, parse: any, state: any): any => {\n            return {};\n        },\n    },\n    fence: {\n        ...SimpleMarkdown.defaultRules.fence,\n        parse: (capture: any, parse: any, state: any): any => {\n            const node = SimpleMarkdown.defaultRules.fence.parse(\n                capture,\n                parse,\n                state,\n            );\n\n            // support screenreader-only text with ```alt\n            if (node.lang === \"alt\") {\n                return {\n                    type: \"codeBlock\",\n                    lang: \"alt\",\n                    // default codeBlock parsing doesn't parse the contents.\n                    // We need to parse the contents for things like table\n                    // support :).\n                    // The \\n\\n is because the inside of the codeblock might\n                    // not end in double newlines for block rules, because\n                    // ordinarily we don't parse this :).\n                    content: parse(node.content + \"\\n\\n\", state),\n                };\n            }\n            return node;\n        },\n    },\n    blockQuote: {\n        ...SimpleMarkdown.defaultRules.blockQuote,\n        // Replace the less restrictive blockquote regex from SimpleMarkdown\n        // with a more restrictive one. The only difference should be that\n        //\n        // > A blockquote\n        //\n        // > Another blockquote\n        //\n        // will now match as two different blockQuotes instead of a single\n        // blockquote with some paragraph breaks in it.\n        //\n        // The main motivation for doing this is to provide better support for\n        // translators translating blockquotes with multiple paragraphs in\n        // them. When translating articles, we split up paragraphs, translate\n        // them separately, and then recombine them. We do this so that\n        // translators don't have to translate an entire article at a time,\n        // they can instead translate paragraph-by-paragraph.That system\n        // doesn't understand blockquotes, so it will split up blockquotes into\n        // more than one paragraph. A way to solve this would be to make that\n        // system understand blockquotes, but then translators would have to\n        // translate an entire, multi-paragraph blockquote at a time. Instead,\n        // we choose to modify our blockquote matching to split up\n        // multi-paragraph blockquotes into multiple blockquotes.\n        //\n        // There is also precedence for doing this splitting up in other\n        // libraries, for instance CommonMark also splits up blockquotes with\n        // empty lines into multiple blockquotes:\n        // https://spec.commonmark.org/0.28/#example-205\n        match: SimpleMarkdown.blockRegex(\n            /^ *>[^\\n]+(\\n( *>)?[^\\n]+)*\\n{2,}/,\n        ) as any,\n    },\n    // The lint rule never actually matches anything.\n    // We check for lint after parsing, and, if we find any, we\n    // transform the tree to add lint nodes. This rule is here\n    // just for the react() function\n    lint: {\n        order: 1000,\n        match: (s: any): any => null,\n        parse: (capture: any, parse: any, state: any): any => ({}),\n    },\n} as const;\n\n// @ts-expect-error - TS2345 - Argument of type '{ readonly columns: { readonly order: -2; readonly match: any; readonly parse: (capture: any, parse: any, state: any) => any; }; readonly crowdinId: { readonly order: -1; readonly match: (source: any, state: any, prevCapture: any) => any; readonly parse: (capture: any, parse: any, state: any) => any; }; ... 34 more ...' is not assignable to parameter of type 'ParserRules'.\nconst builtParser = SimpleMarkdown.parserFor(pureMarkdownRules);\n\nexport const parse = (source: string, state?: any): any => {\n    const paragraphedSource = source + \"\\n\\n\";\n\n    return builtParser(paragraphedSource, {\n        ...state,\n        inline: false,\n    });\n};\n"],"names":["libName","libVersion","addLibraryVersionToPerseusDebug","rWidgetRule","mathMatcher","source","state","isBlock","length","index","inline","startIndex","braceLevel","character","endIndex","match","exec","slice","substring","mathMatch","blockMathMatch","TITLED_TABLE_REGEX","RegExp","SimpleMarkdown","defaultRules","nptable","regex","crowdinJiptMatcher","blockRegex","pureMarkdownRules","columns","order","parse","capture","col1","col2","crowdinId","prevCapture","isJipt","id","titledTable","title","parseInline","tableCapture","table","widget","link","inlineRegex","widgetType","blockMath","codeBlock","content","math","unescapedDollar","fence","node","lang","type","blockQuote","lint","s","builtParser","parserFor","paragraphedSource"],"mappings":";;;;;;;;;;;AAMA,MAAMA,OAAAA,CAAU,4BAChB,CAAaC,MAAAA,UAAAA,CAAa,QAE1BC,6CAAgCF,OAASC,CAAAA,UAAAA,CAAAA;;ACCzC,MAAME,WAAc,CAAA,sCAAA,CAwBpB,MAAMC,WAAAA,CAAc,CAACC,MAAaC,CAAAA,KAAAA,CAAYC,OAC1C,GAAA,CAAA,MAAMC,MAASH,CAAAA,MAAAA,CAAOG,MAAM,CAC5B,IAAIC,KAAQ,CAAA,CAAA,CAGZ,GAAIF,OAAAA,CAAS,CACT,GAAID,KAAMI,CAAAA,MAAM,CAAE,CACd,OAAO,IACX,CACA,MAAOD,KAAAA,CAAQD,MAAUH,EAAAA,MAAM,CAACI,KAAM,CAAA,GAAK,GAAK,CAAA,CAC5CA,KACJ,GAAA,CACJ,CAGA,GAAI,EAAEA,KAAAA,CAAQD,MAAUH,EAAAA,MAAM,CAACI,KAAAA,CAAM,GAAK,GAAE,EAAI,CAC5C,OAAO,IACX,CAEAA,QACA,MAAME,UAAAA,CAAaF,KACnB,CAAA,IAAIG,WAAa,CAKjB,CAAA,MAAOH,KAAQD,CAAAA,MAAAA,CAAQ,CACnB,MAAMK,SAAYR,CAAAA,MAAM,CAACI,KAAM,CAAA,CAE/B,GAAII,SAAAA,GAAc,IAAM,CAAA,CASpBJ,KACJ,GAAA,CAAA,KAAO,GAAIG,UAAc,EAAA,CAAA,EAAKC,SAAc,GAAA,GAAA,CAAK,CAC7C,IAAIC,QAAWL,CAAAA,KAAAA,CAAQ,EACvB,GAAIF,OAAAA,CAAS,CAET,MAAMQ,KAAQ,CAAA,eAAA,CAAgBC,IAAI,CAACX,OAAOY,KAAK,CAACH,QAEhDA,CAAAA,CAAAA,CAAAA,QAAAA,CAAWC,KAAQD,CAAAA,QAAAA,CAAWC,KAAK,CAAC,EAAE,CAACP,MAAM,CAAG,KACpD,CASA,GAAIM,QAAU,CAAA,CACV,OAAO,CACHT,MAAAA,CAAOa,SAAS,CAAC,CAAGJ,CAAAA,QAAAA,CAAAA,CACpBT,MAAOa,CAAAA,SAAS,CAACP,UAAYF,CAAAA,KAAAA,CAAAA,CAChC,CAEL,OAAO,IACX,CAAA,KAAO,GAAII,SAAAA,GAAc,IAAK,CAC1BD,UAAAA,GACJ,CAAO,KAAA,GAAIC,SAAc,GAAA,GAAA,CAAK,CAC1BD,UAAAA,GACJ,MAAO,GAAIC,SAAAA,GAAc,IAAQR,EAAAA,MAAM,CAACI,KAAAA,CAAQ,CAAE,CAAA,GAAK,KAAM,CAMzD,OAAO,IACX,CAEAA,KACJ,GAAA,CAGA,OAAO,IACX,EACA,MAAMU,SAAAA,CAAY,CAACd,MAAAA,CAAaC,KAC5BF,GAAAA,WAAAA,CAAYC,MAAQC,CAAAA,KAAAA,CAAO,OAC/B,MAAMc,cAAAA,CAAiB,CAACf,MAAAA,CAAaC,KACjCF,GAAAA,WAAAA,CAAYC,MAAQC,CAAAA,KAAAA,CAAO,MAE/B,MAAMe,kBAAAA,CAAqB,IAAIC,MAAAA,CAC3B,4BACI,CAAA,GAAA,CAIAC,+BAAeC,CAAAA,YAAY,CAACC,OAAO,CAACV,KAAK,CAACW,KAAK,CAACrB,MAAM,CAACa,SAAS,CAAC,CAAA,CAAA,CACjE,GAGR,CAAA,CAAA,MAAMS,mBAAqBJ,+BAAeK,CAAAA,UAAU,CAAC,oBAAA,CAErD,CAAaC,MAAAA,iBAAAA,CAAoB,CAC7B,GAAGN,+BAAeC,CAAAA,YAAY,CAG9BM,OAAAA,CAAS,CACLC,KAAO,CAAA,EACPhB,CAAAA,KAAAA,CAAOQ,+BAAeK,CAAAA,UAAU,CAC5B,kCAAA,CAAA,CAEJI,MAAO,CAACC,OAAAA,CAAcD,KAAY1B,CAAAA,KAAAA,GAAAA,CAC9B,OAAO,CACH4B,IAAMF,CAAAA,KAAAA,CAAMC,OAAO,CAAC,CAAA,CAAE,CAAE3B,KAAAA,CAAAA,CACxB6B,KAAMH,KAAMC,CAAAA,OAAO,CAAC,CAAA,CAAE,CAAE3B,KAC5B,CAAA,CACJ,CACJ,CAAA,CACA8B,SAAW,CAAA,CACPL,KAAO,CAAA,GACPhB,KAAO,CAAA,CAACV,MAAaC,CAAAA,KAAAA,CAAY+B,WAE7B,GAAA,CAAA,GAAI/B,KAAMgC,CAAAA,MAAM,CAAE,CACd,OAAOX,kBAAmBtB,CAAAA,MAAAA,CAAQC,KAAO+B,CAAAA,WAAAA,CAC7C,CACA,OAAO,IACX,CACAL,CAAAA,KAAAA,CAAO,CAACC,OAAAA,CAAcD,MAAY1B,KAAqB,IAAA,CACnDiC,EAAAA,CAAIN,OAAO,CAAC,CAAA,CAAE,CAClB,CACJ,CAAA,CAOAO,WAAa,CAAA,CAETT,MAAOR,+BAAeC,CAAAA,YAAY,CAACC,OAAO,CAACM,KAAK,CAAG,EAAA,CACnDhB,MAAOQ,+BAAeK,CAAAA,UAAU,CAACP,kBAAAA,CAAAA,CACjCW,KAAO,CAAA,CAACC,OAAcD,CAAAA,KAAAA,CAAY1B,SAC9B,MAAMmC,KAAAA,CAAQlB,+BAAemB,CAAAA,WAAW,CAACV,KAAAA,CAAOC,OAAO,CAAC,EAAE,CAAE3B,KAAAA,CAAAA,CAI5D,MAAMqC,YAAAA,CAAeV,OAAQhB,CAAAA,KAAK,CAAC,CAAA,CAAA,CACnC,MAAM2B,KAAQrB,CAAAA,+BAAAA,CAAeC,YAAY,CAACC,OAAO,CAACO,KAAK,CACnDW,aACAX,KACA1B,CAAAA,KAAAA,CAAAA,CAEJ,OAAO,CACHmC,KAAOA,CAAAA,KAAAA,CACPG,KAAOA,CAAAA,KACX,CACJ,CACJ,CAAA,CACAC,MAAQ,CAAA,CACJd,MAAOR,+BAAeC,CAAAA,YAAY,CAACsB,IAAI,CAACf,KAAK,CAAG,GAChDhB,CAAAA,KAAAA,CAAOQ,+BAAewB,CAAAA,WAAW,CAAC5C,WAAAA,CAAAA,CAClC6B,MAAO,CAACC,OAAAA,CAAcD,KAAY1B,CAAAA,KAAAA,GAAAA,CAC9B,OAAO,CACHiC,EAAIN,CAAAA,OAAO,CAAC,CAAE,CAAA,CACde,UAAYf,CAAAA,OAAO,CAAC,CAAA,CAAE,CAE9B,CACJ,CACAgB,CAAAA,SAAAA,CAAW,CACPlB,KAAAA,CAAQR,+BAAeC,CAAAA,YAAY,CAAC0B,SAAS,CAACnB,KAAK,CAAG,EACtDhB,CAAAA,KAAAA,CAAOK,cACPY,CAAAA,KAAAA,CAAO,CAACC,OAAAA,CAAcD,MAAY1B,KAC9B,GAAA,CAAA,OAAO,CACH6C,OAAAA,CAASlB,OAAO,CAAC,CAAE,CACvB,CACJ,CACJ,CAAA,CACAmB,IAAM,CAAA,CACFrB,KAAOR,CAAAA,+BAAAA,CAAeC,YAAY,CAACsB,IAAI,CAACf,KAAK,CAAG,GAAA,CAChDhB,MAAOI,SACPa,CAAAA,KAAAA,CAAO,CAACC,OAAAA,CAAcD,MAAY1B,KAC9B,GAAA,CAAA,OAAO,CACH6C,OAAAA,CAASlB,OAAO,CAAC,CAAE,CACvB,CACJ,CACJ,CAAA,CACAoB,eAAiB,CAAA,CACbtB,KAAOR,CAAAA,+BAAAA,CAAeC,YAAY,CAACsB,IAAI,CAACf,KAAK,CAAG,GAAA,CAChDhB,KAAOQ,CAAAA,+BAAAA,CAAewB,WAAW,CAAC,aAClCf,KAAO,CAAA,CAACC,OAAcD,CAAAA,KAAAA,CAAY1B,KAC9B,GAAA,CAAA,OAAO,EACX,CACJ,CACAgD,CAAAA,KAAAA,CAAO,CACH,GAAG/B,+BAAeC,CAAAA,YAAY,CAAC8B,KAAK,CACpCtB,KAAO,CAAA,CAACC,OAAcD,CAAAA,KAAAA,CAAY1B,KAC9B,GAAA,CAAA,MAAMiD,IAAOhC,CAAAA,+BAAAA,CAAeC,YAAY,CAAC8B,KAAK,CAACtB,KAAK,CAChDC,OAAAA,CACAD,KACA1B,CAAAA,KAAAA,CAAAA,CAIJ,GAAIiD,IAAKC,CAAAA,IAAI,GAAK,KAAA,CAAO,CACrB,OAAO,CACHC,IAAM,CAAA,WAAA,CACND,KAAM,KAONL,CAAAA,OAAAA,CAASnB,KAAMuB,CAAAA,IAAAA,CAAKJ,OAAO,CAAG,MAAQ7C,CAAAA,KAAAA,CAC1C,CACJ,CACA,OAAOiD,IACX,CACJ,CACAG,CAAAA,UAAAA,CAAY,CACR,GAAGnC,gCAAeC,YAAY,CAACkC,UAAU,CA4BzC3C,KAAOQ,CAAAA,+BAAAA,CAAeK,UAAU,CAC5B,oCAER,CAKA+B,CAAAA,IAAAA,CAAM,CACF5B,KAAAA,CAAO,IACPhB,KAAO,CAAC6C,CAAgB,EAAA,IAAA,CACxB5B,MAAO,CAACC,OAAAA,CAAcD,KAAY1B,CAAAA,KAAAA,IAAqB,EAAC,CAC5D,CACJ,EAGA,MAAMuD,WAAAA,CAActC,+BAAeuC,CAAAA,SAAS,CAACjC,iBAAAA,CAE7C,CAAaG,MAAAA,KAAAA,CAAQ,CAAC3B,MAAAA,CAAgBC,KAClC,GAAA,CAAA,MAAMyD,iBAAoB1D,CAAAA,MAAAA,CAAS,OAEnC,OAAOwD,WAAAA,CAAYE,iBAAmB,CAAA,CAClC,GAAGzD,KAAK,CACRI,MAAQ,CAAA,KACZ,EACJ;;;;;;"}

package/package.json

@@ -3,7 +3,7 @@
   "description": "SimpleMarkdown instance with non-react Perseus rules",
   "author": "Khan Academy",
   "license": "MIT",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "publishConfig": {
     "access": "public"
   },
@@ -22,11 +22,11 @@
     "dist"
   ],
   "dependencies": {
-    "@khanacademy/perseus-utils": "2.0.0",
-    "@khanacademy/simple-markdown": "2.0.0"
+    "@khanacademy/perseus-utils": "2.0.1",
+    "@khanacademy/simple-markdown": "2.0.2"
   },
   "devDependencies": {
-    "perseus-build-settings": "0.6.0"
+    "perseus-build-settings": "0.6.1"
   },
   "peerDependencies": {},
   "keywords": [],