react-native-marcus 0.1.1 → 0.2.0

package/lib/commonjs/parser/index.js

@@ -1,4 +1,14 @@
-module.exports.parse = function parse(markdown) {
+const __parsers = new Map();
+module.exports.createParser = function createParser(options) {
+const __marcusGfm = !!(options && options.gfm === true);
+const __marcusMention = !!(options && options.mention === true);
+const __marcusMath = !!(options && options.math === true);
+const key = `${__marcusGfm}:${__marcusMention}:${__marcusMath}`;
+const cached = __parsers.get(key);
+if (cached !== undefined) {
+  return cached;
+}
+const parse = function parse(markdown) {
 "worklet";
 function TextDecoder() {
   throw new Error('TextDecoder is not available in the worklet runtime');
@@ -2320,7 +2330,7 @@ var content = {
 };
 function initializeContent(effects) {
   const contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial);
-  let previous2;
+  let previous4;
   return contentStart;
   function afterContentStartConstruct(code2) {
     if (code2 === null) {
@@ -2339,12 +2349,12 @@ function initializeContent(effects) {
   function lineStart(code2) {
     const token = effects.enter("chunkText", {
       contentType: "text",
-      previous: previous2
+      previous: previous4
     });
-    if (previous2) {
-      previous2.next = token;
+    if (previous4) {
+      previous4.next = token;
     }
-    previous2 = token;
+    previous4 = token;
     return data(code2);
   }
   function data(code2) {
@@ -2672,8 +2682,8 @@ function resolveAllAttention(events, context) {
 }
 function tokenizeAttention(effects, ok) {
   const attentionMarkers2 = this.parser.constructs.attentionMarkers.null;
-  const previous2 = this.previous;
-  const before = classifyCharacter(previous2);
+  const previous4 = this.previous;
+  const before = classifyCharacter(previous4);
   let marker;
   return start;
   function start(code2) {
@@ -2689,7 +2699,7 @@ function tokenizeAttention(effects, ok) {
     const token = effects.exit("attentionSequence");
     const after = classifyCharacter(code2);
     const open = !after || after === 2 && before || attentionMarkers2.includes(code2);
-    const close = !before || before === 2 && after || attentionMarkers2.includes(previous2);
+    const close = !before || before === 2 && after || attentionMarkers2.includes(previous4);
     token._open = Boolean(marker === 42 ? open : open && (before || !close));
     token._close = Boolean(marker === 42 ? close : close && (after || !open));
     return ok(code2);
@@ -3609,7 +3619,7 @@ function subcontent(events, eventIndex) {
   const jumps = [];
   const gaps = {};
   let stream;
-  let previous2;
+  let previous4;
   let index = -1;
   let current = token;
   let adjust = 0;
@@ -3624,7 +3634,7 @@ function subcontent(events, eventIndex) {
       if (!current.next) {
         stream.push(null);
       }
-      if (previous2) {
+      if (previous4) {
         tokenizer.defineSkip(current.start);
       }
       if (current._isInFirstContentOfListItem) {
@@ -3635,7 +3645,7 @@ function subcontent(events, eventIndex) {
         tokenizer._gfmTasklistFirstContentOfListItem = void 0;
       }
     }
-    previous2 = current;
+    previous4 = current;
     current = current.next;
   }
   current = token;
@@ -3688,11 +3698,11 @@ function resolveContent(events) {
   return events;
 }
 function tokenizeContent(effects, ok) {
-  let previous2;
+  let previous4;
   return chunkStart;
   function chunkStart(code2) {
     effects.enter("content");
-    previous2 = effects.enter("chunkContent", {
+    previous4 = effects.enter("chunkContent", {
       contentType: "content"
     });
     return chunkInside(code2);
@@ -3715,11 +3725,11 @@ function tokenizeContent(effects, ok) {
   function contentContinue(code2) {
     effects.consume(code2);
     effects.exit("chunkContent");
-    previous2.next = effects.enter("chunkContent", {
+    previous4.next = effects.enter("chunkContent", {
       contentType: "content",
-      previous: previous2
+      previous: previous4
     });
-    previous2 = previous2.next;
+    previous4 = previous4.next;
     return chunkInside;
   }
 }
@@ -6578,19 +6588,19 @@ function gfmStrikethrough(options) {
     return events;
   }
   function tokenizeStrikethrough(effects, ok, nok) {
-    const previous2 = this.previous;
+    const previous4 = this.previous;
     const events = this.events;
     let size = 0;
     return start;
     function start(code2) {
-      if (previous2 === 126 && events[events.length - 1][1].type !== "characterEscape") {
+      if (previous4 === 126 && events[events.length - 1][1].type !== "characterEscape") {
         return nok(code2);
       }
       effects.enter("strikethroughSequenceTemporary");
       return more(code2);
     }
     function more(code2) {
-      const before = classifyCharacter(previous2);
+      const before = classifyCharacter(previous4);
       if (code2 === 126) {
         if (size > 1) return nok(code2);
         effects.consume(code2);
@@ -6607,14 +6617,296 @@ function gfmStrikethrough(options) {
   }
 }
 
+// node_modules/micromark-extension-math/lib/math-flow.js
+var mathFlow = {
+  tokenize: tokenizeMathFenced,
+  concrete: true,
+  name: "mathFlow"
+};
+var nonLazyContinuation2 = {
+  tokenize: tokenizeNonLazyContinuation2,
+  partial: true
+};
+function tokenizeMathFenced(effects, ok, nok) {
+  const self = this;
+  const tail = self.events[self.events.length - 1];
+  const initialSize = tail && tail[1].type === "linePrefix" ? tail[2].sliceSerialize(tail[1], true).length : 0;
+  let sizeOpen = 0;
+  return start;
+  function start(code2) {
+    effects.enter("mathFlow");
+    effects.enter("mathFlowFence");
+    effects.enter("mathFlowFenceSequence");
+    return sequenceOpen(code2);
+  }
+  function sequenceOpen(code2) {
+    if (code2 === 36) {
+      effects.consume(code2);
+      sizeOpen++;
+      return sequenceOpen;
+    }
+    if (sizeOpen < 2) {
+      return nok(code2);
+    }
+    effects.exit("mathFlowFenceSequence");
+    return factorySpace(effects, metaBefore, "whitespace")(code2);
+  }
+  function metaBefore(code2) {
+    if (code2 === null || markdownLineEnding(code2)) {
+      return metaAfter(code2);
+    }
+    effects.enter("mathFlowFenceMeta");
+    effects.enter("chunkString", {
+      contentType: "string"
+    });
+    return meta(code2);
+  }
+  function meta(code2) {
+    if (code2 === null || markdownLineEnding(code2)) {
+      effects.exit("chunkString");
+      effects.exit("mathFlowFenceMeta");
+      return metaAfter(code2);
+    }
+    if (code2 === 36) {
+      return nok(code2);
+    }
+    effects.consume(code2);
+    return meta;
+  }
+  function metaAfter(code2) {
+    effects.exit("mathFlowFence");
+    if (self.interrupt) {
+      return ok(code2);
+    }
+    return effects.attempt(nonLazyContinuation2, beforeNonLazyContinuation, after)(code2);
+  }
+  function beforeNonLazyContinuation(code2) {
+    return effects.attempt({
+      tokenize: tokenizeClosingFence,
+      partial: true
+    }, after, contentStart)(code2);
+  }
+  function contentStart(code2) {
+    return (initialSize ? factorySpace(effects, beforeContentChunk, "linePrefix", initialSize + 1) : beforeContentChunk)(code2);
+  }
+  function beforeContentChunk(code2) {
+    if (code2 === null) {
+      return after(code2);
+    }
+    if (markdownLineEnding(code2)) {
+      return effects.attempt(nonLazyContinuation2, beforeNonLazyContinuation, after)(code2);
+    }
+    effects.enter("mathFlowValue");
+    return contentChunk(code2);
+  }
+  function contentChunk(code2) {
+    if (code2 === null || markdownLineEnding(code2)) {
+      effects.exit("mathFlowValue");
+      return beforeContentChunk(code2);
+    }
+    effects.consume(code2);
+    return contentChunk;
+  }
+  function after(code2) {
+    effects.exit("mathFlow");
+    return ok(code2);
+  }
+  function tokenizeClosingFence(effects2, ok2, nok2) {
+    let size = 0;
+    return factorySpace(effects2, beforeSequenceClose, "linePrefix", self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4);
+    function beforeSequenceClose(code2) {
+      effects2.enter("mathFlowFence");
+      effects2.enter("mathFlowFenceSequence");
+      return sequenceClose(code2);
+    }
+    function sequenceClose(code2) {
+      if (code2 === 36) {
+        size++;
+        effects2.consume(code2);
+        return sequenceClose;
+      }
+      if (size < sizeOpen) {
+        return nok2(code2);
+      }
+      effects2.exit("mathFlowFenceSequence");
+      return factorySpace(effects2, afterSequenceClose, "whitespace")(code2);
+    }
+    function afterSequenceClose(code2) {
+      if (code2 === null || markdownLineEnding(code2)) {
+        effects2.exit("mathFlowFence");
+        return ok2(code2);
+      }
+      return nok2(code2);
+    }
+  }
+}
+function tokenizeNonLazyContinuation2(effects, ok, nok) {
+  const self = this;
+  return start;
+  function start(code2) {
+    if (code2 === null) {
+      return ok(code2);
+    }
+    effects.enter("lineEnding");
+    effects.consume(code2);
+    effects.exit("lineEnding");
+    return lineStart;
+  }
+  function lineStart(code2) {
+    return self.parser.lazy[self.now().line] ? nok(code2) : ok(code2);
+  }
+}
+
+// node_modules/micromark-extension-math/lib/math-text.js
+function mathText(options) {
+  const options_ = options || {};
+  let single = options_.singleDollarTextMath;
+  if (single === null || single === void 0) {
+    single = true;
+  }
+  return {
+    tokenize: tokenizeMathText,
+    resolve: resolveMathText,
+    previous: previous2,
+    name: "mathText"
+  };
+  function tokenizeMathText(effects, ok, nok) {
+    const self = this;
+    let sizeOpen = 0;
+    let size;
+    let token;
+    return start;
+    function start(code2) {
+      effects.enter("mathText");
+      effects.enter("mathTextSequence");
+      return sequenceOpen(code2);
+    }
+    function sequenceOpen(code2) {
+      if (code2 === 36) {
+        effects.consume(code2);
+        sizeOpen++;
+        return sequenceOpen;
+      }
+      if (sizeOpen < 2 && !single) {
+        return nok(code2);
+      }
+      effects.exit("mathTextSequence");
+      return between(code2);
+    }
+    function between(code2) {
+      if (code2 === null) {
+        return nok(code2);
+      }
+      if (code2 === 36) {
+        token = effects.enter("mathTextSequence");
+        size = 0;
+        return sequenceClose(code2);
+      }
+      if (code2 === 32) {
+        effects.enter("space");
+        effects.consume(code2);
+        effects.exit("space");
+        return between;
+      }
+      if (markdownLineEnding(code2)) {
+        effects.enter("lineEnding");
+        effects.consume(code2);
+        effects.exit("lineEnding");
+        return between;
+      }
+      effects.enter("mathTextData");
+      return data(code2);
+    }
+    function data(code2) {
+      if (code2 === null || code2 === 32 || code2 === 36 || markdownLineEnding(code2)) {
+        effects.exit("mathTextData");
+        return between(code2);
+      }
+      effects.consume(code2);
+      return data;
+    }
+    function sequenceClose(code2) {
+      if (code2 === 36) {
+        effects.consume(code2);
+        size++;
+        return sequenceClose;
+      }
+      if (size === sizeOpen) {
+        effects.exit("mathTextSequence");
+        effects.exit("mathText");
+        return ok(code2);
+      }
+      token.type = "mathTextData";
+      return data(code2);
+    }
+  }
+}
+function resolveMathText(events) {
+  let tailExitIndex = events.length - 4;
+  let headEnterIndex = 3;
+  let index;
+  let enter;
+  if ((events[headEnterIndex][1].type === "lineEnding" || events[headEnterIndex][1].type === "space") && (events[tailExitIndex][1].type === "lineEnding" || events[tailExitIndex][1].type === "space")) {
+    index = headEnterIndex;
+    while (++index < tailExitIndex) {
+      if (events[index][1].type === "mathTextData") {
+        events[tailExitIndex][1].type = "mathTextPadding";
+        events[headEnterIndex][1].type = "mathTextPadding";
+        headEnterIndex += 2;
+        tailExitIndex -= 2;
+        break;
+      }
+    }
+  }
+  index = headEnterIndex - 1;
+  tailExitIndex++;
+  while (++index <= tailExitIndex) {
+    if (enter === void 0) {
+      if (index !== tailExitIndex && events[index][1].type !== "lineEnding") {
+        enter = index;
+      }
+    } else if (index === tailExitIndex || events[index][1].type === "lineEnding") {
+      events[enter][1].type = "mathTextData";
+      if (index !== enter + 2) {
+        events[enter][1].end = events[index - 1][1].end;
+        events.splice(enter + 2, index - enter - 2);
+        tailExitIndex -= index - enter - 2;
+        index = enter + 2;
+      }
+      enter = void 0;
+    }
+  }
+  return events;
+}
+function previous2(code2) {
+  return code2 !== 36 || this.events[this.events.length - 1][1].type === "characterEscape";
+}
+
+// node_modules/micromark-extension-math/lib/syntax.js
+function math(options) {
+  return {
+    flow: {
+      [36]: mathFlow
+    },
+    text: {
+      [36]: mathText(options)
+    }
+  };
+}
+
 // src/parser/micromark-extension-mentions.ts
 var LETTER = /^\p{L}$/u;
-var WORD = /^[\p{L}\p{M}\p{N}_]$/u;
 var ALPHANUMERIC = /^[\p{L}\p{M}\p{N}]$/u;
+var AT = 64;
+var DOT = 46;
+var HYPHEN = 45;
+var UNDERSCORE = 95;
 var mention = {
   name: "mention",
-  tokenize
+  tokenize,
+  previous: previous3
 };
+var join = { tokenize: tokenizeJoin, partial: true };
 function mentions() {
   return {
     text: {
@@ -6623,6 +6915,9 @@ function mentions() {
     }
   };
 }
+function previous3(code2) {
+  return code2 === null || code2 !== AT && !test(ALPHANUMERIC, code2);
+}
 function tokenize(effects, ok, nok) {
   return start;
   function start(code2) {
@@ -6638,25 +6933,52 @@ function tokenize(effects, ok, nok) {
       return nok(code2);
     }
     effects.consume(code2);
-    return body;
+    return part;
   }
-  function body(code2) {
-    if (code2 !== null && test(WORD, code2)) {
+  function part(code2) {
+    if (code2 !== null && test(ALPHANUMERIC, code2)) {
       effects.consume(code2);
-      return body;
+      return part;
     }
-    if (code2 === 45) {
-      return hyphen;
+    if (code2 === DOT) {
+      effects.consume(code2);
+      return afterDot;
+    }
+    if (code2 === HYPHEN || code2 === UNDERSCORE || code2 === AT) {
+      return effects.attempt(join, part, done);
     }
+    return done(code2);
+  }
+  function afterDot(code2) {
+    if (code2 === DOT) {
+      return done(code2);
+    }
+    return part(code2);
+  }
+  function done(code2) {
     effects.exit("mention");
     return ok(code2);
   }
-  function hyphen(code2) {
+}
+function tokenizeJoin(effects, ok, nok) {
+  return separator;
+  function separator(code2) {
+    effects.consume(code2);
+    return code2 === AT ? afterAt : afterJoin;
+  }
+  function afterJoin(code2) {
     if (code2 === null || !test(ALPHANUMERIC, code2)) {
       return nok(code2);
     }
     effects.consume(code2);
-    return body;
+    return ok;
+  }
+  function afterAt(code2) {
+    if (code2 === null || !test(LETTER, code2)) {
+      return nok(code2);
+    }
+    effects.consume(code2);
+    return ok;
   }
 }
 function test(regex, code2) {
@@ -6669,6 +6991,8 @@ function test(regex, code2) {
 // src/parser/index.ts
 var EMOJI_TYPE = "emoji";
 var SYNTAX_TYPE = "syntax";
+var LABEL_TYPE = "label";
+var ALT_TYPE = "alt";
 var MAX_DEPTH = 6;
 var TOKENS = {
   syntax: /* @__PURE__ */ new Set([
@@ -6710,6 +7034,17 @@ var TOKENS = {
     // Code.
     "codeTextSequence",
     "codeFencedFenceSequence",
+    // Maths. The padding is the space `$ x $` is written with, which is part of
+    // the markup rather than of the TeX.
+    "mathTextSequence",
+    "mathTextPadding",
+    "mathFlowFenceSequence",
+    // Whatever follows the opening `$$`, which nothing reads.
+    "mathFlowFenceMeta",
+    // Whatever follows a fenced block's language. The language itself is
+    // `language` -- something will want to read it -- but the rest of
+    // that line is markup like any other fence.
+    "codeFencedFenceMeta",
     // Character references.
     "characterReferenceMarker",
     "characterReferenceMarkerNumeric",
@@ -6726,19 +7061,39 @@ var TOKENS = {
   special: {
     codeFenced: "codeblock",
     codeIndented: "codeblock",
-    image: "inline-image"
+    image: "image",
+    // One range over the whole span, delimiters included, the way an image is
+    // one range over `![alt](url)`. What is inside is TeX: a display strips it
+    // whole and hands it to a renderer, and an input leaves it alone. Nothing
+    // is emitted for the content itself -- there is nothing markdown-shaped in
+    // there to style.
+    mathText: "math",
+    mathFlow: "math-block"
   },
   scope: {
-    emphasis: "italic",
-    strong: "bold",
+    // Identities: these carry CommonMark's own names, so what micromark calls
+    // a token and what a range is typed as are the same word.
+    emphasis: "emphasis",
+    strong: "strong",
     strikethrough: "strikethrough"
     // Headings are absent: their level is only known once the marker token
     // arrives, so they are emitted from emitHeading() instead.
   },
   content: {
-    mention: "mention-user",
+    mention: "mention",
     codeTextData: "code",
-    codeFlowValue: "pre"
+    codeFlowValue: "pre",
+    // The language a fenced block declares. Its own type rather than `syntax`
+    // because it is metadata something will want to read -- highlighting, at
+    // least -- and no formatter styles it, so it stays plain text in an input
+    // the way the rest of the fence line does not.
+    codeFencedFenceInfo: "language",
+    // The title after a destination -- `[a](b "title")`, on a link as much as on
+    // an image. Metadata for the same reasons the language above is: a display
+    // renderer removes it with the rest of the resource, and something that
+    // renders an image wants to read it. Left unstyled in an input, where it is
+    // text between two quotes.
+    resourceTitleString: "title"
     // TODO:
     // htmlFlow: 'html',
     // htmlText: 'html',
@@ -6775,19 +7130,31 @@ var EMOJI = {
     "autolinkProtocol",
     "autolinkEmail"
   ]),
-  exclude: /* @__PURE__ */ new Set(["bold", "italic", "strikethrough"]),
+  exclude: /* @__PURE__ */ new Set(["strong", "emphasis", "strikethrough"]),
   pattern: (0, import_emoji_regex.default)()
 };
-globalThis.__parse__micromark = function(markdown) {
+globalThis.__parse__micromark = function(markdown, options) {
   const bomLength = markdown.charCodeAt(0) === 65279 ? 1 : 0;
   if (bomLength > 0) {
     markdown = markdown.slice(bomLength);
   }
-  const extensions = [gfmAutolinkLiteral(), gfmStrikethrough(), mentions()];
+  const extensions = [];
+  if (options?.gfm === true) {
+    extensions.push(gfmAutolinkLiteral(), gfmStrikethrough());
+  }
+  if (options?.mention === true) {
+    extensions.push(mentions());
+  }
+  if (options?.math === true) {
+    extensions.push(math({ singleDollarTextMath: false }));
+  }
   const ranges = [];
   const openBlocks = [];
   const countedBlocks = [];
   let pendingHeading = null;
+  let openImages = 0;
+  let altDepth = 0;
+  let labelDepth = 0;
   const markers = [];
   const events = postprocess(
     parse({ extensions }).document().write(preprocess()(markdown, "utf-8", true))
@@ -6851,6 +7218,12 @@ globalThis.__parse__micromark = function(markdown) {
       return;
     }
     if (TOKENS.special[token.type]) {
+      if (token.type === "image") {
+        openImages++;
+        if (altDepth > 0) {
+          return;
+        }
+      }
       emit(token, TOKENS.special[token.type]);
       return;
     }
@@ -6858,6 +7231,23 @@ globalThis.__parse__micromark = function(markdown) {
       emit(token, SYNTAX_TYPE);
       return;
     }
+    if (token.type === "labelText") {
+      if (altDepth > 0) {
+        altDepth++;
+        return;
+      }
+      if (openImages > 0) {
+        emit(token, ALT_TYPE);
+        altDepth = 1;
+        return;
+      }
+      emit(token, LABEL_TYPE);
+      labelDepth++;
+      return;
+    }
+    if (altDepth > 0) {
+      return;
+    }
     if (TOKENS.scope[token.type]) {
       emit(token, TOKENS.scope[token.type]);
       return;
@@ -6871,11 +7261,26 @@ globalThis.__parse__micromark = function(markdown) {
       return;
     }
     if (TOKENS.link[token.type]) {
+      if (labelDepth > 0 && openImages === 0) {
+        return;
+      }
       emit(token, TOKENS.link[token.type]);
       return;
     }
   }
   function exit2(token) {
+    if (token.type === "labelText") {
+      if (altDepth > 0) {
+        altDepth--;
+      } else if (labelDepth > 0) {
+        labelDepth--;
+      }
+      return;
+    }
+    if (token.type === "image") {
+      openImages--;
+      return;
+    }
     if (!TOKENS.block[token.type]) {
       return;
     }
@@ -6964,7 +7369,7 @@ globalThis.__parse__micromark = function(markdown) {
   }
   function push2(start, end, type, depth) {
     if (start >= end) return;
-    const previous2 = ranges[ranges.length - 1];
+    const previous4 = ranges[ranges.length - 1];
     if (depth === void 0 && // Two containers opening on one line put their prefixes back to back.
     // Merging them would lose which prefix belongs to which container.
     type !== BLOCK_PREFIX && // Adjacent syntax belongs to whatever encloses it, and neighbors often sit in different
@@ -6973,8 +7378,8 @@ globalThis.__parse__micromark = function(markdown) {
     // the first one's container -- overlapping it without containing it or being contained by
     // it, which is not a tree and renders the shared characters once per range. Runs that do
     // share an enclosure, like `>>`, cost only an extra span.
-    type !== SYNTAX_TYPE && previous2 && previous2.type === type && previous2.start + previous2.length === start) {
-      previous2.length = end - previous2.start;
+    type !== SYNTAX_TYPE && previous4 && previous4.type === type && previous4.start + previous4.length === start) {
+      previous4.length = end - previous4.start;
       return;
     }
     const range = {
@@ -7025,6 +7430,9 @@ globalThis.__parse__micromark = function(markdown) {
     ranges.push(...result);
   }
 };
-return globalThis.__parse__micromark(markdown);
+return globalThis.__parse__micromark(markdown, { gfm: __marcusGfm, mention: __marcusMention, math: __marcusMath });
+};
+__parsers.set(key, parse);
+return parse;
 }
 //# sourceMappingURL=index.js.map