@uiw/react-md-editor 3.20.10 → 3.21.0

package/dist/mdeditor.js

@@ -17364,123 +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),
-  "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)
+  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
@@ -28021,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) => {
@@ -28043,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
 
 
@@ -33335,7 +33333,7 @@ function ReactMarkdown(options) {
   }
 
   const processor = unified()
-    .use(remark_parse)
+    .use(remarkParse)
     .use(options.remarkPlugins || [])
     .use(lib, {
       ...options.remarkRehypeOptions,
@@ -35091,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 {'left'|'center'|'right'|'none'} Align
+ * @typedef {[number, number, Array<Event>]} Change
+ * @typedef {[number, number, number]} Jump
  */
 
+/**
+ * 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)
+  // }
 
-/** @type {Extension} */
-const gfmTable = {
-  flow: {
-    null: {
-      tokenize: tokenizeTable,
-      resolve: resolveTable
+  /**
+   * Done, change the events.
+   *
+   * @param {Array<Event>} events
+   * @returns {void}
+   */
+  consume(events) {
+    this.map.sort((a, b) => a[0] - b[0])
+
+    /* 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
@@ -35861,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
  */
 
 
@@ -35876,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([
@@ -35892,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([
@@ -73656,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`
@@ -73670,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
@@ -73691,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 = ({});