@khanacademy/pure-markdown 0.1.5 → 0.2.1

package/.eslintrc.js

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
 /* eslint-disable import/no-commonjs */
 const path = require("path");
 

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @khanacademy/pure-markdown
 
+## 0.2.1
+
+### Patch Changes
+
+-   1f062e98: Bump all package versions since the build settings have been updated
+-   Updated dependencies [1f062e98]
+    -   @khanacademy/perseus-error@0.2.1
+    -   @khanacademy/simple-markdown@0.9.1
+
+## 0.2.0
+
+### Minor Changes
+
+-   53fd3768: Migrate source code to TypeScript
+
+### Patch Changes
+
+-   Updated dependencies [53fd3768]
+    -   @khanacademy/perseus-error@0.2.0
+    -   @khanacademy/simple-markdown@0.9.0
+
 ## 0.1.5
 
 ### Patch Changes

package/dist/es/index.js

@@ -1,44 +1,21 @@
 import SimpleMarkdown from '@khanacademy/simple-markdown';
 
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly && (symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    })), keys.push.apply(keys, symbols);
-  }
-
-  return keys;
-}
-
-function _objectSpread2(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = null != arguments[i] ? arguments[i] : {};
-    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
-      _defineProperty(target, key, source[key]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
-      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-    });
-  }
-
-  return target;
-}
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
 
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
+    return target;
+  };
 
-  return obj;
+  return _extends.apply(this, arguments);
 }
 
 /**
@@ -64,36 +41,34 @@ function _defineProperty(obj, key, value) {
  * This can also match block-math, which is math alone in a paragraph.
  */
 
-var rWidgetRule = /^\[\[\u2603 (([a-z-]+) ([0-9]+))\]\]/;
-
-var mathMatcher = (source, state, isBlock) => {
-  var length = source.length;
-  var index = 0; // When looking for blocks, skip over leading spaces
+const rWidgetRule = /^\[\[\u2603 (([a-z-]+) ([0-9]+))\]\]/;
+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 "$"
-
+  }
 
+  // Our source must start with a "$"
   if (!(index < length && source[index] === "$")) {
     return null;
   }
-
   index++;
-  var startIndex = index;
-  var braceLevel = 0; // Loop through the source, looking for a closing '$'
+  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) {
-    var character = source[index];
-
+    const character = source[index];
     if (character === "\\") {
       // Consume both the `\` and the escaped char as a single
       // token.
@@ -105,24 +80,23 @@ var mathMatcher = (source, state, isBlock) => {
       // braces `\{`
       index++;
     } else if (braceLevel <= 0 && character === "$") {
-      var endIndex = index + 1;
-
+      let endIndex = index + 1;
       if (isBlock) {
         // Look for two trailing newlines after the closing `$`
-        var match = /^(?: *\n){2,}/.exec(source.slice(endIndex));
+        const match = /^(?: *\n){2,}/.exec(source.slice(endIndex));
+        // @ts-expect-error [FEI-5003] - 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
+      }
+
+      // 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
       //   /\$([^\$]*)\$/
-
-
       if (endIndex) {
         return [source.substring(0, endIndex), source.substring(startIndex, index)];
       }
-
       return null;
     } else if (character === "{") {
       braceLevel++;
@@ -136,32 +110,30 @@ var mathMatcher = (source, state, isBlock) => {
       // in paragraphs...
       return null;
     }
-
     index++;
-  } // we didn't find a closing `$`
-
+  }
 
+  // we didn't find a closing `$`
   return null;
 };
-
-var mathMatch = (source, state) => mathMatcher(source, state, false);
-
-var blockMathMatch = (source, state) => mathMatcher(source, state, true);
-
-var TITLED_TABLE_REGEX = new RegExp("^\\|\\| +(.*) +\\|\\| *\\n" + "(" + // The simple-markdown nptable regex, without
+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 `^`
 // $FlowFixMe[incompatible-use]
+// @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
 SimpleMarkdown.defaultRules.nptable.match.regex.source.substring(1) + ")");
