@uiw/react-md-editor 3.20.9 → 3.21.0

package/dist/mdeditor.js

@@ -17364,121 +17364,123 @@ __webpack_require__.r(__webpack_exports__);
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
-  "EditorContext": () => (/* reexport */ EditorContext),
-  "MarkdownUtil": () => (/* reexport */ markdownUtils_namespaceObject),
-  "TextAreaCommandOrchestrator": () => (/* reexport */ TextAreaCommandOrchestrator),
-  "TextAreaTextApi": () => (/* reexport */ TextAreaTextApi),
-  "bold": () => (/* reexport */ bold),
-  "checkedListCommand": () => (/* reexport */ checkedListCommand),
-  "code": () => (/* reexport */ code_code),
-  "codeBlock": () => (/* reexport */ codeBlock),
-  "codeEdit": () => (/* reexport */ codeEdit),
-  "codeLive": () => (/* reexport */ codeLive),
-  "codePreview": () => (/* reexport */ codePreview),
-  "commands": () => (/* reexport */ commands_namespaceObject),
-  "comment": () => (/* reexport */ commands_comment_comment),
+  EditorContext: () => (/* reexport */ EditorContext),
+  MarkdownUtil: () => (/* reexport */ markdownUtils_namespaceObject),
+  TextAreaCommandOrchestrator: () => (/* reexport */ TextAreaCommandOrchestrator),
+  TextAreaTextApi: () => (/* reexport */ TextAreaTextApi),
+  bold: () => (/* reexport */ bold),
+  checkedListCommand: () => (/* reexport */ checkedListCommand),
+  code: () => (/* reexport */ code_code),
+  codeBlock: () => (/* reexport */ codeBlock),
+  codeEdit: () => (/* reexport */ codeEdit),
+  codeLive: () => (/* reexport */ codeLive),
+  codePreview: () => (/* reexport */ codePreview),
+  commands: () => (/* reexport */ commands_namespaceObject),
+  comment: () => (/* reexport */ commands_comment_comment),
   "default": () => (/* binding */ src_0),
-  "divider": () => (/* reexport */ divider),
-  "fullscreen": () => (/* reexport */ fullscreen),
-  "getBreaksNeededForEmptyLineAfter": () => (/* reexport */ getBreaksNeededForEmptyLineAfter),
-  "getBreaksNeededForEmptyLineBefore": () => (/* reexport */ getBreaksNeededForEmptyLineBefore),
-  "getCommands": () => (/* reexport */ commands_getCommands),
-  "getExtraCommands": () => (/* reexport */ getExtraCommands),
-  "getStateFromTextArea": () => (/* reexport */ getStateFromTextArea),
-  "getSurroundingWord": () => (/* reexport */ getSurroundingWord),
-  "group": () => (/* reexport */ group),
-  "hr": () => (/* reexport */ hr),
-  "image": () => (/* reexport */ commands_image_image),
-  "italic": () => (/* reexport */ italic),
-  "link": () => (/* reexport */ commands_link_link),
-  "orderedListCommand": () => (/* reexport */ orderedListCommand),
-  "quote": () => (/* reexport */ quote),
-  "reducer": () => (/* reexport */ reducer),
-  "selectWord": () => (/* reexport */ selectWord),
-  "strikethrough": () => (/* reexport */ strikeThrough_strikethrough),
-  "title": () => (/* reexport */ title),
-  "title1": () => (/* reexport */ title1),
-  "title2": () => (/* reexport */ title2),
-  "title3": () => (/* reexport */ title3),
-  "title4": () => (/* reexport */ title4),
-  "title5": () => (/* reexport */ title5),
-  "title6": () => (/* reexport */ title6),
-  "unorderedListCommand": () => (/* reexport */ unorderedListCommand)
+  divider: () => (/* reexport */ divider),
+  fullscreen: () => (/* reexport */ fullscreen),
+  getBreaksNeededForEmptyLineAfter: () => (/* reexport */ getBreaksNeededForEmptyLineAfter),
+  getBreaksNeededForEmptyLineBefore: () => (/* reexport */ getBreaksNeededForEmptyLineBefore),
+  getCommands: () => (/* reexport */ commands_getCommands),
+  getExtraCommands: () => (/* reexport */ getExtraCommands),
+  getStateFromTextArea: () => (/* reexport */ getStateFromTextArea),
+  getSurroundingWord: () => (/* reexport */ getSurroundingWord),
+  group: () => (/* reexport */ group),
+  hr: () => (/* reexport */ hr),
+  image: () => (/* reexport */ commands_image_image),
+  insertAtLineStart: () => (/* reexport */ insertAtLineStart),
+  insertTextAtPosition: () => (/* reexport */ insertTextAtPosition),
+  italic: () => (/* reexport */ italic),
+  link: () => (/* reexport */ commands_link_link),
+  orderedListCommand: () => (/* reexport */ orderedListCommand),
+  quote: () => (/* reexport */ quote),
+  reducer: () => (/* reexport */ reducer),
+  selectWord: () => (/* reexport */ selectWord),
+  strikethrough: () => (/* reexport */ strikeThrough_strikethrough),
+  title: () => (/* reexport */ title),
+  title1: () => (/* reexport */ title1),
+  title2: () => (/* reexport */ title2),
+  title3: () => (/* reexport */ title3),
+  title4: () => (/* reexport */ title4),
+  title5: () => (/* reexport */ title5),
+  title6: () => (/* reexport */ title6),
+  unorderedListCommand: () => (/* reexport */ unorderedListCommand)
 });
 
 // NAMESPACE OBJECT: ../node_modules/react-markdown/node_modules/micromark/lib/constructs.js
 var constructs_namespaceObject = {};
 __webpack_require__.r(constructs_namespaceObject);
 __webpack_require__.d(constructs_namespaceObject, {
-  "attentionMarkers": () => (attentionMarkers),
-  "contentInitial": () => (contentInitial),
-  "disable": () => (disable),
-  "document": () => (constructs_document),
-  "flow": () => (constructs_flow),
-  "flowInitial": () => (flowInitial),
-  "insideSpan": () => (insideSpan),
-  "string": () => (constructs_string),
-  "text": () => (constructs_text)
+  attentionMarkers: () => (attentionMarkers),
+  contentInitial: () => (contentInitial),
+  disable: () => (disable),
+  document: () => (constructs_document),
+  flow: () => (constructs_flow),
+  flowInitial: () => (flowInitial),
+  insideSpan: () => (insideSpan),
+  string: () => (constructs_string),
+  text: () => (constructs_text)
 });
 
 // NAMESPACE OBJECT: ../node_modules/property-information/lib/util/types.js
 var types_namespaceObject = {};
 __webpack_require__.r(types_namespaceObject);
 __webpack_require__.d(types_namespaceObject, {
-  "boolean": () => (types_boolean),
-  "booleanish": () => (booleanish),
-  "commaOrSpaceSeparated": () => (commaOrSpaceSeparated),
-  "commaSeparated": () => (commaSeparated),
-  "number": () => (number),
-  "overloadedBoolean": () => (overloadedBoolean),
-  "spaceSeparated": () => (spaceSeparated)
+  boolean: () => (types_boolean),
+  booleanish: () => (booleanish),
+  commaOrSpaceSeparated: () => (commaOrSpaceSeparated),
+  commaSeparated: () => (commaSeparated),
+  number: () => (number),
+  overloadedBoolean: () => (overloadedBoolean),
+  spaceSeparated: () => (spaceSeparated)
 });
 
 // NAMESPACE OBJECT: ./src/utils/markdownUtils.ts
 var markdownUtils_namespaceObject = {};
 __webpack_require__.r(markdownUtils_namespaceObject);
 __webpack_require__.d(markdownUtils_namespaceObject, {
-  "getBreaksNeededForEmptyLineAfter": () => (getBreaksNeededForEmptyLineAfter),
-  "getBreaksNeededForEmptyLineBefore": () => (getBreaksNeededForEmptyLineBefore),
-  "getSurroundingWord": () => (getSurroundingWord),
-  "selectWord": () => (selectWord)
+  getBreaksNeededForEmptyLineAfter: () => (getBreaksNeededForEmptyLineAfter),
+  getBreaksNeededForEmptyLineBefore: () => (getBreaksNeededForEmptyLineBefore),
+  getSurroundingWord: () => (getSurroundingWord),
+  selectWord: () => (selectWord)
 });
 
 // NAMESPACE OBJECT: ./src/commands/index.ts
 var commands_namespaceObject = {};
 __webpack_require__.r(commands_namespaceObject);
 __webpack_require__.d(commands_namespaceObject, {
-  "TextAreaCommandOrchestrator": () => (TextAreaCommandOrchestrator),
-  "TextAreaTextApi": () => (TextAreaTextApi),
-  "bold": () => (bold),
-  "checkedListCommand": () => (checkedListCommand),
-  "code": () => (code_code),
-  "codeBlock": () => (codeBlock),
-  "codeEdit": () => (codeEdit),
-  "codeLive": () => (codeLive),
-  "codePreview": () => (codePreview),
-  "comment": () => (commands_comment_comment),
-  "divider": () => (divider),
-  "fullscreen": () => (fullscreen),
-  "getCommands": () => (commands_getCommands),
-  "getExtraCommands": () => (getExtraCommands),
-  "getStateFromTextArea": () => (getStateFromTextArea),
-  "group": () => (group),
-  "hr": () => (hr),
-  "image": () => (commands_image_image),
-  "italic": () => (italic),
-  "link": () => (commands_link_link),
-  "orderedListCommand": () => (orderedListCommand),
-  "quote": () => (quote),
-  "strikethrough": () => (strikeThrough_strikethrough),
-  "title": () => (title),
-  "title1": () => (title1),
-  "title2": () => (title2),
-  "title3": () => (title3),
-  "title4": () => (title4),
-  "title5": () => (title5),
-  "title6": () => (title6),
-  "unorderedListCommand": () => (unorderedListCommand)
+  TextAreaCommandOrchestrator: () => (TextAreaCommandOrchestrator),
+  TextAreaTextApi: () => (TextAreaTextApi),
+  bold: () => (bold),
+  checkedListCommand: () => (checkedListCommand),
+  code: () => (code_code),
+  codeBlock: () => (codeBlock),
+  codeEdit: () => (codeEdit),
+  codeLive: () => (codeLive),
+  codePreview: () => (codePreview),
+  comment: () => (commands_comment_comment),
+  divider: () => (divider),
+  fullscreen: () => (fullscreen),
+  getCommands: () => (commands_getCommands),
+  getExtraCommands: () => (getExtraCommands),
+  getStateFromTextArea: () => (getStateFromTextArea),
+  group: () => (group),
+  hr: () => (hr),
+  image: () => (commands_image_image),
+  italic: () => (italic),
+  link: () => (commands_link_link),
+  orderedListCommand: () => (orderedListCommand),
+  quote: () => (quote),
+  strikethrough: () => (strikeThrough_strikethrough),
+  title: () => (title),
+  title1: () => (title1),
+  title2: () => (title2),
+  title3: () => (title3),
+  title4: () => (title4),
+  title5: () => (title5),
+  title6: () => (title6),
+  unorderedListCommand: () => (unorderedListCommand)
 });
 
 ;// CONCATENATED MODULE: ../node_modules/@babel/runtime/helpers/esm/typeof.js