-var crowdinJiptMatcher = SimpleMarkdown.blockRegex(/^(crwdns.*)\n\s*\n/);
-var pureMarkdownRules = _objectSpread2(_objectSpread2({}, SimpleMarkdown.defaultRules), {}, {
+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) => {
+    parse: (capture, parse, state) => {
       return {
-        col1: _parse(capture[1], state),
-        col2: _parse(capture[2], state)
+        col1: parse(capture[1], state),
+        col2: parse(capture[2], state)
       };
     }
   },
@@ -172,10 +144,9 @@ var pureMarkdownRules = _objectSpread2(_objectSpread2({}, SimpleMarkdown.default
       if (state.isJipt) {
         return crowdinJiptMatcher(source, state, prevCapture);
       }
-
       return null;
     },
-    parse: (capture, _parse2, state) => ({
+    parse: (capture, parse, state) => ({
       id: capture[1]
     })
   },
@@ -189,12 +160,13 @@ var pureMarkdownRules = _objectSpread2(_objectSpread2({}, SimpleMarkdown.default
     // process immediately before nptables
     order: SimpleMarkdown.defaultRules.nptable.order - 0.5,
     match: SimpleMarkdown.blockRegex(TITLED_TABLE_REGEX),
-    parse: (capture, _parse3, state) => {
-      var title = SimpleMarkdown.parseInline(_parse3, capture[1], state); // Remove our [0] and [1] captures, and pass the rest to
-      // the nptable parser
+    parse: (capture, parse, state) => {
+      const title = SimpleMarkdown.parseInline(parse, capture[1], state);
 
-      var tableCapture = capture.slice(2);
-      var table = SimpleMarkdown.defaultRules.nptable.parse(tableCapture, _parse3, 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
@@ -204,7 +176,7 @@ var pureMarkdownRules = _objectSpread2(_objectSpread2({}, SimpleMarkdown.default
   widget: {
     order: SimpleMarkdown.defaultRules.link.order - 0.75,
     match: SimpleMarkdown.inlineRegex(rWidgetRule),
-    parse: (capture, _parse4, state) => {
+    parse: (capture, parse, state) => {
       return {
         id: capture[1],
         widgetType: capture[2]
@@ -214,7 +186,7 @@ var pureMarkdownRules = _objectSpread2(_objectSpread2({}, SimpleMarkdown.default
   blockMath: {
     order: SimpleMarkdown.defaultRules.codeBlock.order + 0.5,
     match: blockMathMatch,
-    parse: (capture, _parse5, state) => {
+    parse: (capture, parse, state) => {
       return {
         content: capture[1]
       };
@@ -223,7 +195,7 @@ var pureMarkdownRules = _objectSpread2(_objectSpread2({}, SimpleMarkdown.default
   math: {
     order: SimpleMarkdown.defaultRules.link.order - 0.25,
     match: mathMatch,
-    parse: (capture, _parse6, state) => {
+    parse: (capture, parse, state) => {
       return {
         content: capture[1]
       };
@@ -232,14 +204,15 @@ var pureMarkdownRules = _objectSpread2(_objectSpread2({}, SimpleMarkdown.default
   unescapedDollar: {
     order: SimpleMarkdown.defaultRules.link.order - 0.24,
     match: SimpleMarkdown.inlineRegex(/^(?!\\)\$/),
-    parse: (capture, _parse7, state) => {
+    parse: (capture, parse, state) => {
       return {};
     }
   },
-  fence: _objectSpread2(_objectSpread2({}, SimpleMarkdown.defaultRules.fence), {}, {
-    parse: (capture, _parse8, state) => {
-      var node = SimpleMarkdown.defaultRules.fence.parse(capture, _parse8, state); // support screenreader-only text with ```alt
+  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",
@@ -250,14 +223,13 @@ var pureMarkdownRules = _objectSpread2(_objectSpread2({}, SimpleMarkdown.default
           // 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: _parse8(node.content + "\n\n", state)
+          content: parse(node.content + "\n\n", state)
         };
       }
-
       return node;
     }
   }),
-  blockQuote: _objectSpread2(_objectSpread2({}, SimpleMarkdown.defaultRules.blockQuote), {}, {
+  blockQuote: _extends({}, SimpleMarkdown.defaultRules.blockQuote, {
     // Replace the less restrictive blockquote regex from SimpleMarkdown
     // with a more restrictive one. The only difference should be that
     //
@@ -287,7 +259,7 @@ var pureMarkdownRules = _objectSpread2(_objectSpread2({}, SimpleMarkdown.default
     // https://spec.commonmark.org/0.28/#example-205
     match: SimpleMarkdown.blockRegex(/^ *>[^\n]+(\n( *>)?[^\n]+)*\n{2,}/)
   }),
-  list: _objectSpread2(_objectSpread2({}, SimpleMarkdown.defaultRules.list), {}, {
+  list: _extends({}, SimpleMarkdown.defaultRules.list, {
     match: (source, state, prevCapture) => {
       // Since lists can contain double newlines and we have special
       // handling of double newlines while parsing jipt content, just
@@ -295,7 +267,6 @@ var pureMarkdownRules = _objectSpread2(_objectSpread2({}, SimpleMarkdown.default
       if (state.isJipt) {
         return null;
       }
-
       return SimpleMarkdown.defaultRules.list.match(source, state, prevCapture);
     }
   }),
@@ -306,14 +277,15 @@ var pureMarkdownRules = _objectSpread2(_objectSpread2({}, SimpleMarkdown.default
   lint: {
     order: 1000,
     match: s => null,
-    parse: (capture, _parse9, state) => ({})
+    parse: (capture, parse, state) => ({})
   }
-}); // $FlowFixMe[incompatible-call]
+});
 
-var builtParser = SimpleMarkdown.parserFor(pureMarkdownRules);
-var parse = (source, state) => {
-  var paragraphedSource = source + "\n\n";
-  return builtParser(paragraphedSource, _objectSpread2(_objectSpread2({}, state), {}, {
+// @ts-expect-error [FEI-5003] - 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
   }));
 };

package/dist/es/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../src/index.js"],"sourcesContent":["// @flow\n\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 */\nimport SimpleMarkdown from \"@khanacademy/simple-markdown\";\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 */\n\nconst rWidgetRule: RegExp = /^\\[\\[\\u2603 (([a-z-]+) ([0-9]+))\\]\\]/;\n\nconst mathMatcher = (source, state, isBlock) => {\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                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            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        // $FlowFixMe[incompatible-use]\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        ): 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): 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): 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: 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(/^(?!\\\\)\\$/): 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        ): any),\n    },\n    list: {\n        ...SimpleMarkdown.defaultRules.list,\n        match: (source: any, state: any, prevCapture: any): any => {\n            // Since lists can contain double newlines and we have special\n            // handling of double newlines while parsing jipt content, just\n            // disable the list parser.\n            if (state.isJipt) {\n                return null;\n            }\n            return SimpleMarkdown.defaultRules.list.match(\n                source,\n                state,\n                prevCapture,\n            );\n        },\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};\n\n// $FlowFixMe[incompatible-call]\nconst builtParser = SimpleMarkdown.parserFor(pureMarkdownRules);\n\nexport const parse = (source: string, state: $FlowFixMe): $FlowFixMe => {\n    const paragraphedSource = source + \"\\n\\n\";\n\n    return builtParser(paragraphedSource, {\n        ...state,\n        inline: false,\n    });\n};\n"],"names":["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","list","lint","s","builtParser","parserFor","paragraphedSource","_objectSpread"],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../../../../node_modules/@babel/runtime/helpers/esm/extends.js","../../src/index.ts"],"sourcesContent":["export default function _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\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 */\nimport SimpleMarkdown from \"@khanacademy/simple-markdown\";\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 */\n\nconst rWidgetRule = /^\\[\\[\\u2603 (([a-z-]+) ([0-9]+))\\]\\]/;\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 [FEI-5003] - 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            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        // $FlowFixMe[incompatible-use]\n        // @ts-expect-error [FEI-5003] - 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    list: {\n        ...SimpleMarkdown.defaultRules.list,\n        match: (source: any, state: any, prevCapture: any): any => {\n            // Since lists can contain double newlines and we have special\n            // handling of double newlines while parsing jipt content, just\n            // disable the list parser.\n            if (state.isJipt) {\n                return null;\n            }\n            return SimpleMarkdown.defaultRules.list.match(\n                source,\n                state,\n                prevCapture,\n            );\n        },\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 [FEI-5003] - 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":["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","list","lint","s","builtParser","parserFor","paragraphedSource"],"mappings":"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"}