@@ -28019,7 +28021,10 @@ function defaultOnError(left, right) {
 
 
 
-/** @type {import('unified').Plugin<[Options?] | void[], string, Root>} */
+/**
+ * @this {import('unified').Processor}
+ * @type {import('unified').Plugin<[Options?] | void[], string, Root>}
+ */
 function remarkParse(options) {
   /** @type {import('unified').ParserFunction<Root>} */
   const parser = (doc) => {
@@ -28041,11 +28046,6 @@ function remarkParse(options) {
   Object.assign(this, {Parser: parser})
 }
 
-;// CONCATENATED MODULE: ../node_modules/react-markdown/node_modules/remark-parse/index.js
-
-
-/* harmony default export */ const remark_parse = (remarkParse);
-
 ;// CONCATENATED MODULE: ../node_modules/micromark-util-sanitize-uri/index.js
 
 
@@ -33333,7 +33333,7 @@ function ReactMarkdown(options) {
   }
 
   const processor = unified()
-    .use(remark_parse)
+    .use(remarkParse)
     .use(options.remarkPlugins || [])
     .use(lib, {
       ...options.remarkRehypeOptions,
@@ -33434,17 +33434,19 @@ ReactMarkdown.propTypes = {
 
 ;// CONCATENATED MODULE: ../node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js
 /**
- * @typedef {import('micromark-util-types').Extension} Extension
+ * @typedef {import('micromark-util-types').Code} Code
  * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord
- * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Event} Event
+ * @typedef {import('micromark-util-types').Extension} Extension
  * @typedef {import('micromark-util-types').Previous} Previous
  * @typedef {import('micromark-util-types').State} State
- * @typedef {import('micromark-util-types').Event} Event
- * @typedef {import('micromark-util-types').Code} Code
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
  */
 
-const www = {
-  tokenize: tokenizeWww,
+
+const wwwPrefix = {
+  tokenize: tokenizeWwwPrefix,
   partial: true
 }
 const domain = {
@@ -33455,610 +33457,925 @@ const syntax_path = {
   tokenize: tokenizePath,
   partial: true
 }
-const punctuation = {
-  tokenize: tokenizePunctuation,
+const trail = {
+  tokenize: tokenizeTrail,
   partial: true
 }
-const namedCharacterReference = {
-  tokenize: tokenizeNamedCharacterReference,
+const emailDomainDotTrail = {
+  tokenize: tokenizeEmailDomainDotTrail,
   partial: true
 }
 const wwwAutolink = {
   tokenize: tokenizeWwwAutolink,
   previous: previousWww
 }
-const httpAutolink = {
-  tokenize: tokenizeHttpAutolink,
-  previous: previousHttp
+const protocolAutolink = {
+  tokenize: tokenizeProtocolAutolink,
+  previous: previousProtocol
 }
 const emailAutolink = {
   tokenize: tokenizeEmailAutolink,
   previous: previousEmail
 }
-/** @type {ConstructRecord} */
 
+/** @type {ConstructRecord} */
 const syntax_text = {}
-/** @type {Extension} */
 
+// To do: next major: expose functions that yields extension.
+
+/**
+ * Extension for `micromark` that can be passed in `extensions` to enable GFM
+ * autolink literal syntax.
+ *
+ * @type {Extension}
+ */
 const gfmAutolinkLiteral = {
   text: syntax_text
 }
-let syntax_code = 48 // Add alphanumerics.
+let syntax_code = 48
 
+// Add alphanumerics.
 while (syntax_code < 123) {
   syntax_text[syntax_code] = emailAutolink
   syntax_code++
   if (syntax_code === 58) syntax_code = 65
   else if (syntax_code === 91) syntax_code = 97
 }
-
 syntax_text[43] = emailAutolink
 syntax_text[45] = emailAutolink
 syntax_text[46] = emailAutolink
 syntax_text[95] = emailAutolink
-syntax_text[72] = [emailAutolink, httpAutolink]
-syntax_text[104] = [emailAutolink, httpAutolink]
+syntax_text[72] = [emailAutolink, protocolAutolink]
+syntax_text[104] = [emailAutolink, protocolAutolink]
 syntax_text[87] = [emailAutolink, wwwAutolink]
 syntax_text[119] = [emailAutolink, wwwAutolink]
-/** @type {Tokenizer} */
 
+// To do: perform email autolink literals on events, afterwards.
+// That’s where `markdown-rs` and `cmark-gfm` perform it.
+// It should look for `@`, then for atext backwards, and then for a label
+// forwards.
+// To do: `mailto:`, `xmpp:` protocol as prefix.
+
+/**
+ * Email autolink literal.
+ *
+ * ```markdown
+ * > | a contact@example.org b
+ *       ^^^^^^^^^^^^^^^^^^^
+ * ```
+ *
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
 function tokenizeEmailAutolink(effects, ok, nok) {
   const self = this
+  /** @type {boolean | undefined} */
+  let dot
   /** @type {boolean} */
-
-  let hasDot
-  /** @type {boolean|undefined} */
-
-  let hasDigitInLastSegment
+  let data
   return start
-  /** @type {State} */
 
+  /**
+   * Start of email autolink literal.
+   *
+   * ```markdown
+   * > | a contact@example.org b
+   *       ^
+   * ```
+   *
+   * @type {State}
+   */
   function start(code) {
     if (
       !gfmAtext(code) ||
-      !previousEmail(self.previous) ||
+      !previousEmail.call(self, self.previous) ||
       previousUnbalanced(self.events)
     ) {
       return nok(code)
     }
-
     effects.enter('literalAutolink')
     effects.enter('literalAutolinkEmail')
     return atext(code)
   }
-  /** @type {State} */
 
+  /**
+   * In email atext.
+   *
+   * ```markdown
+   * > | a contact@example.org b
+   *       ^
+   * ```
+   *
+   * @type {State}
+   */
   function atext(code) {
     if (gfmAtext(code)) {
       effects.consume(code)
       return atext
     }
-
     if (code === 64) {
       effects.consume(code)
-      return label
+      return emailDomain
     }
-
     return nok(code)
   }
-  /** @type {State} */
 
-  function label(code) {
+  /**
+   * In email domain.
+   *
+   * The reference code is a bit overly complex as it handles the `@`, of which
+   * there may be just one.
+   * Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L318>
+   *
+   * ```markdown
+   * > | a contact@example.org b
+   *               ^
+   * ```
+   *
+   * @type {State}
+   */
+  function emailDomain(code) {
+    // Dot followed by alphanumerical (not `-` or `_`).
     if (code === 46) {
-      return effects.check(punctuation, done, dotContinuation)(code)
-    }
-
-    if (code === 45 || code === 95) {
-      return effects.check(punctuation, nok, dashOrUnderscoreContinuation)(code)
+      return effects.check(
+        emailDomainDotTrail,
+        emailDomainAfter,
+        emailDomainDot
+      )(code)
     }
 
-    if (asciiAlphanumeric(code)) {
-      if (!hasDigitInLastSegment && asciiDigit(code)) {
-        hasDigitInLastSegment = true
-      }
-
+    // Alphanumerical, `-`, and `_`.
+    if (code === 45 || code === 95 || asciiAlphanumeric(code)) {
+      data = true
       effects.consume(code)
-      return label
+      return emailDomain
     }
 
-    return done(code)
-  }
-  /** @type {State} */
+    // To do: `/` if xmpp.
 
-  function dotContinuation(code) {
-    effects.consume(code)
-    hasDot = true
-    hasDigitInLastSegment = undefined
-    return label
+    // Note: normally we’d truncate trailing punctuation from the link.
+    // However, email autolink literals cannot contain any of those markers,
+    // except for `.`, but that can only occur if it isn’t trailing.
+    // So we can ignore truncating!
+    return emailDomainAfter(code)
   }
-  /** @type {State} */
 
-  function dashOrUnderscoreContinuation(code) {
+  /**
+   * In email domain, on dot that is not a trail.
+   *
+   * ```markdown
+   * > | a contact@example.org b
+   *                      ^
+   * ```
+   *
+   * @type {State}
+   */
+  function emailDomainDot(code) {
     effects.consume(code)
-    return afterDashOrUnderscore
+    dot = true
+    return emailDomain
   }
-  /** @type {State} */
-
-  function afterDashOrUnderscore(code) {
-    if (code === 46) {
-      return effects.check(punctuation, nok, dotContinuation)(code)
-    }
-
-    return label(code)
-  }
-  /** @type {State} */
 
-  function done(code) {
-    if (hasDot && !hasDigitInLastSegment) {
+  /**
+   * After email domain.
+   *
+   * ```markdown
+   * > | a contact@example.org b
+   *                          ^
+   * ```
+   *
+   * @type {State}
+   */
+  function emailDomainAfter(code) {
+    // Domain must not be empty, must include a dot, and must end in alphabetical.
+    // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L332>.
+    if (data && dot && asciiAlpha(self.previous)) {
       effects.exit('literalAutolinkEmail')
       effects.exit('literalAutolink')
       return ok(code)
     }
-
     return nok(code)
   }
 }
-/** @type {Tokenizer} */
 
+/**
+ * `www` autolink literal.
+ *
+ * ```markdown
+ * > | a www.example.org b
+ *       ^^^^^^^^^^^^^^^
+ * ```
+ *
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
 function tokenizeWwwAutolink(effects, ok, nok) {
   const self = this
-  return start
-  /** @type {State} */
+  return wwwStart
 
-  function start(code) {
+  /**
+   * Start of www autolink literal.
+   *
+   * ```markdown
+   * > | www.example.com/a?b#c
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function wwwStart(code) {
     if (
       (code !== 87 && code !== 119) ||
-      !previousWww(self.previous) ||
+      !previousWww.call(self, self.previous) ||
       previousUnbalanced(self.events)
     ) {
       return nok(code)
     }
-
     effects.enter('literalAutolink')
-    effects.enter('literalAutolinkWww') // For `www.` we check instead of attempt, because when it matches, GH
-    // treats it as part of a domain (yes, it says a valid domain must come
-    // after `www.`, but that’s not how it’s implemented by them).
-
+    effects.enter('literalAutolinkWww')
+    // Note: we *check*, so we can discard the `www.` we parsed.
+    // If it worked, we consider it as a part of the domain.
     return effects.check(
-      www,
-      effects.attempt(domain, effects.attempt(syntax_path, done), nok),
+      wwwPrefix,
+      effects.attempt(domain, effects.attempt(syntax_path, wwwAfter), nok),
       nok
     )(code)
   }
-  /** @type {State} */
 
-  function done(code) {
+  /**
+   * After a www autolink literal.
+   *
+   * ```markdown
+   * > | www.example.com/a?b#c
+   *                          ^
+   * ```
+   *
+   * @type {State}
+   */
+  function wwwAfter(code) {
     effects.exit('literalAutolinkWww')
     effects.exit('literalAutolink')
     return ok(code)
   }
 }
-/** @type {Tokenizer} */
 
-function tokenizeHttpAutolink(effects, ok, nok) {
+/**
+ * Protocol autolink literal.
+ *
+ * ```markdown
+ * > | a https://example.org b
+ *       ^^^^^^^^^^^^^^^^^^^
+ * ```
+ *
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeProtocolAutolink(effects, ok, nok) {
   const self = this
-  return start
-  /** @type {State} */
+  let buffer = ''
+  let seen = false
+  return protocolStart
 
-  function start(code) {
+  /**
+   * Start of protocol autolink literal.
+   *
+   * ```markdown
+   * > | https://example.com/a?b#c
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function protocolStart(code) {
     if (
-      (code !== 72 && code !== 104) ||
-      !previousHttp(self.previous) ||
-      previousUnbalanced(self.events)
+      (code === 72 || code === 104) &&
+      previousProtocol.call(self, self.previous) &&
+      !previousUnbalanced(self.events)
     ) {
-      return nok(code)
-    }
-
-    effects.enter('literalAutolink')
-    effects.enter('literalAutolinkHttp')
-    effects.consume(code)
-    return t1
-  }
-  /** @type {State} */
-
-  function t1(code) {
-    if (code === 84 || code === 116) {
-      effects.consume(code)
-      return t2
-    }
-
-    return nok(code)
-  }
-  /** @type {State} */
-
-  function t2(code) {
-    if (code === 84 || code === 116) {
-      effects.consume(code)
-      return p
-    }
-
-    return nok(code)
-  }
-  /** @type {State} */
-
-  function p(code) {
-    if (code === 80 || code === 112) {
+      effects.enter('literalAutolink')
+      effects.enter('literalAutolinkHttp')
+      buffer += String.fromCodePoint(code)
       effects.consume(code)
-      return s
+      return protocolPrefixInside
     }
-
     return nok(code)
   }
-  /** @type {State} */
 
-  function s(code) {
-    if (code === 83 || code === 115) {
+  /**
+   * In protocol.
+   *
+   * ```markdown
+   * > | https://example.com/a?b#c
+   *     ^^^^^
+   * ```
+   *
+   * @type {State}
+   */
+  function protocolPrefixInside(code) {
+    // `5` is size of `https`
+    if (asciiAlpha(code) && buffer.length < 5) {
+      buffer += String.fromCodePoint(code)
       effects.consume(code)
-      return colon
+      return protocolPrefixInside
     }
-
-    return colon(code)
-  }
-  /** @type {State} */
-
-  function colon(code) {
     if (code === 58) {
-      effects.consume(code)
-      return slash1
-    }
-
-    return nok(code)
-  }
-  /** @type {State} */
-
-  function slash1(code) {
-    if (code === 47) {
-      effects.consume(code)
-      return slash2
+      const protocol = buffer.toLowerCase()
+      if (protocol === 'http' || protocol === 'https') {
+        effects.consume(code)
+        return protocolSlashesInside
+      }
     }
-
     return nok(code)
   }
-  /** @type {State} */
 
-  function slash2(code) {
+  /**
+   * In slashes.
+   *
+   * ```markdown
+   * > | https://example.com/a?b#c
+   *           ^^
+   * ```
+   *
+   * @type {State}
+   */
+  function protocolSlashesInside(code) {
     if (code === 47) {
       effects.consume(code)
-      return after
+      if (seen) {
+        return afterProtocol
+      }
+      seen = true
+      return protocolSlashesInside
     }
-
     return nok(code)
   }
-  /** @type {State} */
 
-  function after(code) {
+  /**
+   * After protocol, before domain.
+   *
+   * ```markdown
+   * > | https://example.com/a?b#c
+   *             ^
+   * ```
+   *
+   * @type {State}
+   */
+  function afterProtocol(code) {
+    // To do: this is different from `markdown-rs`:
+    // https://github.com/wooorm/markdown-rs/blob/b3a921c761309ae00a51fe348d8a43adbc54b518/src/construct/gfm_autolink_literal.rs#L172-L182
     return code === null ||
       asciiControl(code) ||
+      markdownLineEndingOrSpace(code) ||
       unicodeWhitespace(code) ||
       unicodePunctuation(code)
       ? nok(code)
-      : effects.attempt(domain, effects.attempt(syntax_path, done), nok)(code)
+      : effects.attempt(domain, effects.attempt(syntax_path, protocolAfter), nok)(code)
   }
-  /** @type {State} */
 
-  function done(code) {
+  /**
+   * After a protocol autolink literal.
+   *
+   * ```markdown
+   * > | https://example.com/a?b#c
+   *                              ^
+   * ```
+   *
+   * @type {State}
+   */
+  function protocolAfter(code) {
     effects.exit('literalAutolinkHttp')
     effects.exit('literalAutolink')
     return ok(code)
   }
 }
-/** @type {Tokenizer} */
-
-function tokenizeWww(effects, ok, nok) {
-  return start
-  /** @type {State} */
-
-  function start(code) {
-    effects.consume(code)
-    return w2
-  }
-  /** @type {State} */
-
-  function w2(code) {
-    if (code === 87 || code === 119) {
-      effects.consume(code)
-      return w3
-    }
 
-    return nok(code)
-  }
-  /** @type {State} */
+/**
+ * `www` prefix.
+ *
+ * ```markdown
+ * > | a www.example.org b
+ *       ^^^^
+ * ```
+ *
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeWwwPrefix(effects, ok, nok) {
+  let size = 0
+  return wwwPrefixInside
 
-  function w3(code) {
-    if (code === 87 || code === 119) {
+  /**
+   * In www prefix.
+   *
+   * ```markdown
+   * > | www.example.com
+   *     ^^^^
+   * ```
+   *
+   * @type {State}
+   */
+  function wwwPrefixInside(code) {
+    if ((code === 87 || code === 119) && size < 3) {
+      size++
       effects.consume(code)
-      return dot
+      return wwwPrefixInside
     }
-
-    return nok(code)
-  }
-  /** @type {State} */
-
-  function dot(code) {
-    if (code === 46) {
+    if (code === 46 && size === 3) {
       effects.consume(code)
-      return after
+      return wwwPrefixAfter
     }
-
     return nok(code)
   }
-  /** @type {State} */
 
-  function after(code) {
-    return code === null || markdownLineEnding(code) ? nok(code) : ok(code)
+  /**
+   * After www prefix.
+   *
+   * ```markdown
+   * > | www.example.com
+   *         ^
+   * ```
+   *
+   * @type {State}
+   */
+  function wwwPrefixAfter(code) {
+    // If there is *anything*, we can link.
+    return code === null ? nok(code) : ok(code)
   }
 }
-/** @type {Tokenizer} */
 
+/**
+ * Domain.
+ *
+ * ```markdown
+ * > | a https://example.org b
+ *               ^^^^^^^^^^^
+ * ```
+ *
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
 function tokenizeDomain(effects, ok, nok) {
-  /** @type {boolean|undefined} */
-  let hasUnderscoreInLastSegment
-  /** @type {boolean|undefined} */
-
-  let hasUnderscoreInLastLastSegment
-  return domain
-  /** @type {State} */
+  /** @type {boolean | undefined} */
+  let underscoreInLastSegment
+  /** @type {boolean | undefined} */
+  let underscoreInLastLastSegment
+  /** @type {boolean | undefined} */
+  let seen
+  return domainInside
 
-  function domain(code) {
-    if (code === 38) {
-      return effects.check(
-        namedCharacterReference,
-        done,
-        punctuationContinuation
-      )(code)
+  /**
+   * In domain.
+   *
+   * ```markdown
+   * > | https://example.com/a
+   *             ^^^^^^^^^^^
+   * ```
+   *
+   * @type {State}
+   */
+  function domainInside(code) {
+    // Check whether this marker, which is a trailing punctuation
+    // marker, optionally followed by more trailing markers, and then
+    // followed by an end.
+    if (code === 46 || code === 95) {
+      return effects.check(trail, domainAfter, domainAtPunctuation)(code)
     }
 
-    if (code === 46 || code === 95) {
-      return effects.check(punctuation, done, punctuationContinuation)(code)
-    } // GH documents that only alphanumerics (other than `-`, `.`, and `_`) can
+    // GH documents that only alphanumerics (other than `-`, `.`, and `_`) can
     // occur, which sounds like ASCII only, but they also support `www.點看.com`,
     // so that’s Unicode.
     // Instead of some new production for Unicode alphanumerics, markdown
     // already has that for Unicode punctuation and whitespace, so use those.
-
+    // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L12>.
     if (
       code === null ||
-      asciiControl(code) ||
+      markdownLineEndingOrSpace(code) ||
       unicodeWhitespace(code) ||
       (code !== 45 && unicodePunctuation(code))
     ) {
-      return done(code)
+      return domainAfter(code)
     }
-
+    seen = true
     effects.consume(code)
-    return domain
+    return domainInside
   }
-  /** @type {State} */
 
-  function punctuationContinuation(code) {
-    if (code === 46) {
-      hasUnderscoreInLastLastSegment = hasUnderscoreInLastSegment
-      hasUnderscoreInLastSegment = undefined
-      effects.consume(code)
-      return domain
+  /**
+   * In domain, at potential trailing punctuation, that was not trailing.
+   *
+   * ```markdown
+   * > | https://example.com
+   *                    ^
+   * ```
+   *
+   * @type {State}
+   */
+  function domainAtPunctuation(code) {
+    // There is an underscore in the last segment of the domain
+    if (code === 95) {
+      underscoreInLastSegment = true
+    }
+    // Otherwise, it’s a `.`: save the last segment underscore in the
+    // penultimate segment slot.
+    else {
+      underscoreInLastLastSegment = underscoreInLastSegment
+      underscoreInLastSegment = undefined
     }
-
-    if (code === 95) hasUnderscoreInLastSegment = true
     effects.consume(code)
-    return domain
+    return domainInside
   }
-  /** @type {State} */
 
-  function done(code) {
-    if (!hasUnderscoreInLastLastSegment && !hasUnderscoreInLastSegment) {
-      return ok(code)
+  /**
+   * After domain.
+   *
+   * ```markdown
+   * > | https://example.com/a
+   *                        ^
+   * ```
+   *
+   * @type {State} */
+  function domainAfter(code) {
+    // Note: that’s GH says a dot is needed, but it’s not true:
+    // <https://github.com/github/cmark-gfm/issues/279>
+    if (underscoreInLastLastSegment || underscoreInLastSegment || !seen) {
+      return nok(code)
     }
-
-    return nok(code)
+    return ok(code)
   }
 }
-/** @type {Tokenizer} */
 
+/**
+ * Path.
+ *
+ * ```markdown
+ * > | a https://example.org/stuff b
+ *                          ^^^^^^
+ * ```
+ *
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
 function tokenizePath(effects, ok) {
-  let balance = 0
-  return inPath
-  /** @type {State} */
-
-  function inPath(code) {
-    if (code === 38) {
-      return effects.check(
-        namedCharacterReference,
-        ok,
-        continuedPunctuation
-      )(code)
-    }
+  let sizeOpen = 0
+  let sizeClose = 0
+  return pathInside
 
+  /**
+   * In path.
+   *
+   * ```markdown
+   * > | https://example.com/a
+   *                        ^^
+   * ```
+   *
+   * @type {State}
+   */
+  function pathInside(code) {
     if (code === 40) {
-      balance++
+      sizeOpen++
+      effects.consume(code)
+      return pathInside
     }
 
-    if (code === 41) {
-      return effects.check(
-        punctuation,
-        parenAtPathEnd,
-        continuedPunctuation
-      )(code)
+    // To do: `markdown-rs` also needs this.
+    // If this is a paren, and there are less closings than openings,
+    // we don’t check for a trail.
+    if (code === 41 && sizeClose < sizeOpen) {
+      return pathAtPunctuation(code)
     }
 
-    if (pathEnd(code)) {
-      return ok(code)
+    // Check whether this trailing punctuation marker is optionally
+    // followed by more trailing markers, and then followed
+    // by an end.
+    if (
+      code === 33 ||
+      code === 34 ||
+      code === 38 ||
+      code === 39 ||
+      code === 41 ||
+      code === 42 ||
+      code === 44 ||
+      code === 46 ||
+      code === 58 ||
+      code === 59 ||
+      code === 60 ||
+      code === 63 ||
+      code === 93 ||
+      code === 95 ||
+      code === 126
+    ) {
+      return effects.check(trail, ok, pathAtPunctuation)(code)
     }
-
-    if (trailingPunctuation(code)) {
-      return effects.check(punctuation, ok, continuedPunctuation)(code)
+    if (
+      code === null ||
+      markdownLineEndingOrSpace(code) ||
+      unicodeWhitespace(code)
+    ) {
+      return ok(code)
     }
-
     effects.consume(code)
-    return inPath
+    return pathInside
   }
-  /** @type {State} */
 
-  function continuedPunctuation(code) {
+  /**
+   * In path, at potential trailing punctuation, that was not trailing.
+   *
+   * ```markdown
+   * > | https://example.com/a"b
+   *                          ^
+   * ```
+   *
+   * @type {State}
+   */
+  function pathAtPunctuation(code) {
+    // Count closing parens.
+    if (code === 41) {
+      sizeClose++
+    }
     effects.consume(code)
-    return inPath
-  }
-  /** @type {State} */
-
-  function parenAtPathEnd(code) {
-    balance--
-    return balance < 0 ? ok(code) : continuedPunctuation(code)
+    return pathInside
   }
 }
-/** @type {Tokenizer} */
-
-function tokenizeNamedCharacterReference(effects, ok, nok) {
-  return start
-  /** @type {State} */
 
-  function start(code) {
-    effects.consume(code)
-    return inside
-  }
-  /** @type {State} */
+/**
+ * Trail.
+ *
+ * This calls `ok` if this *is* the trail, followed by an end, which means
+ * the entire trail is not part of the link.
+ * It calls `nok` if this *is* part of the link.
+ *
+ * ```markdown
+ * > | https://example.com").
+ *                        ^^^
+ * ```
+ *
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeTrail(effects, ok, nok) {
+  return trail
 
-  function inside(code) {
-    if (asciiAlpha(code)) {
+  /**
+   * In trail of domain or path.
+   *
+   * ```markdown
+   * > | https://example.com").
+   *                        ^
+   * ```
+   *
+   * @type {State}
+   */
+  function trail(code) {
+    // Regular trailing punctuation.
+    if (
+      code === 33 ||
+      code === 34 ||
+      code === 39 ||
+      code === 41 ||
+      code === 42 ||
+      code === 44 ||
+      code === 46 ||
+      code === 58 ||
+      code === 59 ||
+      code === 63 ||
+      code === 95 ||
+      code === 126
+    ) {
       effects.consume(code)
-      return inside
+      return trail
     }
 
-    if (code === 59) {
+    // `&` followed by one or more alphabeticals and then a `;`, is
+    // as a whole considered as trailing punctuation.
+    // In all other cases, it is considered as continuation of the URL.
+    if (code === 38) {
       effects.consume(code)
-      return after
+      return trailCharRefStart
     }
 
+    // Needed because we allow literals after `[`, as we fix:
+    // <https://github.com/github/cmark-gfm/issues/278>.
+    // Check that it is not followed by `(` or `[`.
+    if (code === 93) {
+      effects.consume(code)
+      return trailBracketAfter
+    }
+    if (
+      // `<` is an end.
+      code === 60 ||
+      // So is whitespace.
+      code === null ||
+      markdownLineEndingOrSpace(code) ||
+      unicodeWhitespace(code)
+    ) {
+      return ok(code)
+    }
     return nok(code)
   }
-  /** @type {State} */
 
-  function after(code) {
-    // If the named character reference is followed by the end of the path, it’s
-    // not continued punctuation.
-    return pathEnd(code) ? ok(code) : nok(code)
+  /**
+   * In trail, after `]`.
+   *
+   * > 👉 **Note**: this deviates from `cmark-gfm` to fix a bug.
+   * > See end of <https://github.com/github/cmark-gfm/issues/278> for more.
+   *
+   * ```markdown
+   * > | https://example.com](
+   *                         ^
+   * ```
+   *
+   * @type {State}
+   */
+  function trailBracketAfter(code) {
+    // Whitespace or something that could start a resource or reference is the end.
+    // Switch back to trail otherwise.
+    if (
+      code === null ||
+      code === 40 ||
+      code === 91 ||
+      markdownLineEndingOrSpace(code) ||
+      unicodeWhitespace(code)
+    ) {
+      return ok(code)
+    }
+    return trail(code)
   }
-}
-/** @type {Tokenizer} */
-
-function tokenizePunctuation(effects, ok, nok) {
-  return start
-  /** @type {State} */
 
-  function start(code) {
-    effects.consume(code)
-    return after
+  /**
+   * In character-reference like trail, after `&`.
+   *
+   * ```markdown
+   * > | https://example.com&amp;).
+   *                         ^
+   * ```
+   *
+   * @type {State}
+   */
+  function trailCharRefStart(code) {
+    // When non-alpha, it’s not a trail.
+    return asciiAlpha(code) ? trailCharRefInside(code) : nok(code)
   }
-  /** @type {State} */
 
-  function after(code) {
-    // Check the next.
-    if (trailingPunctuation(code)) {
+  /**
+   * In character-reference like trail.
+   *
+   * ```markdown
+   * > | https://example.com&amp;).
+   *                         ^
+   * ```
+   *
+   * @type {State}
+   */
+  function trailCharRefInside(code) {
+    // Switch back to trail if this is well-formed.
+    if (code === 59) {
       effects.consume(code)
-      return after
-    } // If the punctuation marker is followed by the end of the path, it’s not
-    // continued punctuation.
+      return trail
+    }
+    if (asciiAlpha(code)) {
+      effects.consume(code)
+      return trailCharRefInside
+    }
 
-    return pathEnd(code) ? ok(code) : nok(code)
+    // It’s not a trail.
+    return nok(code)
   }
 }
-/**
- * @param {Code} code
- * @returns {boolean}
- */
 
-function trailingPunctuation(code) {
-  return (
-    code === 33 ||
-    code === 34 ||
-    code === 39 ||
-    code === 41 ||
-    code === 42 ||
-    code === 44 ||
-    code === 46 ||
-    code === 58 ||
-    code === 59 ||
-    code === 60 ||
-    code === 63 ||
-    code === 95 ||
-    code === 126
-  )
-}
 /**
- * @param {Code} code
- * @returns {boolean}
+ * Dot in email domain trail.
+ *
+ * This calls `ok` if this *is* the trail, followed by an end, which means
+ * the trail is not part of the link.
+ * It calls `nok` if this *is* part of the link.
+ *
+ * ```markdown
+ * > | contact@example.org.
+ *                        ^
+ * ```
+ *
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
  */
+function tokenizeEmailDomainDotTrail(effects, ok, nok) {
+  return start
 
-function pathEnd(code) {
-  return code === null || code === 60 || markdownLineEndingOrSpace(code)
-}
-/**
- * @param {Code} code
- * @returns {boolean}
- */
+  /**
+   * Dot.
+   *
+   * ```markdown
+   * > | contact@example.org.
+   *                    ^   ^
+   * ```
+   *
+   * @type {State}
+   */
+  function start(code) {
+    // Must be dot.
+    effects.consume(code)
+    return after
+  }
 
-function gfmAtext(code) {
-  return (
-    code === 43 ||
-    code === 45 ||
-    code === 46 ||
-    code === 95 ||
-    asciiAlphanumeric(code)
-  )
+  /**
+   * After dot.
+   *
+   * ```markdown
+   * > | contact@example.org.
+   *                     ^   ^
+   * ```
+   *
+   * @type {State}
+   */
+  function after(code) {
+    // Not a trail if alphanumeric.
+    return asciiAlphanumeric(code) ? nok(code) : ok(code)
+  }
 }
-/** @type {Previous} */
 
+/**
+ * See:
+ * <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L156>.
+ *
+ * @type {Previous}
+ */
 function previousWww(code) {
   return (
     code === null ||
     code === 40 ||
     code === 42 ||
     code === 95 ||
+    code === 91 ||
+    code === 93 ||
     code === 126 ||
     markdownLineEndingOrSpace(code)
   )
 }
-/** @type {Previous} */
 
-function previousHttp(code) {
-  return code === null || !asciiAlpha(code)
+/**
+ * See:
+ * <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L214>.
+ *
+ * @type {Previous}
+ */
+function previousProtocol(code) {
+  return !asciiAlpha(code)
 }
-/** @type {Previous} */
 
+/**
+ * @this {TokenizeContext}
+ * @type {Previous}
+ */
 function previousEmail(code) {
-  return code !== 47 && previousHttp(code)
+  // Do not allow a slash “inside” atext.
+  // The reference code is a bit weird, but that’s what it results in.
+  // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L307>.
+  // Other than slash, every preceding character is allowed.
+  return !(code === 47 || gfmAtext(code))
 }
+
 /**
- * @param {Array<Event>} events
+ * @param {Code} code
  * @returns {boolean}
  */
+function gfmAtext(code) {
+  return (
+    code === 43 ||
+    code === 45 ||
+    code === 46 ||
+    code === 95 ||
+    asciiAlphanumeric(code)
+  )
+}
 
+/**
+ * @param {Array<Event>} events
+ * @returns {boolean}
+ */
 function previousUnbalanced(events) {
   let index = events.length
   let result = false
-
   while (index--) {
     const token = events[index][1]
-
     if (
       (token.type === 'labelLink' || token.type === 'labelImage') &&
       !token._balanced
     ) {
       result = true
       break
-    } // @ts-expect-error If we’ve seen this token, and it was marked as not
-    // having any unbalanced bracket before it, we can exit.
+    }
 
+    // @ts-expect-error If we’ve seen this token, and it was marked as not
+    // having any unbalanced bracket before it, we can exit.
     if (token._gfmAutolinkLiteralWalkedInto) {
       result = false
       break
     }
   }
-
   if (events.length > 0 && !result) {
     // @ts-expect-error Mark the last token as “walked into” w/o finding
     // anything.
     events[events.length - 1][1]._gfmAutolinkLiteralWalkedInto = true
   }
-
   return result
 }
 
@@ -34772,607 +35089,1143 @@ function gfmStrikethrough(options) {
   }
 }
 
-;// CONCATENATED MODULE: ../node_modules/micromark-extension-gfm-table/lib/syntax.js
+;// CONCATENATED MODULE: ../node_modules/micromark-extension-gfm-table/lib/edit-map.js
 /**
- * @typedef {import('micromark-util-types').Extension} Extension
- * @typedef {import('micromark-util-types').Resolver} Resolver
- * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
- * @typedef {import('micromark-util-types').State} State
- * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').Event} Event
+ */
+
+// Port of `edit_map.rs` from `markdown-rs`.
+// This should move to `markdown-js` later.
+
+// Deal with several changes in events, batching them together.
+//
+// Preferably, changes should be kept to a minimum.
+// Sometimes, it’s needed to change the list of events, because parsing can be
+// messy, and it helps to expose a cleaner interface of events to the compiler
+// and other users.
+// It can also help to merge many adjacent similar events.
+// And, in other cases, it’s needed to parse subcontent: pass some events
+// through another tokenizer and inject the result.
+
+/**
+ * @typedef {[number, number, Array<Event>]} Change
+ * @typedef {[number, number, number]} Jump
  */
 
 /**
- * @typedef {'left'|'center'|'right'|'none'} Align
+ * Tracks a bunch of edits.
  */
+class EditMap {
+  /**
+   * Create a new edit map.
+   */
+  constructor() {
+    /**
+     * Record of changes.
+     *
+     * @type {Array<Change>}
+     */
+    this.map = []
+  }
 
+  /**
+   * Create an edit: a remove and/or add at a certain place.
+   *
+   * @param {number} index
+   * @param {number} remove
+   * @param {Array<Event>} add
+   * @returns {void}
+   */
+  add(index, remove, add) {
+    addImpl(this, index, remove, add)
+  }
+
+  // To do: not used here.
+  // /**
+  //  * Create an edit: but insert `add` before existing additions.
+  //  *
+  //  * @param {number} index
+  //  * @param {number} remove
+  //  * @param {Array<Event>} add
+  //  * @returns {void}
+  //  */
+  // addBefore(index, remove, add) {
+  //   addImpl(this, index, remove, add, true)
+  // }
 
+  /**
+   * Done, change the events.
+   *
+   * @param {Array<Event>} events
+   * @returns {void}
+   */
+  consume(events) {
+    this.map.sort((a, b) => a[0] - b[0])
 
-/** @type {Extension} */
-const gfmTable = {
-  flow: {
-    null: {
-      tokenize: tokenizeTable,
-      resolve: resolveTable
+    /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */
+    if (this.map.length === 0) {
+      return
     }
-  }
-}
-const nextPrefixedOrBlank = {
-  tokenize: tokenizeNextPrefixedOrBlank,
-  partial: true
-}
-/** @type {Resolver} */
 
-function resolveTable(events, context) {
-  let index = -1
-  /** @type {boolean|undefined} */
+    // To do: if links are added in events, like they are in `markdown-rs`,
+    // this is needed.
+    // // Calculate jumps: where items in the current list move to.
+    // /** @type {Array<Jump>} */
+    // const jumps = []
+    // let index = 0
+    // let addAcc = 0
+    // let removeAcc = 0
+    // while (index < this.map.length) {
+    //   const [at, remove, add] = this.map[index]
+    //   removeAcc += remove
+    //   addAcc += add.length
+    //   jumps.push([at, removeAcc, addAcc])
+    //   index += 1
+    // }
+    //
+    // . shiftLinks(events, jumps)
 
-  let inHead
-  /** @type {boolean|undefined} */
+    let index = this.map.length
+    /** @type {Array<Array<Event>>} */
+    const vecs = []
+    while (index > 0) {
+      index -= 1
+      vecs.push(events.slice(this.map[index][0] + this.map[index][1]))
+      // eslint-disable-next-line unicorn/no-array-push-push
+      vecs.push(this.map[index][2])
 
-  let inDelimiterRow
-  /** @type {boolean|undefined} */
+      // Truncate rest.
+      events.length = this.map[index][0]
+    }
+    vecs.push([...events])
+    events.length = 0
+    let slice = vecs.pop()
+    while (slice) {
+      events.push(...slice)
+      slice = vecs.pop()
+    }
 
-  let inRow
-  /** @type {number|undefined} */
+    // Truncate everything.
+    this.map.length = 0
+  }
+}
 
-  let contentStart
-  /** @type {number|undefined} */
+/**
+ * Create an edit.
+ *
+ * @param {EditMap} editMap
+ * @param {number} at
+ * @param {number} remove
+ * @param {Array<Event>} add
+ * @returns {void}
+ */
+function addImpl(editMap, at, remove, add) {
+  let index = 0
 
-  let contentEnd
-  /** @type {number|undefined} */
+  /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */
+  if (remove === 0 && add.length === 0) {
+    return
+  }
+  while (index < editMap.map.length) {
+    if (editMap.map[index][0] === at) {
+      editMap.map[index][1] += remove
 
-  let cellStart
-  /** @type {boolean|undefined} */
+      // To do: before not used.
+      // if (before) {
+      //   add.push(...editMap.map[index][2])
+      //   editMap.map[index][2] = add
+      // } else {
+      editMap.map[index][2].push(...add)
+      // }
 
-  let seenCellInRow
+      return
+    }
+    index += 1
+  }
+  editMap.map.push([at, remove, add])
+}
+
+// /**
+//  * Shift `previous` and `next` links according to `jumps`.
+//  *
+//  * This fixes links in case there are events removed or added between them.
+//  *
+//  * @param {Array<Event>} events
+//  * @param {Array<Jump>} jumps
+//  */
+// function shiftLinks(events, jumps) {
+//   let jumpIndex = 0
+//   let index = 0
+//   let add = 0
+//   let rm = 0
+
+//   while (index < events.length) {
+//     const rmCurr = rm
+
+//     while (jumpIndex < jumps.length && jumps[jumpIndex][0] <= index) {
+//       add = jumps[jumpIndex][2]
+//       rm = jumps[jumpIndex][1]
+//       jumpIndex += 1
+//     }
+
+//     // Ignore items that will be removed.
+//     if (rm > rmCurr) {
+//       index += rm - rmCurr
+//     } else {
+//       console.log('to do: links?', add, rmCurr)
+//       // ?
+//       // if let Some(link) = &events[index].link {
+//       //     if let Some(next) = link.next {
+//       //         events[next].link.as_mut().unwrap().previous = Some(index + add - rm);
+//       //         while jumpIndex < jumps.len() && jumps[jumpIndex].0 <= next {
+//       //             add = jumps[jumpIndex].2;
+//       //             rm = jumps[jumpIndex].1;
+//       //             jumpIndex += 1;
+//       //         }
+//       //         events[index].link.as_mut().unwrap().next = Some(next + add - rm);
+//       //         index = next;
+//       //         continue;
+//       //     }
+//       // }
+//       index += 1
+//     }
+//   }
+// }
+
+;// CONCATENATED MODULE: ../node_modules/micromark-extension-gfm-table/lib/infer.js
+/**
+ * @typedef {import('micromark-util-types').Event} Event
+ */
 
-  while (++index < events.length) {
-    const token = events[index][1]
+/**
+ * @typedef {'left' | 'center' | 'right' | 'none'} Align
+ */
 
-    if (inRow) {
-      if (token.type === 'temporaryTableCellContent') {
-        contentStart = contentStart || index
-        contentEnd = index
+/**
+ * Figure out the alignment of a GFM table.
+ *
+ * @param {Array<Event>} events
+ * @param {number} index
+ * @returns {Array<Align>}
+ */
+function gfmTableAlign(events, index) {
+  let inDelimiterRow = false
+  /** @type {Array<Align>} */
+  const align = []
+  while (index < events.length) {
+    const event = events[index]
+    if (inDelimiterRow) {
+      if (event[0] === 'enter') {
+        // Start of alignment value: set a new column.
+        // To do: `markdown-rs` uses `tableDelimiterCellValue`.
+        if (event[1].type === 'tableContent') {
+          align.push(
+            events[index + 1][1].type === 'tableDelimiterMarker'
+              ? 'left'
+              : 'none'
+          )
+        }
       }
-
-      if (
-        // Combine separate content parts into one.
-        (token.type === 'tableCellDivider' || token.type === 'tableRow') &&
-        contentEnd
-      ) {
-        const content = {
-          type: 'tableContent',
-          start: events[contentStart][1].start,
-          end: events[contentEnd][1].end
-        }
-        /** @type {Token} */
-
-        const text = {
-          type: 'chunkText',
-          start: content.start,
-          end: content.end,
-          // @ts-expect-error It’s fine.
-          contentType: 'text'
-        }
-        events.splice(
-          contentStart,
-          contentEnd - contentStart + 1,
-          ['enter', content, context],
-          ['enter', text, context],
-          ['exit', text, context],
-          ['exit', content, context]
-        )
-        index -= contentEnd - contentStart - 3
-        contentStart = undefined
-        contentEnd = undefined
+      // Exits:
+      // End of alignment value: change the column.
+      // To do: `markdown-rs` uses `tableDelimiterCellValue`.
+      else if (event[1].type === 'tableContent') {
+        if (events[index - 1][1].type === 'tableDelimiterMarker') {
+          const alignIndex = align.length - 1
+          align[alignIndex] = align[alignIndex] === 'left' ? 'center' : 'right'
+        }
+      }
+      // Done!
+      else if (event[1].type === 'tableDelimiterRow') {
+        break
       }
+    } else if (event[0] === 'enter' && event[1].type === 'tableDelimiterRow') {
+      inDelimiterRow = true
     }
+    index += 1
+  }
+  return align
+}
 
-    if (
-      events[index][0] === 'exit' &&
-      cellStart !== undefined &&
-      cellStart + (seenCellInRow ? 0 : 1) < index &&
-      (token.type === 'tableCellDivider' ||
-        (token.type === 'tableRow' &&
-          (cellStart + 3 < index ||
-            events[cellStart][1].type !== 'whitespace')))
-    ) {
-      const cell = {
-        type: inDelimiterRow
-          ? 'tableDelimiter'
-          : inHead
-          ? 'tableHeader'
-          : 'tableData',
-        start: events[cellStart][1].start,
-        end: events[index][1].end
-      }
-      events.splice(index + (token.type === 'tableCellDivider' ? 1 : 0), 0, [
-        'exit',
-        cell,
-        context
-      ])
-      events.splice(cellStart, 0, ['enter', cell, context])
-      index += 2
-      cellStart = index + 1
-      seenCellInRow = true
-    }
+;// CONCATENATED MODULE: ../node_modules/micromark-extension-gfm-table/lib/syntax.js
+/**
+ * @typedef {import('micromark-util-types').Event} Event
+ * @typedef {import('micromark-util-types').Extension} Extension
+ * @typedef {import('micromark-util-types').Point} Point
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ */
 
-    if (token.type === 'tableRow') {
-      inRow = events[index][0] === 'enter'
+/**
+ * @typedef {[number, number, number, number]} Range
+ *   Cell info.
+ *
+ * @typedef {0 | 1 | 2 | 3} RowKind
+ *   Where we are: `1` for head row, `2` for delimiter row, `3` for body row.
+ */
 
-      if (inRow) {
-        cellStart = index + 1
-        seenCellInRow = false
-      }
-    }
 
-    if (token.type === 'tableDelimiterRow') {
-      inDelimiterRow = events[index][0] === 'enter'
 
-      if (inDelimiterRow) {
-        cellStart = index + 1
-        seenCellInRow = false
-      }
-    }
 
-    if (token.type === 'tableHead') {
-      inHead = events[index][0] === 'enter'
+
+
+// To do: next major: expose functions.
+
+/**
+ * Extension for `micromark` that can be passed in `extensions` to enable GFM
+ * table syntax.
+ *
+ * @type {Extension}
+ */
+const gfmTable = {
+  flow: {
+    null: {
+      tokenize: tokenizeTable,
+      resolveAll: resolveTable
     }
   }
-
-  return events
 }
-/** @type {Tokenizer} */
 
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
 function tokenizeTable(effects, ok, nok) {
   const self = this
-  /** @type {Array<Align>} */
-
-  const align = []
-  let tableHeaderCount = 0
-  /** @type {boolean|undefined} */
-
-  let seenDelimiter
-  /** @type {boolean|undefined} */
-
-  let hasDash
+  let size = 0
+  let sizeB = 0
+  /** @type {boolean | undefined} */
+  let seen
   return start
-  /** @type {State} */
 
+  /**
+   * Start of a GFM table.
+   *
+   * If there is a valid table row or table head before, then we try to parse
+   * another row.
+   * Otherwise, we try to parse a head.
+   *
+   * ```markdown
+   * > | | a |
+   *     ^
+   *   | | - |
+   * > | | b |
+   *     ^
+   * ```
+   * @type {State}
+   */
   function start(code) {
-    // @ts-expect-error Custom.
-    effects.enter('table')._align = align
+    let index = self.events.length - 1
+    while (index > -1) {
+      const type = self.events[index][1].type
+      if (
+        type === 'lineEnding' ||
+        // Note: markdown-rs uses `whitespace` instead of `linePrefix`
+        type === 'linePrefix'
+      )
+        index--
+      else break
+    }
+    const tail = index > -1 ? self.events[index][1].type : null
+    const next =
+      tail === 'tableHead' || tail === 'tableRow' ? bodyRowStart : headRowBefore
+
+    // Don’t allow lazy body rows.
+    if (next === bodyRowStart && self.parser.lazy[self.now().line]) {
+      return nok(code)
+    }
+    return next(code)
+  }
+
+  /**
+   * Before table head row.
+   *
+   * ```markdown
+   * > | | a |
+   *     ^
+   *   | | - |
+   *   | | b |
+   * ```
+   *
+   * @type {State}
+   */
+  function headRowBefore(code) {
     effects.enter('tableHead')
-    effects.enter('tableRow') // If we start with a pipe, we open a cell marker.
+    effects.enter('tableRow')
+    return headRowStart(code)
+  }
 
+  /**
+   * Before table head row, after whitespace.
+   *
+   * ```markdown
+   * > | | a |
+   *     ^
+   *   | | - |
+   *   | | b |
+   * ```
+   *
+   * @type {State}
+   */
+  function headRowStart(code) {
     if (code === 124) {
-      return cellDividerHead(code)
+      return headRowBreak(code)
     }
 
-    tableHeaderCount++
-    effects.enter('temporaryTableCellContent') // Can’t be space or eols at the start of a construct, so we’re in a cell.
-
-    return inCellContentHead(code)
-  }
-  /** @type {State} */
+    // To do: micromark-js should let us parse our own whitespace in extensions,
+    // like `markdown-rs`:
+    //
+    // ```js
+    // // 4+ spaces.
+    // if (markdownSpace(code)) {
+    //   return nok(code)
+    // }
+    // ```
 
-  function cellDividerHead(code) {
-    effects.enter('tableCellDivider')
-    effects.consume(code)
-    effects.exit('tableCellDivider')
-    seenDelimiter = true
-    return cellBreakHead
+    seen = true
+    // Count the first character, that isn’t a pipe, double.
+    sizeB += 1
+    return headRowBreak(code)
   }
-  /** @type {State} */
 
-  function cellBreakHead(code) {
-    if (code === null || markdownLineEnding(code)) {
-      return atRowEndHead(code)
+  /**
+   * At break in table head row.
+   *
+   * ```markdown
+   * > | | a |
+   *     ^
+   *       ^
+   *         ^
+   *   | | - |
+   *   | | b |
+   * ```
+   *
+   * @type {State}
+   */
+  function headRowBreak(code) {
+    if (code === null) {
+      // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.
+      return nok(code)
     }
+    if (markdownLineEnding(code)) {
+      // If anything other than one pipe (ignoring whitespace) was used, it’s fine.
+      if (sizeB > 1) {
+        sizeB = 0
+        // To do: check if this works.
+        // Feel free to interrupt:
+        self.interrupt = true
+        effects.exit('tableRow')
+        effects.enter('lineEnding')
+        effects.consume(code)
+        effects.exit('lineEnding')
+        return headDelimiterStart
+      }
 
+      // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.
+      return nok(code)
+    }
     if (markdownSpace(code)) {
-      effects.enter('whitespace')
-      effects.consume(code)
-      return inWhitespaceHead
+      // To do: check if this is fine.
+      // effects.attempt(State::Next(StateName::GfmTableHeadRowBreak), State::Nok)
+      // State::Retry(space_or_tab(tokenizer))
+      return factorySpace(effects, headRowBreak, 'whitespace')(code)
     }
-
-    if (seenDelimiter) {
-      seenDelimiter = undefined
-      tableHeaderCount++
+    sizeB += 1
+    if (seen) {
+      seen = false
+      // Header cell count.
+      size += 1
     }
-
     if (code === 124) {
-      return cellDividerHead(code)
-    } // Anything else is cell content.
-
-    effects.enter('temporaryTableCellContent')
-    return inCellContentHead(code)
-  }
-  /** @type {State} */
-
-  function inWhitespaceHead(code) {
-    if (markdownSpace(code)) {
+      effects.enter('tableCellDivider')
       effects.consume(code)
-      return inWhitespaceHead
+      effects.exit('tableCellDivider')
+      // Whether a delimiter was seen.
+      seen = true
+      return headRowBreak
     }
 
-    effects.exit('whitespace')
-    return cellBreakHead(code)
+    // Anything else is cell data.
+    effects.enter('data')
+    return headRowData(code)
   }
-  /** @type {State} */
 
-  function inCellContentHead(code) {
-    // EOF, whitespace, pipe
+  /**
+   * In table head row data.
+   *
+   * ```markdown
+   * > | | a |
+   *       ^
+   *   | | - |
+   *   | | b |
+   * ```
+   *
+   * @type {State}
+   */
+  function headRowData(code) {
     if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {
-      effects.exit('temporaryTableCellContent')
-      return cellBreakHead(code)
+      effects.exit('data')
+      return headRowBreak(code)
     }
-
     effects.consume(code)
-    return code === 92 ? inCellContentEscapeHead : inCellContentHead
+    return code === 92 ? headRowEscape : headRowData
   }
-  /** @type {State} */
 
-  function inCellContentEscapeHead(code) {
+  /**
+   * In table head row escape.
+   *
+   * ```markdown
+   * > | | a\-b |
+   *         ^
+   *   | | ---- |
+   *   | | c    |
+   * ```
+   *
+   * @type {State}
+   */
+  function headRowEscape(code) {
     if (code === 92 || code === 124) {
       effects.consume(code)
-      return inCellContentHead
-    } // Anything else.
-
-    return inCellContentHead(code)
-  }
-  /** @type {State} */
-
-  function atRowEndHead(code) {
-    if (code === null) {
-      return nok(code)
+      return headRowData
     }
-
-    effects.exit('tableRow')
-    effects.exit('tableHead')
-    const originalInterrupt = self.interrupt
-    self.interrupt = true
-    return effects.attempt(
-      {
-        tokenize: tokenizeRowEnd,
-        partial: true
-      },
-      function (code) {
-        self.interrupt = originalInterrupt
-        effects.enter('tableDelimiterRow')
-        return atDelimiterRowBreak(code)
-      },
-      function (code) {
-        self.interrupt = originalInterrupt
-        return nok(code)
-      }
-    )(code)
+    return headRowData(code)
   }
-  /** @type {State} */
 
-  function atDelimiterRowBreak(code) {
-    if (code === null || markdownLineEnding(code)) {
-      return rowEndDelimiter(code)
-    }
+  /**
+   * Before delimiter row.
+   *
+   * ```markdown
+   *   | | a |
+   * > | | - |
+   *     ^
+   *   | | b |
+   * ```
+   *
+   * @type {State}
+   */
+  function headDelimiterStart(code) {
+    // Reset `interrupt`.
+    self.interrupt = false
 
+    // Note: in `markdown-rs`, we need to handle piercing here too.
+    if (self.parser.lazy[self.now().line]) {
+      return nok(code)
+    }
+    effects.enter('tableDelimiterRow')
+    // Track if we’ve seen a `:` or `|`.
+    seen = false
     if (markdownSpace(code)) {
-      effects.enter('whitespace')
-      effects.consume(code)
-      return inWhitespaceDelimiter
+      return factorySpace(
+        effects,
+        headDelimiterBefore,
+        'linePrefix',
+        self.parser.constructs.disable.null.includes('codeIndented')
+          ? undefined
+          : 4
+      )(code)
     }
+    return headDelimiterBefore(code)
+  }
 
-    if (code === 45) {
-      effects.enter('tableDelimiterFiller')
-      effects.consume(code)
-      hasDash = true
-      align.push('none')
-      return inFillerDelimiter
+  /**
+   * Before delimiter row, after optional whitespace.
+   *
+   * Reused when a `|` is found later, to parse another cell.
+   *
+   * ```markdown
+   *   | | a |
+   * > | | - |
+   *     ^
+   *   | | b |
+   * ```
+   *
+   * @type {State}
+   */
+  function headDelimiterBefore(code) {
+    if (code === 45 || code === 58) {
+      return headDelimiterValueBefore(code)
     }
-
-    if (code === 58) {
-      effects.enter('tableDelimiterAlignment')
-      effects.consume(code)
-      effects.exit('tableDelimiterAlignment')
-      align.push('left')
-      return afterLeftAlignment
-    } // If we start with a pipe, we open a cell marker.
-
     if (code === 124) {
+      seen = true
+      // If we start with a pipe, we open a cell marker.
       effects.enter('tableCellDivider')
       effects.consume(code)
       effects.exit('tableCellDivider')
-      return atDelimiterRowBreak
+      return headDelimiterCellBefore
     }
 
-    return nok(code)
+    // More whitespace / empty row not allowed at start.
+    return headDelimiterNok(code)
   }
-  /** @type {State} */
 
-  function inWhitespaceDelimiter(code) {
+  /**
+   * After `|`, before delimiter cell.
+   *
+   * ```markdown
+   *   | | a |
+   * > | | - |
+   *      ^
+   * ```
+   *
+   * @type {State}
+   */
+  function headDelimiterCellBefore(code) {
     if (markdownSpace(code)) {
-      effects.consume(code)
-      return inWhitespaceDelimiter
+      return factorySpace(effects, headDelimiterValueBefore, 'whitespace')(code)
     }
-
-    effects.exit('whitespace')
-    return atDelimiterRowBreak(code)
+    return headDelimiterValueBefore(code)
   }
-  /** @type {State} */
-
-  function inFillerDelimiter(code) {
-    if (code === 45) {
-      effects.consume(code)
-      return inFillerDelimiter
-    }
-
-    effects.exit('tableDelimiterFiller')
 
+  /**
+   * Before delimiter cell value.
+   *
+   * ```markdown
+   *   | | a |
+   * > | | - |
+   *       ^
+   * ```
+   *
+   * @type {State}
+   */
+  function headDelimiterValueBefore(code) {
+    // Align: left.
     if (code === 58) {
-      effects.enter('tableDelimiterAlignment')
+      sizeB += 1
+      seen = true
+      effects.enter('tableDelimiterMarker')
       effects.consume(code)
-      effects.exit('tableDelimiterAlignment')
-      align[align.length - 1] =
-        align[align.length - 1] === 'left' ? 'center' : 'right'
-      return afterRightAlignment
+      effects.exit('tableDelimiterMarker')
+      return headDelimiterLeftAlignmentAfter
     }
 
-    return atDelimiterRowBreak(code)
+    // Align: none.
+    if (code === 45) {
+      sizeB += 1
+      // To do: seems weird that this *isn’t* left aligned, but that state is used?
+      return headDelimiterLeftAlignmentAfter(code)
+    }
+    if (code === null || markdownLineEnding(code)) {
+      return headDelimiterCellAfter(code)
+    }
+    return headDelimiterNok(code)
   }
-  /** @type {State} */
 
-  function afterLeftAlignment(code) {
+  /**
+   * After delimiter cell left alignment marker.
+   *
+   * ```markdown
+   *   | | a  |
+   * > | | :- |
+   *        ^
+   * ```
+   *
+   * @type {State}
+   */
+  function headDelimiterLeftAlignmentAfter(code) {
     if (code === 45) {
       effects.enter('tableDelimiterFiller')
-      effects.consume(code)
-      hasDash = true
-      return inFillerDelimiter
-    } // Anything else is not ok.
+      return headDelimiterFiller(code)
+    }
 
-    return nok(code)
+    // Anything else is not ok after the left-align colon.
+    return headDelimiterNok(code)
   }
-  /** @type {State} */
-
-  function afterRightAlignment(code) {
-    if (code === null || markdownLineEnding(code)) {
-      return rowEndDelimiter(code)
-    }
 
-    if (markdownSpace(code)) {
-      effects.enter('whitespace')
+  /**
+   * In delimiter cell filler.
+   *
+   * ```markdown
+   *   | | a |
+   * > | | - |
+   *       ^
+   * ```
+   *
+   * @type {State}
+   */
+  function headDelimiterFiller(code) {
+    if (code === 45) {
       effects.consume(code)
-      return inWhitespaceDelimiter
-    } // `|`
+      return headDelimiterFiller
+    }
 
-    if (code === 124) {
-      effects.enter('tableCellDivider')
+    // Align is `center` if it was `left`, `right` otherwise.
+    if (code === 58) {
+      seen = true
+      effects.exit('tableDelimiterFiller')
+      effects.enter('tableDelimiterMarker')
       effects.consume(code)
-      effects.exit('tableCellDivider')
-      return atDelimiterRowBreak
+      effects.exit('tableDelimiterMarker')
+      return headDelimiterRightAlignmentAfter
     }
-
-    return nok(code)
+    effects.exit('tableDelimiterFiller')
+    return headDelimiterRightAlignmentAfter(code)
   }
-  /** @type {State} */
-
-  function rowEndDelimiter(code) {
-    effects.exit('tableDelimiterRow') // Exit if there was no dash at all, or if the header cell count is not the
-    // delimiter cell count.
 
-    if (!hasDash || tableHeaderCount !== align.length) {
-      return nok(code)
+  /**
+   * After delimiter cell right alignment marker.
+   *
+   * ```markdown
+   *   | |  a |
+   * > | | -: |
+   *         ^
+   * ```
+   *
+   * @type {State}
+   */
+  function headDelimiterRightAlignmentAfter(code) {
+    if (markdownSpace(code)) {
+      return factorySpace(effects, headDelimiterCellAfter, 'whitespace')(code)
     }
+    return headDelimiterCellAfter(code)
+  }
 
-    if (code === null) {
-      return tableClose(code)
+  /**
+   * After delimiter cell.
+   *
+   * ```markdown
+   *   | |  a |
+   * > | | -: |
+   *          ^
+   * ```
+   *
+   * @type {State}
+   */
+  function headDelimiterCellAfter(code) {
+    if (code === 124) {
+      return headDelimiterBefore(code)
     }
-
-    return effects.check(
-      nextPrefixedOrBlank,
-      tableClose,
-      effects.attempt(
-        {
-          tokenize: tokenizeRowEnd,
-          partial: true
-        },
-        factorySpace(effects, bodyStart, 'linePrefix', 4),
-        tableClose
-      )
-    )(code)
+    if (code === null || markdownLineEnding(code)) {
+      // Exit when:
+      // * there was no `:` or `|` at all (it’s a thematic break or setext
+      //   underline instead)
+      // * the header cell count is not the delimiter cell count
+      if (!seen || size !== sizeB) {
+        return headDelimiterNok(code)
+      }
+
+      // Note: in markdown-rs`, a reset is needed here.
+      effects.exit('tableDelimiterRow')
+      effects.exit('tableHead')
+      // To do: in `markdown-rs`, resolvers need to be registered manually.
+      // effects.register_resolver(ResolveName::GfmTable)
+      return ok(code)
+    }
+    return headDelimiterNok(code)
   }
-  /** @type {State} */
 
-  function tableClose(code) {
-    effects.exit('table')
-    return ok(code)
+  /**
+   * In delimiter row, at a disallowed byte.
+   *
+   * ```markdown
+   *   | | a |
+   * > | | x |
+   *       ^
+   * ```
+   *
+   * @type {State}
+   */
+  function headDelimiterNok(code) {
+    // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.
+    return nok(code)
   }
-  /** @type {State} */
 
-  function bodyStart(code) {
-    effects.enter('tableBody')
-    return rowStartBody(code)
+  /**
+   * Before table body row.
+   *
+   * ```markdown
+   *   | | a |
+   *   | | - |
+   * > | | b |
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function bodyRowStart(code) {
+    // Note: in `markdown-rs` we need to manually take care of a prefix,
+    // but in `micromark-js` that is done for us, so if we’re here, we’re
+    // never at whitespace.
+    effects.enter('tableRow')
+    return bodyRowBreak(code)
   }
-  /** @type {State} */
-
-  function rowStartBody(code) {
-    effects.enter('tableRow') // If we start with a pipe, we open a cell marker.
 
+  /**
+   * At break in table body row.
+   *
+   * ```markdown
+   *   | | a |
+   *   | | - |
+   * > | | b |
+   *     ^
+   *       ^
+   *         ^
+   * ```
+   *
+   * @type {State}
+   */
+  function bodyRowBreak(code) {
     if (code === 124) {
-      return cellDividerBody(code)
+      effects.enter('tableCellDivider')
+      effects.consume(code)
+      effects.exit('tableCellDivider')
+      return bodyRowBreak
     }
-
-    effects.enter('temporaryTableCellContent') // Can’t be space or eols at the start of a construct, so we’re in a cell.
-
-    return inCellContentBody(code)
-  }
-  /** @type {State} */
-
-  function cellDividerBody(code) {
-    effects.enter('tableCellDivider')
-    effects.consume(code)
-    effects.exit('tableCellDivider')
-    return cellBreakBody
-  }
-  /** @type {State} */
-
-  function cellBreakBody(code) {
     if (code === null || markdownLineEnding(code)) {
-      return atRowEndBody(code)
+      effects.exit('tableRow')
+      return ok(code)
     }
-
     if (markdownSpace(code)) {
-      effects.enter('whitespace')
-      effects.consume(code)
-      return inWhitespaceBody
-    } // `|`
-
-    if (code === 124) {
-      return cellDividerBody(code)
-    } // Anything else is cell content.
-
-    effects.enter('temporaryTableCellContent')
-    return inCellContentBody(code)
-  }
-  /** @type {State} */
-
-  function inWhitespaceBody(code) {
-    if (markdownSpace(code)) {
-      effects.consume(code)
-      return inWhitespaceBody
+      return factorySpace(effects, bodyRowBreak, 'whitespace')(code)
     }
 
-    effects.exit('whitespace')
-    return cellBreakBody(code)
+    // Anything else is cell content.
+    effects.enter('data')
+    return bodyRowData(code)
   }
-  /** @type {State} */
 
-  function inCellContentBody(code) {
-    // EOF, whitespace, pipe
+  /**
+   * In table body row data.
+   *
+   * ```markdown
+   *   | | a |
+   *   | | - |
+   * > | | b |
+   *       ^
+   * ```
+   *
+   * @type {State}
+   */
+  function bodyRowData(code) {
     if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {
-      effects.exit('temporaryTableCellContent')
-      return cellBreakBody(code)
+      effects.exit('data')
+      return bodyRowBreak(code)
     }
-
     effects.consume(code)
-    return code === 92 ? inCellContentEscapeBody : inCellContentBody
+    return code === 92 ? bodyRowEscape : bodyRowData
   }
-  /** @type {State} */
 
-  function inCellContentEscapeBody(code) {
+  /**
+   * In table body row escape.
+   *
+   * ```markdown
+   *   | | a    |
+   *   | | ---- |
+   * > | | b\-c |
+   *         ^
+   * ```
+   *
+   * @type {State}
+   */
+  function bodyRowEscape(code) {
     if (code === 92 || code === 124) {
       effects.consume(code)
-      return inCellContentBody
-    } // Anything else.
-
-    return inCellContentBody(code)
-  }
-  /** @type {State} */
-
-  function atRowEndBody(code) {
-    effects.exit('tableRow')
-
-    if (code === null) {
-      return tableBodyClose(code)
+      return bodyRowData
     }
-
-    return effects.check(
-      nextPrefixedOrBlank,
-      tableBodyClose,
-      effects.attempt(
-        {
-          tokenize: tokenizeRowEnd,
-          partial: true
-        },
-        factorySpace(effects, rowStartBody, 'linePrefix', 4),
-        tableBodyClose
-      )
-    )(code)
+    return bodyRowData(code)
   }
-  /** @type {State} */
-
-  function tableBodyClose(code) {
-    effects.exit('tableBody')
-    return tableClose(code)
-  }
-  /** @type {Tokenizer} */
+}
 
-  function tokenizeRowEnd(effects, ok, nok) {
-    return start
-    /** @type {State} */
+/** @type {Resolver} */
+// eslint-disable-next-line complexity
+function resolveTable(events, context) {
+  let index = -1
+  let inFirstCellAwaitingPipe = true
+  /** @type {RowKind} */
+  let rowKind = 0
+  /** @type {Range} */
+  let lastCell = [0, 0, 0, 0]
+  /** @type {Range} */
+  let cell = [0, 0, 0, 0]
+  let afterHeadAwaitingFirstBodyRow = false
+  let lastTableEnd = 0
+  /** @type {Token | undefined} */
+  let currentTable
+  /** @type {Token | undefined} */
+  let currentBody
+  /** @type {Token | undefined} */
+  let currentCell
+  const map = new EditMap()
+  while (++index < events.length) {
+    const event = events[index]
+    const token = event[1]
+    if (event[0] === 'enter') {
+      // Start of head.
+      if (token.type === 'tableHead') {
+        afterHeadAwaitingFirstBodyRow = false
 
-    function start(code) {
-      effects.enter('lineEnding')
-      effects.consume(code)
-      effects.exit('lineEnding')
-      return factorySpace(effects, prefixed, 'linePrefix')
-    }
-    /** @type {State} */
+        // Inject previous (body end and) table end.
+        if (lastTableEnd !== 0) {
+          flushTableEnd(map, context, lastTableEnd, currentTable, currentBody)
+          currentBody = undefined
+          lastTableEnd = 0
+        }
 
-    function prefixed(code) {
-      // Blank or interrupting line.
-      if (
-        self.parser.lazy[self.now().line] ||
-        code === null ||
-        markdownLineEnding(code)
+        // Inject table start.
+        currentTable = {
+          type: 'table',
+          start: Object.assign({}, token.start),
+          // Note: correct end is set later.
+          end: Object.assign({}, token.end)
+        }
+        map.add(index, 0, [['enter', currentTable, context]])
+      } else if (
+        token.type === 'tableRow' ||
+        token.type === 'tableDelimiterRow'
       ) {
-        return nok(code)
+        inFirstCellAwaitingPipe = true
+        currentCell = undefined
+        lastCell = [0, 0, 0, 0]
+        cell = [0, index + 1, 0, 0]
+
+        // Inject table body start.
+        if (afterHeadAwaitingFirstBodyRow) {
+          afterHeadAwaitingFirstBodyRow = false
+          currentBody = {
+            type: 'tableBody',
+            start: Object.assign({}, token.start),
+            // Note: correct end is set later.
+            end: Object.assign({}, token.end)
+          }
+          map.add(index, 0, [['enter', currentBody, context]])
+        }
+        rowKind = token.type === 'tableDelimiterRow' ? 2 : currentBody ? 3 : 1
       }
-
-      const tail = self.events[self.events.length - 1] // Indented code can interrupt delimiter and body rows.
-
-      if (
-        !self.parser.constructs.disable.null.includes('codeIndented') &&
-        tail &&
-        tail[1].type === 'linePrefix' &&
-        tail[2].sliceSerialize(tail[1], true).length >= 4
+      // Cell data.
+      else if (
+        rowKind &&
+        (token.type === 'data' ||
+          token.type === 'tableDelimiterMarker' ||
+          token.type === 'tableDelimiterFiller')
       ) {
-        return nok(code)
+        inFirstCellAwaitingPipe = false
+
+        // First value in cell.
+        if (cell[2] === 0) {
+          if (lastCell[1] !== 0) {
+            cell[0] = cell[1]
+            currentCell = flushCell(
+              map,
+              context,
+              lastCell,
+              rowKind,
+              undefined,
+              currentCell
+            )
+            lastCell = [0, 0, 0, 0]
+          }
+          cell[2] = index
+        }
+      } else if (token.type === 'tableCellDivider') {
+        if (inFirstCellAwaitingPipe) {
+          inFirstCellAwaitingPipe = false
+        } else {
+          if (lastCell[1] !== 0) {
+            cell[0] = cell[1]
+            currentCell = flushCell(
+              map,
+              context,
+              lastCell,
+              rowKind,
+              undefined,
+              currentCell
+            )
+          }
+          lastCell = cell
+          cell = [lastCell[1], index, 0, 0]
+        }
       }
+    }
+    // Exit events.
+    else if (token.type === 'tableHead') {
+      afterHeadAwaitingFirstBodyRow = true
+      lastTableEnd = index
+    } else if (
+      token.type === 'tableRow' ||
+      token.type === 'tableDelimiterRow'
+    ) {
+      lastTableEnd = index
+      if (lastCell[1] !== 0) {
+        cell[0] = cell[1]
+        currentCell = flushCell(
+          map,
+          context,
+          lastCell,
+          rowKind,
+          index,
+          currentCell
+        )
+      } else if (cell[1] !== 0) {
+        currentCell = flushCell(map, context, cell, rowKind, index, currentCell)
+      }
+      rowKind = 0
+    } else if (
+      rowKind &&
+      (token.type === 'data' ||
+        token.type === 'tableDelimiterMarker' ||
+        token.type === 'tableDelimiterFiller')
+    ) {
+      cell[3] = index
+    }
+  }
+  if (lastTableEnd !== 0) {
+    flushTableEnd(map, context, lastTableEnd, currentTable, currentBody)
+  }
+  map.consume(context.events)
 
-      self._gfmTableDynamicInterruptHack = true
-      return effects.check(
-        self.parser.constructs.flow,
-        function (code) {
-          self._gfmTableDynamicInterruptHack = false
-          return nok(code)
-        },
-        function (code) {
-          self._gfmTableDynamicInterruptHack = false
-          return ok(code)
-        }
-      )(code)
+  // To do: move this into `html`, when events are exposed there.
+  // That’s what `markdown-rs` does.
+  // That needs updates to `mdast-util-gfm-table`.
+  index = -1
+  while (++index < context.events.length) {
+    const event = context.events[index]
+    if (event[0] === 'enter' && event[1].type === 'table') {
+      // @ts-expect-error: custom field.
+      event[1]._align = gfmTableAlign(context.events, index)
     }
   }
+  return events
 }
-/** @type {Tokenizer} */
-
-function tokenizeNextPrefixedOrBlank(effects, ok, nok) {
-  let size = 0
-  return start
-  /** @type {State} */
-
-  function start(code) {
-    // This is a check, so we don’t care about tokens, but we open a bogus one
-    // so we’re valid.
-    effects.enter('check') // EOL.
 
-    effects.consume(code)
-    return whitespace
+/// Generate a cell.
+/**
+ *
+ * @param {EditMap} map
+ * @param {TokenizeContext} context
+ * @param {Range} range
+ * @param {RowKind} rowKind
+ * @param {number | undefined} rowEnd
+ * @param {Token | undefined} previousCell
+ * @returns {Token | undefined}
+ */
+// eslint-disable-next-line max-params
+function flushCell(map, context, range, rowKind, rowEnd, previousCell) {
+  // `markdown-rs` uses:
+  // rowKind === 2 ? 'tableDelimiterCell' : 'tableCell'
+  const groupName =
+    rowKind === 1
+      ? 'tableHeader'
+      : rowKind === 2
+      ? 'tableDelimiter'
+      : 'tableData'
+  // `markdown-rs` uses:
+  // rowKind === 2 ? 'tableDelimiterCellValue' : 'tableCellText'
+  const valueName = 'tableContent'
+
+  // Insert an exit for the previous cell, if there is one.
+  //
+  // ```markdown
+  // > | | aa | bb | cc |
+  //          ^-- exit
+  //           ^^^^-- this cell
+  // ```
+  if (range[0] !== 0) {
+    previousCell.end = Object.assign({}, getPoint(context.events, range[0]))
+    map.add(range[0], 0, [['exit', previousCell, context]])
   }
-  /** @type {State} */
 
-  function whitespace(code) {
-    if (code === -1 || code === 32) {
-      effects.consume(code)
-      size++
-      return size === 4 ? ok : whitespace
-    } // EOF or whitespace
+  // Insert enter of this cell.
+  //
+  // ```markdown
+  // > | | aa | bb | cc |
+  //           ^-- enter
+  //           ^^^^-- this cell
+  // ```
+  const now = getPoint(context.events, range[1])
+  previousCell = {
+    type: groupName,
+    start: Object.assign({}, now),
+    // Note: correct end is set later.
+    end: Object.assign({}, now)
+  }
+  map.add(range[1], 0, [['enter', previousCell, context]])
 
-    if (code === null || markdownLineEndingOrSpace(code)) {
-      return ok(code)
-    } // Anything else.
+  // Insert text start at first data start and end at last data end, and
+  // remove events between.
+  //
+  // ```markdown
+  // > | | aa | bb | cc |
+  //            ^-- enter
+  //             ^-- exit
+  //           ^^^^-- this cell
+  // ```
+  if (range[2] !== 0) {
+    const relatedStart = getPoint(context.events, range[2])
+    const relatedEnd = getPoint(context.events, range[3])
+    const valueToken = {
+      type: valueName,
+      start: Object.assign({}, relatedStart),
+      end: Object.assign({}, relatedEnd)
+    }
+    map.add(range[2], 0, [['enter', valueToken, context]])
+    if (rowKind !== 2) {
+      // Fix positional info on remaining events
+      const start = context.events[range[2]]
+      const end = context.events[range[3]]
+      start[1].end = Object.assign({}, end[1].end)
+      start[1].type = 'chunkText'
+      // @ts-expect-error It’s fine.
+      start[1].contentType = 'text'
+
+      // Remove if needed.
+      if (range[3] > range[2] + 1) {
+        const a = range[2] + 1
+        const b = range[3] - range[2] - 1
+        map.add(a, b, [])
+      }
+    }
+    map.add(range[3] + 1, 0, [['exit', valueToken, context]])
+  }
+
+  // Insert an exit for the last cell, if at the row end.
+  //
+  // ```markdown
+  // > | | aa | bb | cc |
+  //                    ^-- exit
+  //               ^^^^^^-- this cell (the last one contains two “between” parts)
+  // ```
+  if (rowEnd !== undefined) {
+    previousCell.end = Object.assign({}, getPoint(context.events, rowEnd))
+    map.add(rowEnd, 0, [['exit', previousCell, context]])
+    previousCell = undefined
+  }
+  return previousCell
+}
 
-    return nok(code)
+/**
+ * Generate table end (and table body end).
+ *
+ * @param {EditMap} map
+ * @param {TokenizeContext} context
+ * @param {number} index
+ * @param {Token} table
+ * @param {Token | undefined} tableBody
+ */
+// eslint-disable-next-line max-params
+function flushTableEnd(map, context, index, table, tableBody) {
+  /** @type {Array<Event>} */
+  const exits = []
+  const related = getPoint(context.events, index)
+  if (tableBody) {
+    tableBody.end = Object.assign({}, related)
+    exits.push(['exit', tableBody, context])
   }
+  table.end = Object.assign({}, related)
+  exits.push(['exit', table, context])
+  map.add(index + 1, 0, exits)
+}
+
+/**
+ * @param {Array<Event>} events
+ * @param {number} index
+ * @returns {readonly Point}
+ */
+function getPoint(events, index) {
+  const event = events[index]
+  const side = event[0] === 'enter' ? 'start' : 'end'
+  return event[1][side]
 }
 
 ;// CONCATENATED MODULE: ../node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js
@@ -35542,10 +36395,10 @@ function spaceThenNonSpace(effects, ok, nok) {
 
 ;// CONCATENATED MODULE: ../node_modules/micromark-extension-gfm/index.js
 /**
+ * @typedef {import('micromark-extension-gfm-footnote').HtmlOptions} HtmlOptions
+ * @typedef {import('micromark-extension-gfm-strikethrough').Options} Options
  * @typedef {import('micromark-util-types').Extension} Extension
  * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension
- * @typedef {import('micromark-extension-gfm-strikethrough').Options} Options
- * @typedef {import('micromark-extension-gfm-footnote').HtmlOptions} HtmlOptions
  */
 
 
@@ -35557,10 +36410,15 @@ function spaceThenNonSpace(effects, ok, nok) {
 
 
 /**
- * Support GFM or markdown on github.com.
+ * Create an extension for `micromark` to enable GFM syntax.
  *
- * @param {Options} [options]
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ *
+ *   Passed to `micromark-extens-gfm-strikethrough`.
  * @returns {Extension}
+ *   Extension for `micromark` that can be passed in `extensions` to enable GFM
+ *   syntax.
  */
 function gfm(options) {
   return combineExtensions([
@@ -35573,10 +36431,15 @@ function gfm(options) {
 }
 
 /**
- * Support to compile GFM to HTML.
+ * Create an extension for `micromark` to support GFM when serializing to HTML.
+ *
+ * @param {HtmlOptions | null | undefined} [options]
+ *   Configuration.
  *
- * @param {HtmlOptions} [options]
+ *   Passed to `micromark-extens-gfm-footnote`.
  * @returns {HtmlExtension}
+ *   Extension for `micromark` that can be passed in `htmlExtensions` to
+ *   support GFM when serializing to HTML.
  */
 function gfmHtml(options) {
   return combineHtmlExtensions([
@@ -73337,7 +74200,7 @@ var commands_getCommands=function getCommands(){return[bold,italic,strikeThrough
    */_createClass(TextAreaTextApi,[{key:"replaceSelection",value:function replaceSelection(text){insertTextAtPosition(this.textArea,text);return getStateFromTextArea(this.textArea);}/**
    * Selects the specified text range
    * @param selection
-   */},{key:"setSelectionRange",value:function setSelectionRange(selection){this.textArea.focus();this.textArea.selectionStart=selection.start;this.textArea.selectionEnd=selection.end;return getStateFromTextArea(this.textArea);}}]);return TextAreaTextApi;}();var TextAreaCommandOrchestrator=/*#__PURE__*/function(){function TextAreaCommandOrchestrator(textArea){_classCallCheck(this,TextAreaCommandOrchestrator);this.textArea=void 0;this.textApi=void 0;this.textArea=textArea;this.textApi=new TextAreaTextApi(textArea);}_createClass(TextAreaCommandOrchestrator,[{key:"getState",value:function getState(){if(!this.textArea)return false;return getStateFromTextArea(this.textArea);}},{key:"executeCommand",value:function executeCommand(command,dispatch,state,shortcuts){command.execute&&command.execute(_objectSpread2({command:command},getStateFromTextArea(this.textArea)),this.textApi,dispatch,state,shortcuts);}}]);return TextAreaCommandOrchestrator;}();
+   */},{key:"setSelectionRange",value:function setSelectionRange(selection){this.textArea.focus();this.textArea.selectionStart=selection.start;this.textArea.selectionEnd=selection.end;return getStateFromTextArea(this.textArea);}}]);return TextAreaTextApi;}();var TextAreaCommandOrchestrator=/*#__PURE__*/function(){function TextAreaCommandOrchestrator(textArea){_classCallCheck(this,TextAreaCommandOrchestrator);this.textArea=void 0;this.textApi=void 0;this.textArea=textArea;this.textApi=new TextAreaTextApi(textArea);}_createClass(TextAreaCommandOrchestrator,[{key:"getState",value:function getState(){if(!this.textArea)return false;return getStateFromTextArea(this.textArea);}},{key:"executeCommand",value:function executeCommand(command,dispatch,state,shortcuts){console.log('state:',state);command.execute&&command.execute(_objectSpread2({command:command},getStateFromTextArea(this.textArea)),this.textApi,dispatch,state,shortcuts);}}]);return TextAreaCommandOrchestrator;}();
 ;// CONCATENATED MODULE: ./src/components/TextArea/handleKeyDown.tsx
 /**
  * - `13` - `Enter`
@@ -73351,8 +74214,8 @@ var commands_getCommands=function getCommands(){return[bold,italic,strikeThrough
 // extracted by mini-css-extract-plugin
 /* harmony default export */ const TextArea = ({});
 ;// CONCATENATED MODULE: ./src/components/TextArea/Textarea.tsx
-var Textarea_excluded=["prefixCls","onChange"];function Textarea(props){var prefixCls=props.prefixCls,_onChange=props.onChange,other=_objectWithoutProperties(props,Textarea_excluded);var _useContext=(0,external_root_React_commonjs2_react_commonjs_react_amd_react_.useContext)(EditorContext),markdown=_useContext.markdown,commands=_useContext.commands,fullscreen=_useContext.fullscreen,preview=_useContext.preview,highlightEnable=_useContext.highlightEnable,extraCommands=_useContext.extraCommands,tabSize=_useContext.tabSize,defaultTabEnable=_useContext.defaultTabEnable,dispatch=_useContext.dispatch;var textRef=external_root_React_commonjs2_react_commonjs_react_amd_react_default().useRef(null);var executeRef=external_root_React_commonjs2_react_commonjs_react_amd_react_default().useRef();var statesRef=external_root_React_commonjs2_react_commonjs_react_amd_react_default().useRef({fullscreen:fullscreen,preview:preview});(0,external_root_React_commonjs2_react_commonjs_react_amd_react_.useEffect)(function(){statesRef.current={fullscreen:fullscreen,preview:preview,highlightEnable:highlightEnable};},[fullscreen,preview,highlightEnable]);(0,external_root_React_commonjs2_react_commonjs_react_amd_react_.useEffect)(function(){if(textRef.current&&dispatch){var commandOrchestrator=new TextAreaCommandOrchestrator(textRef.current);executeRef.current=commandOrchestrator;dispatch({textarea:textRef.current,commandOrchestrator:commandOrchestrator});}// eslint-disable-next-line react-hooks/exhaustive-deps
-},[]);var onKeyDown=function onKeyDown(e){handleKeyDown(e,tabSize,defaultTabEnable);shortcutsHandle(e,[].concat(_toConsumableArray(commands||[]),_toConsumableArray(extraCommands||[])),executeRef.current,dispatch,statesRef.current);};(0,external_root_React_commonjs2_react_commonjs_react_amd_react_.useEffect)(function(){if(textRef.current){textRef.current.addEventListener('keydown',onKeyDown);}return function(){if(textRef.current){// eslint-disable-next-line react-hooks/exhaustive-deps
+var Textarea_excluded=["prefixCls","onChange"],_excluded2=["markdown","commands","fullscreen","preview","highlightEnable","extraCommands","tabSize","defaultTabEnable","dispatch"];function Textarea(props){var prefixCls=props.prefixCls,_onChange=props.onChange,other=_objectWithoutProperties(props,Textarea_excluded);var _useContext=(0,external_root_React_commonjs2_react_commonjs_react_amd_react_.useContext)(EditorContext),markdown=_useContext.markdown,commands=_useContext.commands,fullscreen=_useContext.fullscreen,preview=_useContext.preview,highlightEnable=_useContext.highlightEnable,extraCommands=_useContext.extraCommands,tabSize=_useContext.tabSize,defaultTabEnable=_useContext.defaultTabEnable,dispatch=_useContext.dispatch,otherStore=_objectWithoutProperties(_useContext,_excluded2);var textRef=external_root_React_commonjs2_react_commonjs_react_amd_react_default().useRef(null);var executeRef=external_root_React_commonjs2_react_commonjs_react_amd_react_default().useRef();var statesRef=external_root_React_commonjs2_react_commonjs_react_amd_react_default().useRef({fullscreen:fullscreen,preview:preview});(0,external_root_React_commonjs2_react_commonjs_react_amd_react_.useEffect)(function(){statesRef.current={fullscreen:fullscreen,preview:preview,highlightEnable:highlightEnable};},[fullscreen,preview,highlightEnable]);(0,external_root_React_commonjs2_react_commonjs_react_amd_react_.useEffect)(function(){if(textRef.current&&dispatch){var commandOrchestrator=new TextAreaCommandOrchestrator(textRef.current);executeRef.current=commandOrchestrator;dispatch({textarea:textRef.current,commandOrchestrator:commandOrchestrator});}// eslint-disable-next-line react-hooks/exhaustive-deps
+},[]);var onKeyDown=function onKeyDown(e){handleKeyDown(e,tabSize,defaultTabEnable);console.log('otherStore:',otherStore);shortcutsHandle(e,[].concat(_toConsumableArray(commands||[]),_toConsumableArray(extraCommands||[])),executeRef.current,dispatch,statesRef.current);};(0,external_root_React_commonjs2_react_commonjs_react_amd_react_.useEffect)(function(){if(textRef.current){textRef.current.addEventListener('keydown',onKeyDown);}return function(){if(textRef.current){// eslint-disable-next-line react-hooks/exhaustive-deps
 textRef.current.removeEventListener('keydown',onKeyDown);}};// eslint-disable-next-line react-hooks/exhaustive-deps
 },[]);return/*#__PURE__*/(0,jsx_runtime.jsx)("textarea",_objectSpread2(_objectSpread2({autoComplete:"off",autoCorrect:"off",autoCapitalize:"off",spellCheck:false},other),{},{ref:textRef,className:"".concat(prefixCls,"-text-input ").concat(other.className?other.className:''),value:markdown,onChange:function onChange(e){dispatch&&dispatch({markdown:e.target.value});_onChange&&_onChange(e);}}));}
 ;// CONCATENATED MODULE: ./src/components/TextArea/index.tsx
@@ -73372,7 +74235,7 @@ function Child_Child(props){var _ref=props||{},prefixCls=_ref.prefixCls,groupNam
 function ToolbarItems(props){var prefixCls=props.prefixCls,overflow=props.overflow;var _useContext=(0,external_root_React_commonjs2_react_commonjs_react_amd_react_.useContext)(EditorContext),fullscreen=_useContext.fullscreen,preview=_useContext.preview,_useContext$barPopup=_useContext.barPopup,barPopup=_useContext$barPopup===void 0?{}:_useContext$barPopup,components=_useContext.components,commandOrchestrator=_useContext.commandOrchestrator,dispatch=_useContext.dispatch;var originalOverflow=(0,external_root_React_commonjs2_react_commonjs_react_amd_react_.useRef)('');function handleClick(command,name){if(!dispatch)return;var state={barPopup:_objectSpread2({},barPopup)};if(command.keyCommand==='preview'){state.preview=command.value;}if(command.keyCommand==='fullscreen'){state.fullscreen=!fullscreen;}if(props.commands&&command.keyCommand==='group'){props.commands.forEach(function(item){if(name===item.groupName){state.barPopup[name]=true;}else if(item.keyCommand){state.barPopup[item.groupName]=false;}});}else if(name||command.parent){Object.keys(state.barPopup||{}).forEach(function(keyName){state.barPopup[keyName]=false;});}if(Object.keys(state).length){dispatch(_objectSpread2({},state));}commandOrchestrator&&commandOrchestrator.executeCommand(command);}(0,external_root_React_commonjs2_react_commonjs_react_amd_react_.useEffect)(function(){if(document&&overflow){if(fullscreen){// prevent scroll on fullscreen
 document.body.style.overflow='hidden';}else{// get the original overflow only the first time
 if(!originalOverflow.current){originalOverflow.current=window.getComputedStyle(document.body,null).overflow;}// reset to the original overflow
-document.body.style.overflow=originalOverflow.current;}}},[fullscreen,originalOverflow,overflow]);return/*#__PURE__*/(0,jsx_runtime.jsx)("ul",{children:(props.commands||[]).map(function(item,idx){if(item.keyCommand==='divider'){return/*#__PURE__*/(0,jsx_runtime.jsx)("li",_objectSpread2(_objectSpread2({},item.liProps),{},{className:"".concat(prefixCls,"-toolbar-divider")}),idx);}if(!item.keyCommand)return/*#__PURE__*/(0,jsx_runtime.jsx)(external_root_React_commonjs2_react_commonjs_react_amd_react_.Fragment,{},idx);var activeBtn=fullscreen&&item.keyCommand==='fullscreen'||item.keyCommand==='preview'&&preview===item.value;var childNode=item.children&&typeof item.children==='function'?item.children({getState:function getState(){return commandOrchestrator.getState();},textApi:commandOrchestrator?commandOrchestrator.textApi:undefined,close:function close(){return handleClick({},item.groupName);},execute:function execute(){return handleClick({execute:item.execute});}}):undefined;var disabled=barPopup&&preview&&preview==='preview'&&!/(preview|fullscreen)/.test(item.keyCommand);var render=(components===null||components===void 0?void 0:components.toolbar)||item.render;var com=render&&typeof render==='function'?render(item,!!disabled,handleClick,idx):null;return/*#__PURE__*/(0,jsx_runtime.jsxs)("li",_objectSpread2(_objectSpread2({},item.liProps),{},{className:activeBtn?"active":'',children:[com&&/*#__PURE__*/external_root_React_commonjs2_react_commonjs_react_amd_react_default().isValidElement(com)&&com,!com&&!item.buttonProps&&item.icon,!com&&item.buttonProps&&/*#__PURE__*/external_root_React_commonjs2_react_commonjs_react_amd_react_default().createElement('button',_objectSpread2(_objectSpread2({type:'button',key:idx,disabled:disabled,'data-name':item.name},item.buttonProps),{},{onClick:function onClick(evn){evn.stopPropagation();handleClick(item,item.groupName);}}),item.icon),item.children&&/*#__PURE__*/(0,jsx_runtime.jsx)(Child_Child,{overflow:overflow,groupName:item.groupName,prefixCls:prefixCls,children:childNode,commands:Array.isArray(item.children)?item.children:undefined})]}),idx);})});}function Toolbar_Toolbar(){var props=arguments.length>0&&arguments[0]!==undefined?arguments[0]:{};var prefixCls=props.prefixCls,toolbarBottom=props.toolbarBottom,isChild=props.isChild;var _useContext2=(0,external_root_React_commonjs2_react_commonjs_react_amd_react_.useContext)(EditorContext),commands=_useContext2.commands,extraCommands=_useContext2.extraCommands;var bottomClassName=toolbarBottom?'bottom':'';return/*#__PURE__*/(0,jsx_runtime.jsxs)("div",{className:"".concat(prefixCls,"-toolbar ").concat(bottomClassName),children:[/*#__PURE__*/(0,jsx_runtime.jsx)(ToolbarItems,_objectSpread2(_objectSpread2({},props),{},{commands:props.commands||commands||[]})),!isChild&&/*#__PURE__*/(0,jsx_runtime.jsx)(ToolbarItems,_objectSpread2(_objectSpread2({},props),{},{commands:extraCommands||[]}))]});}
+document.body.style.overflow=originalOverflow.current;}}},[fullscreen,originalOverflow,overflow]);return/*#__PURE__*/(0,jsx_runtime.jsx)("ul",{children:(props.commands||[]).map(function(item,idx){if(item.keyCommand==='divider'){return/*#__PURE__*/(0,jsx_runtime.jsx)("li",_objectSpread2(_objectSpread2({},item.liProps),{},{className:"".concat(prefixCls,"-toolbar-divider")}),idx);}if(!item.keyCommand)return/*#__PURE__*/(0,jsx_runtime.jsx)(external_root_React_commonjs2_react_commonjs_react_amd_react_.Fragment,{},idx);var activeBtn=fullscreen&&item.keyCommand==='fullscreen'||item.keyCommand==='preview'&&preview===item.value;var childNode=item.children&&typeof item.children==='function'?item.children({getState:function getState(){return commandOrchestrator.getState();},textApi:commandOrchestrator?commandOrchestrator.textApi:undefined,close:function close(){return handleClick({},item.groupName);},execute:function execute(){return handleClick({execute:item.execute});},dispatch:dispatch}):undefined;var disabled=barPopup&&preview&&preview==='preview'&&!/(preview|fullscreen)/.test(item.keyCommand);var render=(components===null||components===void 0?void 0:components.toolbar)||item.render;var com=render&&typeof render==='function'?render(item,!!disabled,handleClick,idx):null;return/*#__PURE__*/(0,jsx_runtime.jsxs)("li",_objectSpread2(_objectSpread2({},item.liProps),{},{className:activeBtn?"active":'',children:[com&&/*#__PURE__*/external_root_React_commonjs2_react_commonjs_react_amd_react_default().isValidElement(com)&&com,!com&&!item.buttonProps&&item.icon,!com&&item.buttonProps&&/*#__PURE__*/external_root_React_commonjs2_react_commonjs_react_amd_react_default().createElement('button',_objectSpread2(_objectSpread2({type:'button',key:idx,disabled:disabled,'data-name':item.name},item.buttonProps),{},{onClick:function onClick(evn){evn.stopPropagation();handleClick(item,item.groupName);}}),item.icon),item.children&&/*#__PURE__*/(0,jsx_runtime.jsx)(Child_Child,{overflow:overflow,groupName:item.groupName,prefixCls:prefixCls,children:childNode,commands:Array.isArray(item.children)?item.children:undefined})]}),idx);})});}function Toolbar_Toolbar(){var props=arguments.length>0&&arguments[0]!==undefined?arguments[0]:{};var prefixCls=props.prefixCls,toolbarBottom=props.toolbarBottom,isChild=props.isChild;var _useContext2=(0,external_root_React_commonjs2_react_commonjs_react_amd_react_.useContext)(EditorContext),commands=_useContext2.commands,extraCommands=_useContext2.extraCommands;var bottomClassName=toolbarBottom?'bottom':'';return/*#__PURE__*/(0,jsx_runtime.jsxs)("div",{className:"".concat(prefixCls,"-toolbar ").concat(bottomClassName),children:[/*#__PURE__*/(0,jsx_runtime.jsx)(ToolbarItems,_objectSpread2(_objectSpread2({},props),{},{commands:props.commands||commands||[]})),!isChild&&/*#__PURE__*/(0,jsx_runtime.jsx)(ToolbarItems,_objectSpread2(_objectSpread2({},props),{},{commands:extraCommands||[]}))]});}
 ;// CONCATENATED MODULE: ./src/components/DragBar/index.less
 // extracted by mini-css-extract-plugin
 /* harmony default export */ const DragBar = ({});