@nectary/components 2.6.0 → 2.7.0

package/rich-textarea/utils.js

@@ -0,0 +1,1730 @@
+import { getEmojiBaseUrl, getEmojiUrl } from '../emoji/utils';
+import { isEmojiString, parseMarkdown } from '../utils';
+const TEXT_EMPTY_DATA = '​';
+const TEXT_WHITESPACE = ' ';
+const isTextNode = $n => $n !== null && $n.nodeType === Node.TEXT_NODE;
+const isEmptyText = value => value === null || value.length === 0 || value === TEXT_EMPTY_DATA;
+const isEmptyTextNode = $n => isTextNode($n) && isEmptyText($n.nodeValue);
+const getTextValue = $n => isEmptyText($n.nodeValue) ? TEXT_EMPTY_DATA : $n.nodeValue;
+const isParagraph = $n => {
+  return $n !== null && $n.nodeType === Node.ELEMENT_NODE && $n.classList.contains('p');
+};
+const isListItem = $n => {
+  return isUnorderedListItem($n) || isOrderedListItem($n);
+};
+const isUnorderedListItem = $n => {
+  return $n !== null && $n.nodeType === Node.ELEMENT_NODE && $n.classList.contains('uli');
+};
+const isOrderedListItem = $n => {
+  return $n !== null && $n.nodeType === Node.ELEMENT_NODE && $n.classList.contains('oli');
+};
+const isTextBlock = $n => isParagraph($n) || isListItem($n);
+const isEmoji = $n => {
+  return $n !== null && $n.nodeName === 'IMG';
+};
+const isInline = $n => $n !== null && $n.nodeName === 'SPAN';
+const isRoot = $n => $n !== null && $n.nodeName === 'DIV';
+const assertNonNull = $n => {
+  if ($n === null) {
+    throw new Error('Node is NULL');
+  }
+};
+const assertEquals = (a, b) => {
+  if (a !== b) {
+    throw new Error(`"${a}" not equals "${b}"`);
+  }
+};
+const assertTextNode = $n => {
+  assertNonNull($n);
+  if (!isTextNode($n)) {
+    throw new Error(`Node is not a TextNode: ${$n?.nodeName}`);
+  }
+};
+const assertTextBlock = $n => {
+  assertNonNull($n);
+  if (!isTextBlock($n)) {
+    throw new Error(`Node is not a TextBlock: ${$n?.nodeName}`);
+  }
+};
+const assertListItem = $n => {
+  assertNonNull($n);
+  if (!isListItem($n)) {
+    throw new Error(`Node is not a ListItem: ${$n?.nodeName}`);
+  }
+};
+const markListItemAsBlock = $li => {
+  $li.classList.add('block');
+};
+const isListItemMarkedArBlock = $li => {
+  return $li.classList.contains('block');
+};
+const MAX_LISTITEM_LEVEL = 4;
+const removeListItemLevel = $li => {
+  $li.classList.remove('l0', 'l1', 'l2', 'l3', 'l4');
+};
+const setListItemLevel = ($li, level) => {
+  removeListItemLevel($li);
+  const clampedLevel = Math.max(0, Math.min(level, MAX_LISTITEM_LEVEL));
+  $li.classList.add(`l${clampedLevel}`);
+};
+const getListItemLevel = $li => {
+  if ($li.classList.contains('l1')) {
+    return 1;
+  }
+  if ($li.classList.contains('l2')) {
+    return 2;
+  }
+  if ($li.classList.contains('l3')) {
+    return 3;
+  }
+  if ($li.classList.contains('l4')) {
+    return 4;
+  }
+  return 0;
+};
+const assertInline = $n => {
+  assertNonNull($n);
+  if (!isInline($n)) {
+    throw new Error(`Node is not an Inline: ${$n?.nodeName}`);
+  }
+};
+const isTextContent = $n => {
+  return $n !== null && $n.nodeType === Node.ELEMENT_NODE && (isInline($n) || isEmoji($n));
+};
+const assertTextContent = $n => {
+  assertNonNull($n);
+  if (!isTextContent($n)) {
+    throw new Error(`Node is not TextContent: ${$n?.nodeName}`);
+  }
+};
+const createTextNode = (data, doc) => {
+  return doc.createTextNode(data);
+};
+const createEmptyTextNode = doc => {
+  return createTextNode(TEXT_EMPTY_DATA, doc);
+};
+const createEmptyInline = doc => {
+  const res = doc.createElement('SPAN');
+  res.append(createEmptyTextNode(doc));
+  return res;
+};
+const getParentInline = $n => {
+  const $p = $n.parentNode;
+  assertInline($p);
+  return $p;
+};
+const isInsideList = (isOrdered, $n) => {
+  const $block = getParentTextBlock($n);
+  return isOrdered ? isOrderedListItem($block) : isUnorderedListItem($block);
+};
+const isAllInsideList = (isOrdered, $a, $b) => {
+  return allSiblingsIncludingSatisfy(getParentTextBlock($a), getParentTextBlock($b), isOrdered ? isOrderedListItem : isUnorderedListItem);
+};
+const FORMAT_TYPE_TO_NAME = {
+  formatBold: 'b',
+  formatCodeTag: 'c',
+  formatItalic: 'i',
+  formatStrikeThrough: 's'
+};
+const isFormatName = ($n, inlineName) => {
+  return $n.classList.contains(inlineName);
+};
+const isFormatBold = $n => isFormatName($n, 'b');
+const isFormatItalic = $n => isFormatName($n, 'i');
+const isFormatStrikethrough = $n => isFormatName($n, 's');
+const isFormatCodetag = $n => isFormatName($n, 'c');
+const isFormatLink = $n => isFormatName($n, 'l');
+const isAllInsideFormatName = ($a, $b, formatName) => {
+  const aBlock = getParentTextBlock($a);
+  const bBlock = getParentTextBlock($b);
+  let $currentBlock = aBlock;
+  let $prevBlock = null;
+  let hasTextNodes = false;
+  do {
+    let $n = $currentBlock === getParentTextBlock($a) ? $a : getFirstTextContent($currentBlock);
+    let $prev = $n;
+    do {
+      if (isInline($n)) {
+        hasTextNodes = true;
+        if (!isFormatName($n, formatName)) {
+          return false;
+        }
+      }
+      $prev = $n;
+      $n = getNextSiblingTextContent($n);
+    } while ($n !== null && $prev !== $b);
+    $prevBlock = $currentBlock;
+    $currentBlock = getNextSiblingTextBlock($currentBlock);
+  } while ($currentBlock !== null && $prevBlock !== bBlock);
+  return hasTextNodes;
+};
+const isAllInsideBold = ($a, $b) => isAllInsideFormatName($a, $b, 'b');
+const isAllInsideItalic = ($a, $b) => isAllInsideFormatName($a, $b, 'i');
+const isAllInsideStrikethrough = ($a, $b) => isAllInsideFormatName($a, $b, 's');
+const isAllInsideCodetag = ($a, $b) => isAllInsideFormatName($a, $b, 'c');
+const isAllInsideLink = ($a, $b) => isAllInsideFormatName($a, $b, 'l');
+const LINK_HREF_ATTR_NAME = 'data-href';
+const copyFormatName = ($source, $target) => {
+  const $inline = isTextNode($source) ? getParentInline($source) : $source;
+  $target.className = $inline.className;
+  if (isFormatLink($inline)) {
+    $target.setAttribute(LINK_HREF_ATTR_NAME, $inline.getAttribute(LINK_HREF_ATTR_NAME) ?? '');
+  }
+};
+const setInlineFormat = ($n, formatName, shouldEnable) => {
+  if (shouldEnable) {
+    if (formatName === 'c' || isFormatName($n, 'c')) {
+      $n.className = '';
+    }
+    if (formatName === 'l' || isFormatName($n, 'l')) {
+      $n.className = '';
+      $n.removeAttribute(LINK_HREF_ATTR_NAME);
+    }
+    $n.classList.add(formatName);
+  } else {
+    if (formatName === 'l') {
+      $n.removeAttribute(LINK_HREF_ATTR_NAME);
+    }
+    $n.classList.remove(formatName);
+  }
+};
+const setAllInlineFormat = ($a, $b, formatName, shouldEnable) => {
+  const aBlock = getParentTextBlock($a);
+  const bBlock = getParentTextBlock($b);
+  let $currentBlock = aBlock;
+  let $prevBlock = null;
+  do {
+    let $n = $currentBlock === getParentTextBlock($a) ? $a : getFirstTextContent($currentBlock);
+    let $prev = $n;
+    do {
+      if (isInline($n)) {
+        setInlineFormat($n, formatName, shouldEnable);
+      }
+      $prev = $n;
+      $n = getNextSiblingTextContent($n);
+    } while ($n !== null && $prev !== $b);
+    $prevBlock = $currentBlock;
+    $currentBlock = getNextSiblingTextBlock($currentBlock);
+  } while ($currentBlock !== null && $prevBlock !== bBlock);
+};
+const toggleInlineFormat = ($n, formatName) => {
+  setInlineFormat($n, formatName, !isFormatName($n, formatName));
+};
+const areSameInlineFormat = ($a, $b) => {
+  if ($a.classList.length === 0 && $b.classList.length === 0) {
+    return true;
+  }
+  if ($a.classList.length !== $b.classList.length) {
+    return false;
+  }
+  if ($a.className === 'l') {
+    return $b.className === 'l' && $a.getAttribute(LINK_HREF_ATTR_NAME) === $b.getAttribute(LINK_HREF_ATTR_NAME);
+  }
+  for (let i = 0; i < $a.classList.length; i++) {
+    if (!$b.classList.contains($a.classList[i])) {
+      return false;
+    }
+  }
+  return true;
+};
+const createInlineWithText = (data, doc) => {
+  const $res = doc.createElement('SPAN');
+  $res.append(createTextNode(data, doc));
+  return $res;
+};
+const createInlineWithTextOfType = ($text, $source) => {
+  const $res = $source.ownerDocument.createElement($source.nodeName);
+  copyFormatName($source, $res);
+  $res.append($text);
+  return $res;
+};
+const createLink = (text, href, doc) => {
+  const $link = createInlineWithText(text, doc);
+  setInlineFormat($link, 'l', true);
+  $link.setAttribute(LINK_HREF_ATTR_NAME, href);
+  return $link;
+};
+const EMOJI_CHAR_ATTR_NAME = 'data-char';
+const createEmoji = (emojiChar, baseUrl, doc) => {
+  const $emoji = doc.createElement('img');
+  $emoji.setAttribute(EMOJI_CHAR_ATTR_NAME, emojiChar);
+  $emoji.setAttribute('src', getEmojiUrl(baseUrl, emojiChar));
+  $emoji.classList.add('e');
+  return $emoji;
+};
+const PARAGRAPH_CLASSNAME = 'p';
+const createActuallyEmptyParagraph = doc => {
+  const $p = doc.createElement('p');
+  $p.classList.add(PARAGRAPH_CLASSNAME);
+  return $p;
+};
+const createEmptyParagraph = doc => {
+  const res = createActuallyEmptyParagraph(doc);
+  res.append(createEmptyInline(doc));
+  return res;
+};
+const createParagraphWithChildren = (children, doc) => {
+  if (children.length === 0) {
+    return createEmptyParagraph(doc);
+  }
+  const $p = createActuallyEmptyParagraph(doc);
+  $p.append(...children);
+  return $p;
+};
+const ULI_CLASSNAME = 'uli';
+const OLI_CLASSNAME = 'oli';
+const createActuallyEmptyListItem = (isOrdered, listLevel, doc) => {
+  const $li = doc.createElement('p');
+  $li.className = isOrdered ? OLI_CLASSNAME : ULI_CLASSNAME;
+  setListItemLevel($li, listLevel);
+  return $li;
+};
+const createEmptyListItem = (isOrdered, listLevel, doc) => {
+  const $li = createActuallyEmptyListItem(isOrdered, listLevel, doc);
+  $li.append(createEmptyInline(doc));
+  return $li;
+};
+const setListItemOrderedType = ($li, isOrdered) => {
+  if (isOrdered) {
+    $li.classList.remove(ULI_CLASSNAME);
+    $li.classList.add(OLI_CLASSNAME);
+  } else {
+    $li.classList.remove(OLI_CLASSNAME);
+    $li.classList.add(ULI_CLASSNAME);
+  }
+};
+const convertToListItem = ($p, isOrdered) => {
+  $p.classList.remove(PARAGRAPH_CLASSNAME);
+  if (isOrdered) {
+    $p.classList.add(OLI_CLASSNAME);
+  } else {
+    $p.classList.add(ULI_CLASSNAME);
+  }
+  const $li = $p;
+  setListItemLevel($li, 0);
+  return $li;
+};
+const convertToParagraph = $li => {
+  removeListItemLevel($li);
+  $li.classList.remove(ULI_CLASSNAME, OLI_CLASSNAME);
+  $li.classList.add(PARAGRAPH_CLASSNAME);
+  ensureListItemLevelsAreCorrect($li);
+  return $li;
+};
+const createListItemWithChildren = (children, isOrdered, listLevel, doc) => {
+  if (children.length === 0) {
+    return createEmptyListItem(isOrdered, listLevel, doc);
+  }
+  const $li = createActuallyEmptyListItem(isOrdered, listLevel, doc);
+  $li.append(...children);
+  return $li;
+};
+const getParentTextBlock = $node => {
+  const $inline = isTextNode($node) ? getParentInline($node) : $node;
+  const $p = $inline.parentNode;
+  assertTextBlock($p);
+  return $p;
+};
+const childIndexOf = ($parent, $child) => {
+  return Array.prototype.indexOf.call($parent.childNodes, $child);
+};
+const getChildByIndex = ($parent, index) => {
+  const children = $parent.childNodes;
+  if (index < 0 || index >= children.length) {
+    throw new Error('Invalid index');
+  }
+  const $ch = index >= children.length ? children[children.length - 1] : children[index];
+  return $ch;
+};
+const afterLastChildIndex = $parent => {
+  return $parent.childNodes.length;
+};
+const isAfterLastChildIndex = ($parent, index) => {
+  return index >= $parent.childNodes.length;
+};
+const getLastChild = n => n.lastChild;
+const getFirstChild = n => n.firstChild;
+const getPrevSibling = n => n.previousSibling;
+const getNextSibling = n => n.nextSibling;
+const getSiblingTextBlock = getSibling => $node => {
+  const $sib = getSibling($node);
+  if ($sib !== null) {
+    assertTextBlock($sib);
+    return $sib;
+  }
+  return null;
+};
+const getPrevSiblingTextBlock = getSiblingTextBlock(getPrevSibling);
+const getNextSiblingTextBlock = getSiblingTextBlock(getNextSibling);
+const getPrevSiblingTextContent = ($node, ensureValid) => {
+  const $sib = $node.previousSibling;
+  if ($sib === null && ensureValid === true) {
+    const $currentBlock = getParentTextBlock($node);
+    const $prevBlock = getPrevSiblingTextBlock($currentBlock);
+    if ($prevBlock === null) {
+      $currentBlock.prepend(createEmptyInline($node.ownerDocument));
+      return getFirstTextContent($currentBlock);
+    }
+    return getLastTextContent($prevBlock);
+  }
+  if ($sib !== null) {
+    assertTextContent($sib);
+  }
+  return $sib;
+};
+const getNextSiblingTextContent = ($node, ensureValid) => {
+  const $sib = $node.nextSibling;
+  if ($sib === null && ensureValid === true) {
+    const $currentBlock = getParentTextBlock($node);
+    const $nextBlock = getNextSiblingTextBlock($currentBlock);
+    if ($nextBlock === null) {
+      $currentBlock.append(createEmptyInline($node.ownerDocument));
+      return getLastTextContent($currentBlock);
+    }
+    return getFirstTextContent($nextBlock);
+  }
+  if ($sib !== null) {
+    assertTextContent($sib);
+  }
+  return $sib;
+};
+const createCollapsedRange = cursor => {
+  const {
+    node,
+    offset
+  } = cursorToNodeWithOffset(cursor);
+  return {
+    startContainer: node,
+    startOffset: offset,
+    endContainer: node,
+    endOffset: offset
+  };
+};
+const createSpanningRange = (aCursor, bCursor) => {
+  const {
+    node: startContainer,
+    offset: startOffset
+  } = cursorToNodeWithOffset(aCursor);
+  const {
+    node: endContainer,
+    offset: endOffset
+  } = cursorToNodeWithOffset(bCursor);
+  return {
+    startContainer,
+    startOffset,
+    endContainer,
+    endOffset
+  };
+};
+const removePrevSiblings = $node => {
+  let $n;
+  while (($n = $node.previousSibling) !== null) {
+    $n.remove();
+  }
+};
+const removeNextSiblings = $node => {
+  let $n;
+  while (($n = $node.nextSibling) !== null) {
+    $n.remove();
+  }
+};
+const removeSiblingsBetween = ($a, $b) => {
+  let $n;
+  while (($n = $a.nextSibling) !== $b) {
+    assertNonNull($n);
+    $n.remove();
+  }
+};
+const getCommonParent = ($n0, $n1) => {
+  let $n = $n0;
+  while (!$n.contains($n1)) {
+    $n = $n.parentNode;
+  }
+  return $n;
+};
+const removeNodesBetween = (aCursor, bCursor) => {
+  if (aCursor.$inline === bCursor.$inline) {
+    return;
+  }
+  const commonParent = getCommonParent(aCursor.$inline, bCursor.$inline);
+  let $cpChildA = aCursor.$inline;
+  let $cpChildB = bCursor.$inline;
+  while ($cpChildA.parentNode !== commonParent) {
+    removeNextSiblings($cpChildA);
+    $cpChildA = $cpChildA.parentNode;
+  }
+  while ($cpChildB.parentNode !== commonParent) {
+    removePrevSiblings($cpChildB);
+    $cpChildB = $cpChildB.parentNode;
+  }
+  removeSiblingsBetween($cpChildA, $cpChildB);
+};
+const ensureCorrectTextBlockIfEmpty = $node => {
+  if (!$node.hasChildNodes()) {
+    $node.append(createEmptyInline($node.ownerDocument));
+    return;
+  }
+  const children = $node.childNodes;
+  if (children.length === 1) {
+    const $firstChild = children[0];
+    assertTextContent($firstChild);
+    if (isInline($firstChild)) {
+      if ($firstChild.childNodes.length > 1 || !isTextNode($firstChild.firstChild)) {
+        $node.replaceChildren(createEmptyInline($node.ownerDocument));
+      }
+    }
+  }
+};
+const getChildText = $node => {
+  if ($node.childNodes.length !== 1) {
+    throw new Error('Should have exact 1 child');
+  }
+  const $child = $node.firstChild;
+  assertTextNode($child);
+  return $child;
+};
+const getChildTextContent = getFirstOrLastChild => $node => {
+  ensureCorrectTextBlockIfEmpty($node);
+  const $child = getFirstOrLastChild($node);
+  assertTextContent($child);
+  return $child;
+};
+const getLastTextContent = getChildTextContent(getLastChild);
+const getFirstTextContent = getChildTextContent(getFirstChild);
+const getFirstOrLastTextBlock = getFirstOrLastChild => $root => {
+  let $lc = getFirstOrLastChild($root);
+  if ($lc === null) {
+    $lc = createEmptyParagraph($root.ownerDocument);
+    $root.append($lc);
+  }
+  assertTextBlock($lc);
+  return $lc;
+};
+const getFirstTextBlock = getFirstOrLastTextBlock(getFirstChild);
+const getLastTextBlock = getFirstOrLastTextBlock(getLastChild);
+const mergeSiblingTextNodes = ($a, aCursor, bCursor) => {
+  const $b = $a.nextSibling;
+  if ($b === null) {
+    return;
+  }
+  assertTextNode($b);
+  const aContent = getTextValue($a);
+  const bContent = getTextValue($b);
+  const aContentLength = isEmptyText(aContent) ? 0 : aContent.length;
+  const bContentLength = isEmptyText(bContent) ? 0 : bContent.length;
+  let resultText = (isEmptyText(aContent) ? '' : aContent) + (isEmptyText(bContent) ? '' : bContent);
+  const isEmptyResultText = resultText.length === 0;
+  if (aCursor.$text === $a) {
+    aCursor.offset = isEmptyResultText ? 1 : aCursor.offset;
+  }
+  if (aCursor.$text === $b) {
+    aCursor.$text = $a;
+    aCursor.offset = isEmptyResultText ? 1 : aContentLength + (bContentLength === 0 ? 0 : aCursor.offset);
+  }
+  if (bCursor != null) {
+    if (bCursor.$text === $a) {
+      bCursor.offset = isEmptyResultText ? 1 : bCursor.offset;
+    }
+    if (bCursor.$text === $b) {
+      bCursor.$text = $a;
+      bCursor.offset = isEmptyResultText ? 1 : aContentLength + (bContentLength === 0 ? 0 : bCursor.offset);
+    }
+  }
+  if (isEmptyResultText) {
+    resultText = TEXT_EMPTY_DATA;
+  }
+  $a.nodeValue = resultText;
+  $b.remove();
+  mergeSiblingTextNodes($a, aCursor);
+};
+const mergeNextTextContentSibling = ($a, aCursor, bCursor) => {
+  const $b = $a.nextSibling;
+  if ($b === null) {
+    return;
+  }
+  assertTextContent($b);
+  if (isInline($a) && isInline($b)) {
+    const $aText = getChildText($a);
+    const $bText = getChildText($b);
+    if (areSameInlineFormat($a, $b) || isEmptyTextNode($aText) || isEmptyTextNode($bText)) {
+      $a.append($bText);
+      $b.remove();
+      mergeSiblingTextNodes($aText, aCursor, bCursor);
+    }
+  }
+};
+const mergePrevTextContentSibling = ($b, aCursor, bCursor) => {
+  const $a = $b.previousSibling;
+  if ($a === null) {
+    return;
+  }
+  assertTextContent($a);
+  if (isInline($a) && isInline($b)) {
+    const $aText = getChildText($a);
+    const $bText = getChildText($b);
+    if (areSameInlineFormat($a, $b) || isEmptyTextNode($aText) || isEmptyTextNode($bText)) {
+      $a.append($bText);
+      $b.remove();
+      mergeSiblingTextNodes($aText, aCursor, bCursor);
+    }
+  }
+};
+const mergeTextContentBetween = ($a, $b, aCursor, bCursor) => {
+  const $sib = getNextSiblingTextContent($a);
+  if ($sib === null) {
+    return;
+  }
+  if ($a === $b || $sib === $b) {
+    mergeNextTextContentSibling($b, aCursor, bCursor);
+    mergeNextTextContentSibling($a, aCursor, bCursor);
+    mergePrevTextContentSibling($a, aCursor, bCursor);
+    return;
+  }
+  mergeNextTextContentSibling($a, aCursor, bCursor);
+  const $newSib = getNextSiblingTextContent($a);
+  assertNonNull($newSib);
+  if ($newSib === $sib) {
+    mergePrevTextContentSibling($a, aCursor, bCursor);
+    mergeTextContentBetween($sib, $b, aCursor, bCursor);
+  } else {
+    mergeTextContentBetween($a, $b, aCursor, bCursor);
+  }
+};
+const mergeNextTextBlock = ($a, aCursor, bCursor) => {
+  const $b = $a.nextSibling;
+  if ($b === null) {
+    return;
+  }
+  assertTextBlock($b);
+  const $lastChild = getLastChild($a);
+  if ($b.hasChildNodes()) {
+    $a.append(...Array.from($b.childNodes));
+  }
+  $b.remove();
+  if ($lastChild !== null) {
+    assertTextContent($lastChild);
+    mergeNextTextContentSibling($lastChild, aCursor, bCursor);
+  }
+};
+const sliceChildren = ($parent, index) => {
+  if (index < 0) {
+    throw new Error('Not found');
+  }
+  const children = Array.from($parent.childNodes);
+  if (index === 0) {
+    return children;
+  }
+  return children.slice(index);
+};
+const splitTextBlock = ($a, childIndex) => {
+  const bChildren = sliceChildren($a, childIndex);
+  const $b = isListItem($a) ? createListItemWithChildren(bChildren, isOrderedListItem($a), getListItemLevel($a), $a.ownerDocument) : createParagraphWithChildren(bChildren, $a.ownerDocument);
+  ensureCorrectTextBlockIfEmpty($a);
+  ensureCorrectTextBlockIfEmpty($b);
+  $a.after($b);
+  return [$a, $b];
+};
+const splitTextNode = ($aText, offset) => {
+  const content = getTextValue($aText);
+  const aContent = content.substring(0, offset);
+  const bContent = content.substring(offset);
+  let $bText = null;
+  if (aContent.length > 0 && bContent.length > 0) {
+    $bText = createTextNode(bContent, $aText.ownerDocument);
+    $aText.nodeValue = aContent;
+  }
+  const $aInline = getParentInline($aText);
+  let $bInline = null;
+  if ($bText !== null) {
+    $bInline = createInlineWithTextOfType($bText, $aInline);
+    $aInline.after($bInline);
+  }
+  const $before = aContent.length === 0 ? getPrevSiblingTextContent($aInline) : $aInline;
+  const $after = $bInline ?? (aContent.length === 0 ? $aInline : getNextSiblingTextContent($aInline));
+  return [$before, $after];
+};
+const sliceTextNode = ($n, startOffset, endOffset) => {
+  const $after = splitTextNode($n, startOffset)[1];
+  assertInline($after);
+  const $before = splitTextNode(getChildText($after), endOffset - startOffset)[0];
+  assertEquals($before, $after);
+  return $after;
+};
+const splitTextNodeAndInsertEmptyInline = ($n, offset) => {
+  const [$before, $after] = splitTextNode($n, offset);
+  const $inline = createEmptyInline($n.ownerDocument);
+  copyFormatName($n, $inline);
+  if ($before !== null) {
+    $before.after($inline);
+  } else {
+    assertNonNull($after);
+    $after.before($inline);
+  }
+  return $inline;
+};
+export const formatInline = (formatType, range) => {
+  const aCursor = createIncomingCursorFromNodeWithOffset(range.startContainer, range.startOffset);
+  const bCursor = createIncomingCursorFromNodeWithOffset(range.endContainer, range.endOffset);
+  const formatName = FORMAT_TYPE_TO_NAME[formatType];
+  if (aCursor.$inline === bCursor.$inline && isTextNode(aCursor.$text)) {
+    const {
+      $text,
+      $inline,
+      offset: startOffset
+    } = aCursor;
+    const {
+      offset: endOffset
+    } = bCursor;
+    if (isEmptyText($text.nodeValue)) {
+      assertInline($inline);
+      toggleInlineFormat($inline, formatName);
+      return {
+        prevent: true,
+        range: createCollapsedRange(createEndCursorFromTextContent($inline))
+      };
+    }
+    if (startOffset === endOffset) {
+      const $newinline = splitTextNodeAndInsertEmptyInline($text, startOffset);
+      toggleInlineFormat($newinline, formatName);
+      return {
+        prevent: true,
+        range: createCollapsedRange(createEndCursorFromTextContent($newinline))
+      };
+    }
+    const $newinline = sliceTextNode($text, startOffset, endOffset);
+    toggleInlineFormat($newinline, formatName);
+    const aTrackingCursor = createBeginCursorFromTextContent($newinline);
+    const bTrackingCursor = createEndCursorFromTextContent($newinline);
+    mergeNextTextContentSibling($newinline, aTrackingCursor, bTrackingCursor);
+    mergePrevTextContentSibling($newinline, aTrackingCursor, bTrackingCursor);
+    return {
+      prevent: true,
+      range: createSpanningRange(aTrackingCursor, bTrackingCursor)
+    };
+  }
+  const areAllInline = isAllInsideFormatName(aCursor.$inline, bCursor.$inline, formatName);
+  let $aInline = aCursor.$inline;
+  let $bInline = bCursor.$inline;
+  if (isTextNode(aCursor.$text)) {
+    $aInline = splitTextNode(aCursor.$text, aCursor.offset)[1];
+  }
+  if (isTextNode(bCursor.$text)) {
+    $bInline = splitTextNode(bCursor.$text, bCursor.offset)[0];
+  }
+  if ($aInline === null) {
+    const aBlock = getNextSiblingTextBlock(getParentTextBlock(aCursor.$inline));
+    assertNonNull(aBlock);
+    $aInline = getFirstTextContent(aBlock);
+  }
+  if ($bInline === null) {
+    const bBlock = getPrevSiblingTextBlock(getParentTextBlock(bCursor.$inline));
+    assertNonNull(bBlock);
+    $bInline = getLastTextContent(bBlock);
+  }
+  setAllInlineFormat($aInline, $bInline, formatName, !areAllInline);
+  const aTrackingCursor = createBeginCursorFromTextContent($aInline);
+  const bTrackingCursor = createEndCursorFromTextContent($bInline);
+  mergeTextContentBetween($aInline, $bInline, aTrackingCursor, bTrackingCursor);
+  return {
+    prevent: true,
+    range: createSpanningRange(aTrackingCursor, bTrackingCursor)
+  };
+};
+const allSiblingsIncludingSatisfy = (aNode, bNode, func) => {
+  let currentNode = aNode;
+  const nextSib = bNode.nextSibling;
+  while (currentNode !== null && currentNode !== nextSib) {
+    const tempNext = currentNode.nextSibling;
+    if (!func(currentNode)) {
+      return false;
+    }
+    currentNode = tempNext;
+  }
+  return true;
+};
+export const formatIndent = range => {
+  if (range.startContainer === range.endContainer && range.startOffset === range.endOffset && range.startOffset !== 0) {
+    return {
+      prevent: false
+    };
+  }
+  const aCursor = createIncomingCursorFromNodeWithOffset(range.startContainer, range.startOffset);
+  const bCursor = createIncomingCursorFromNodeWithOffset(range.endContainer, range.endOffset);
+  const aBlock = getParentTextBlock(aCursor.$inline);
+  const bBlock = getParentTextBlock(bCursor.$inline);
+  const $iterateUpToNode = getNextSiblingTextBlock(bBlock);
+  let $block = aBlock;
+  let $prevBlock = null;
+  while ($block !== null && $block !== $iterateUpToNode) {
+    if (isListItem($block) && !isListItemMarkedArBlock($block)) {
+      const $prev = $prevBlock ?? getPrevSiblingTextBlock($block);
+      const currentLevel = getListItemLevel($block);
+      if (isListItem($prev) && currentLevel <= getListItemLevel($prev)) {
+        setListItemLevel($block, currentLevel + 1);
+      }
+    }
+    $prevBlock = $block;
+    $block = getNextSiblingTextBlock($block);
+  }
+  return {
+    prevent: true,
+    range
+  };
+};
+const ensureListItemLevelsAreCorrect = $li => {
+  if ($li === null) {
+    return;
+  }
+  let $block = getNextSiblingTextBlock($li);
+  let prevLevel = isListItem($li) ? getListItemLevel($li) : -1;
+  while ($block !== null && isListItem($block)) {
+    let currentLevel = getListItemLevel($block);
+    if (currentLevel <= prevLevel + 1) {
+      break;
+    }
+    currentLevel = prevLevel + 1;
+    setListItemLevel($block, currentLevel);
+    prevLevel = currentLevel;
+    $block = getNextSiblingTextBlock($block);
+  }
+};
+export const formatOutdent = range => {
+  if (range.startContainer === range.endContainer && range.startOffset === range.endOffset && range.startOffset !== 0) {
+    return {
+      prevent: false
+    };
+  }
+  const aCursor = createIncomingCursorFromNodeWithOffset(range.startContainer, range.startOffset);
+  const bCursor = createIncomingCursorFromNodeWithOffset(range.endContainer, range.endOffset);
+  const aBlock = getParentTextBlock(aCursor.$inline);
+  const bBlock = getParentTextBlock(bCursor.$inline);
+  const $iterateUpToNode = getNextSiblingTextBlock(bBlock);
+  let $block = aBlock;
+  let $lastListItem = null;
+  while ($block !== null && $block !== $iterateUpToNode) {
+    if (isListItem($block)) {
+      setListItemLevel($block, getListItemLevel($block) - 1);
+      $lastListItem = $block;
+    }
+    $block = getNextSiblingTextBlock($block);
+  }
+  if ($lastListItem !== null) {
+    ensureListItemLevelsAreCorrect($lastListItem);
+  }
+  return {
+    prevent: true,
+    range
+  };
+};
+export const formatList = (isOrdered, range) => {
+  const aCursor = createIncomingCursorFromNodeWithOffset(range.startContainer, range.startOffset);
+  const bCursor = createIncomingCursorFromNodeWithOffset(range.endContainer, range.endOffset);
+  const aBlock = getParentTextBlock(aCursor.$inline);
+  const bBlock = getParentTextBlock(bCursor.$inline);
+  const isInsideSameListType = isAllInsideList(isOrdered, aCursor.$inline, bCursor.$inline);
+  if (isInsideSameListType) {
+    assertListItem(aBlock);
+    assertListItem(bBlock);
+    const $iterateUpToNode = getNextSiblingTextBlock(bBlock);
+    let $block = aBlock;
+    while ($block !== null && $block !== $iterateUpToNode) {
+      convertToParagraph($block);
+      $block = getNextSiblingTextBlock($block);
+    }
+    return {
+      prevent: true,
+      range: createCollapsedRange(bCursor)
+    };
+  }
+  const $iterateUpToNode = getNextSiblingTextBlock(bBlock);
+  let $block = aBlock;
+  while ($block !== null && $block !== $iterateUpToNode) {
+    if (isParagraph($block)) {
+      convertToListItem($block, isOrdered);
+    } else {
+      assertListItem($block);
+      setListItemOrderedType($block, isOrdered);
+    }
+    $block = getNextSiblingTextBlock($block);
+  }
+  return {
+    prevent: true,
+    range: createCollapsedRange(bCursor)
+  };
+};
+const createCursorFromTextNode = (node, offset) => {
+  return {
+    $text: node,
+    $inline: getParentInline(node),
+    offset: Math.min(node.length, offset)
+  };
+};
+const createBeginCursorFromTextContent = node => {
+  if (isInline(node)) {
+    const $text = getChildText(node);
+    const content = getTextValue($text);
+    return {
+      $inline: node,
+      $text,
+      offset: isEmptyText(content) ? content.length : 0
+    };
+  }
+  return {
+    $text: null,
+    $inline: node,
+    offset: 0
+  };
+};
+const createEndCursorFromTextContent = node => {
+  if (isInline(node)) {
+    const $text = getChildText(node);
+    return {
+      $inline: node,
+      $text,
+      offset: $text.length
+    };
+  }
+  return {
+    $text: null,
+    $inline: node,
+    offset: 0,
+    isAfterInline: true
+  };
+};
+const createIncomingCursorFromNodeWithOffset = (node, offset) => {
+  if (isTextNode(node)) {
+    return createCursorFromTextNode(node, offset);
+  }
+  if (isEmoji(node)) {
+    return {
+      $text: null,
+      $inline: node,
+      offset: 0
+    };
+  }
+  if (isTextBlock(node)) {
+    if (isAfterLastChildIndex(node, offset)) {
+      return createEndCursorFromTextContent(getLastTextContent(node));
+    }
+    return createIncomingCursorFromNodeWithOffset(getChildByIndex(node, offset), 0);
+  }
+  if (isInline(node)) {
+    return {
+      $inline: node,
+      $text: getChildText(node),
+      offset: 0
+    };
+  }
+  if (isRoot(node)) {
+    if (isAfterLastChildIndex(node, offset)) {
+      const $block = getLastTextBlock(node);
+      return createIncomingCursorFromNodeWithOffset($block, $block.childNodes.length);
+    }
+    return createIncomingCursorFromNodeWithOffset(getChildByIndex(node, offset), 0);
+  }
+  throw new Error('Should not happen');
+};
+const cursorToNodeWithOffset = _ref => {
+  let {
+    $text,
+    $inline,
+    offset,
+    isAfterInline
+  } = _ref;
+  if (isTextNode($text)) {
+    return {
+      node: $text,
+      offset
+    };
+  }
+  const $block = getParentTextBlock($inline);
+  const childIndex = childIndexOf($block, $inline) + (isAfterInline === true ? 1 : 0);
+  return {
+    node: $block,
+    offset: childIndex
+  };
+};
+const removeContentInRange = range => {
+  const aCursor = createIncomingCursorFromNodeWithOffset(range.startContainer, range.startOffset);
+  const bCursor = createIncomingCursorFromNodeWithOffset(range.endContainer, range.endOffset);
+  if (aCursor.$inline === bCursor.$inline && aCursor.offset === bCursor.offset && aCursor.isAfterInline === bCursor.isAfterInline) {
+    return aCursor;
+  }
+  if (aCursor.$text === bCursor.$text && isTextNode(aCursor.$text)) {
+    const {
+      $text,
+      $inline,
+      offset: startOffset
+    } = aCursor;
+    const {
+      offset: endOffset
+    } = bCursor;
+    const content = getTextValue($text);
+    const nextContent = content.substring(0, startOffset) + content.substring(endOffset);
+    $text.nodeValue = nextContent;
+    if (isEmptyText(nextContent)) {
+      const $nextSib = getNextSiblingTextContent($inline);
+      const $prevSib = getPrevSiblingTextContent($inline);
+      if ($prevSib === null && $nextSib === null) {
+        $text.nodeValue = TEXT_EMPTY_DATA;
+        return createEndCursorFromTextContent($inline);
+      }
+      $inline.remove();
+      if ($nextSib === null) {
+        assertNonNull($prevSib);
+        return createEndCursorFromTextContent($prevSib);
+      }
+      return createBeginCursorFromTextContent($nextSib);
+    }
+    return createCursorFromTextNode($text, startOffset);
+  }
+  removeNodesBetween(aCursor, bCursor);
+  if (isTextNode(aCursor.$text)) {
+    aCursor.$text.nodeValue = getTextValue(aCursor.$text).substring(0, aCursor.offset);
+  }
+  if (isTextNode(bCursor.$text)) {
+    bCursor.$text.nodeValue = getTextValue(bCursor.$text).substring(bCursor.offset);
+  }
+  const aBlock = getParentTextBlock(aCursor.$inline);
+  const bBlock = getParentTextBlock(bCursor.$inline);
+  if (aCursor.$inline !== bCursor.$inline && (isEmptyTextNode(bCursor.$text) || bCursor.$text === null && bCursor.isAfterInline === true)) {
+    bCursor.$inline.remove();
+  }
+  let trackingCursor;
+  if (isEmptyTextNode(aCursor.$text) || aCursor.$text === null && aCursor.isAfterInline !== true) {
+    const $sib = getNextSiblingTextContent(aCursor.$inline);
+    aCursor.$inline.remove();
+    if ($sib === null) {
+      trackingCursor = createEndCursorFromTextContent(getLastTextContent(aBlock));
+    } else {
+      trackingCursor = createBeginCursorFromTextContent($sib);
+    }
+  } else {
+    trackingCursor = createEndCursorFromTextContent(aCursor.$inline);
+  }
+  if (aBlock === bBlock) {
+    mergeNextTextContentSibling(trackingCursor.$inline, trackingCursor);
+    mergePrevTextContentSibling(trackingCursor.$inline, trackingCursor);
+  } else if (getNextSiblingTextBlock(aBlock) === bBlock) {
+    mergeNextTextBlock(aBlock, trackingCursor);
+  }
+  return trackingCursor;
+};
+export const deleteContentBackward = ($root, range) => {
+  const {
+    startContainer,
+    endContainer,
+    startOffset,
+    endOffset
+  } = range;
+  if (startContainer === endContainer && startOffset + 1 === endOffset && isTextNode(startContainer)) {
+    if (startContainer.length > 1) {
+      return DEFAULT_ACTION_RESULT;
+    }
+    if (startContainer.length === 1 && startContainer.nodeValue !== TEXT_EMPTY_DATA) {
+      startContainer.nodeValue = TEXT_EMPTY_DATA;
+      return {
+        prevent: true,
+        range: {
+          startContainer,
+          startOffset: 1,
+          endContainer: startContainer,
+          endOffset: 1
+        }
+      };
+    }
+    const $inline = getParentInline(startContainer);
+    const $block = getParentTextBlock($inline);
+    const childIndex = childIndexOf($block, $inline);
+    if (childIndex > 0) {
+      const $prevSib = getChildByIndex($block, childIndex - 1);
+      if (isInline($prevSib)) {
+        const $text = getChildText($prevSib);
+        return deleteContentBackward($root, {
+          startContainer: $text,
+          startOffset: $text.length - 1,
+          endContainer,
+          endOffset
+        });
+      }
+      return deleteContentBackward($root, {
+        startContainer: $block,
+        startOffset: childIndex - 1,
+        endContainer,
+        endOffset
+      });
+    }
+    const $prevBlock = getPrevSiblingTextBlock($block);
+    if ($prevBlock !== null) {
+      return deleteContentBackward($root, {
+        startContainer: $prevBlock,
+        startOffset: afterLastChildIndex($prevBlock),
+        endContainer,
+        endOffset
+      });
+    }
+  }
+  return {
+    prevent: true,
+    range: createCollapsedRange(removeContentInRange(range))
+  };
+};
+export const insertLink = ($root, text, href, range) => {
+  const cursor = removeContentInRange(range);
+  const {
+    $text,
+    $inline,
+    offset,
+    isAfterInline: isAfterLastChild
+  } = cursor;
+  const $link = createLink(text, href, $root.ownerDocument);
+  if (isTextNode($text)) {
+    if (isEmptyText($text.nodeValue)) {
+      getParentTextBlock($inline).replaceChild($link, $inline);
+    } else {
+      const [$before, $after] = splitTextNode($text, offset);
+      if ($before === null) {
+        assertNonNull($after);
+        $after.before($link);
+      } else {
+        $before.after($link);
+      }
+    }
+  } else if (isAfterLastChild === true) {
+    $inline.after($link);
+  } else {
+    $inline.before($link);
+  }
+  return {
+    prevent: true,
+    range: createCollapsedRange(createEndCursorFromTextContent($link))
+  };
+};
+export const insertLineBreak = range => {
+  const cursor = removeContentInRange(range);
+  const {
+    $text,
+    $inline,
+    offset,
+    isAfterInline: isAfterLastChild
+  } = cursor;
+  const $block = getParentTextBlock($inline);
+  if (isListItem($block)) {
+    if (isEmptyTextBlock($block)) {
+      convertToParagraph($block);
+      return {
+        prevent: true,
+        range: createCollapsedRange(createEndCursorFromTextContent(getLastTextContent($block)))
+      };
+    }
+  }
+  let splitIndex = 0;
+  if (isTextNode($text)) {
+    const [$before] = splitTextNode($text, offset);
+    splitIndex = $before !== null ? childIndexOf($block, $before) + 1 : 0;
+  } else {
+    splitIndex = childIndexOf($block, $inline) + (isAfterLastChild === true ? 1 : 0);
+  }
+  const [_, $bBlock] = splitTextBlock($block, splitIndex);
+  return {
+    prevent: true,
+    range: createCollapsedRange(createBeginCursorFromTextContent(getFirstTextContent($bBlock)))
+  };
+};
+const insertEmoji = ($root, emojiChar, range) => {
+  const cursor = removeContentInRange(range);
+  const {
+    $text,
+    $inline,
+    offset,
+    isAfterInline
+  } = cursor;
+  const baseUrl = getEmojiBaseUrl($root);
+  const $emoji = createEmoji(emojiChar, baseUrl, $root.ownerDocument);
+  if (isTextNode($text)) {
+    if (isEmptyText($text.nodeValue)) {
+      getParentTextBlock($inline).replaceChild($emoji, $inline);
+    } else {
+      const [$before, $after] = splitTextNode($text, offset);
+      if ($before === null) {
+        assertNonNull($after);
+        $after.before($emoji);
+      } else {
+        $before.after($emoji);
+      }
+    }
+  } else if (isAfterInline === true) {
+    $inline.after($emoji);
+  } else {
+    $inline.before($emoji);
+  }
+  return {
+    prevent: true,
+    range: createCollapsedRange(createEndCursorFromTextContent($emoji))
+  };
+};
+export const insertText = ($root, data, range) => {
+  if (data !== null && isEmojiString(data)) {
+    return insertEmoji($root, data, range);
+  }
+  if (range.startContainer === range.endContainer && range.startOffset === range.endOffset && isTextNode(range.startContainer) && !isEmptyText(range.startContainer.nodeValue)) {
+    const $inline = getParentInline(range.startContainer);
+    const isHotTextWhitespace = range.startOffset === range.startContainer.length && data === TEXT_WHITESPACE && (isFormatCodetag($inline) || isFormatLink($inline));
+    if (!isHotTextWhitespace) {
+      return DEFAULT_ACTION_RESULT;
+    }
+  }
+  const cursor = removeContentInRange(range);
+  if (data === null) {
+    return {
+      prevent: true,
+      range: createCollapsedRange(cursor)
+    };
+  }
+  const {
+    $text,
+    $inline,
+    offset,
+    isAfterInline
+  } = cursor;
+  if ($text === null && isEmoji($inline)) {
+    const $newInline = createInlineWithText(data, $root.ownerDocument);
+    if (isAfterInline === true) {
+      $inline.after($newInline);
+    } else {
+      $inline.before($newInline);
+    }
+    return {
+      prevent: true,
+      range: createCollapsedRange(createEndCursorFromTextContent($newInline))
+    };
+  }
+  if (isTextNode($text)) {
+    assertInline($inline);
+    if (isEmptyText($text.nodeValue)) {
+      $text.nodeValue = data;
+      return {
+        prevent: true,
+        range: createCollapsedRange(createCursorFromTextNode($text, data.length))
+      };
+    }
+    if (offset === $text.length && data === TEXT_WHITESPACE) {
+      if (isFormatLink($inline) || isFormatCodetag($inline)) {
+        const $newinline = createInlineWithText(data, $root.ownerDocument);
+        $inline.after($newinline);
+        return {
+          prevent: true,
+          range: createCollapsedRange(createEndCursorFromTextContent($newinline))
+        };
+      }
+    }
+    const content = $text.nodeValue;
+    $text.nodeValue = content.substring(0, offset) + data + content.substring(offset);
+    return {
+      prevent: true,
+      range: createCollapsedRange(createCursorFromTextNode($text, offset + data.length))
+    };
+  }
+  return {
+    prevent: true,
+    range: createCollapsedRange(cursor)
+  };
+};
+export const insertFromPaste = (data, range, visitor) => {
+  const cursor = removeContentInRange(range);
+  const {
+    $text,
+    $inline,
+    offset,
+    isAfterInline
+  } = cursor;
+  const $mdFragment = parseMarkdown(data, visitor);
+  if ($mdFragment.childNodes.length === 0) {
+    return {
+      prevent: true,
+      range
+    };
+  }
+  const shouldSpreadNodesIntoBlock = $mdFragment.childNodes.length === 1;
+  if (shouldSpreadNodesIntoBlock) {
+    const $block = getParentTextBlock($inline);
+    const $fragment = document.createDocumentFragment();
+    $fragment.append(...Array.from($mdFragment.childNodes[0].childNodes));
+    const $pasteLastChild = $fragment.lastChild;
+    if ($pasteLastChild !== null) {
+      assertTextContent($pasteLastChild);
+    }
+    if (isTextNode($text)) {
+      if (isEmptyText($text.nodeValue)) {
+        $block.replaceChild($fragment, $inline);
+      } else {
+        const [$before, $after] = splitTextNode($text, offset);
+        if ($before === null) {
+          assertNonNull($after);
+          $after.before($fragment);
+        } else {
+          $before.after($fragment);
+        }
+      }
+    } else if (isAfterInline === true) {
+      $inline.after($fragment);
+    } else {
+      $inline.before($fragment);
+    }
+    return {
+      prevent: true,
+      range: createCollapsedRange(createEndCursorFromTextContent($pasteLastChild ?? getLastTextContent($block)))
+    };
+  }
+  const $block = getParentTextBlock($inline);
+  let splitIndex = childIndexOf($block, $inline) + (isAfterInline === true ? 1 : 0);
+  if (isTextNode($text)) {
+    if (isEmptyText($text.nodeValue)) {
+      $inline.remove();
+    } else {
+      const [$before] = splitTextNode($text, offset);
+      if ($before !== null) {
+        splitIndex++;
+      }
+    }
+  }
+  const [$aBlock, $bBlock] = splitTextBlock($block, splitIndex);
+  const $root = $aBlock.parentElement;
+  const $lastBlock = $mdFragment.lastChild;
+  assertTextBlock($lastBlock);
+  if (isEmptyTextBlock($aBlock)) {
+    $root.replaceChild($mdFragment, $aBlock);
+    if (isEmptyTextBlock($bBlock)) {
+      $bBlock.remove();
+    }
+  } else if (isEmptyTextBlock($bBlock)) {
+    $root.replaceChild($mdFragment, $bBlock);
+  } else {
+    $aBlock.after($mdFragment);
+  }
+  return {
+    prevent: true,
+    range: createCollapsedRange(createEndCursorFromTextContent(getLastTextContent($lastBlock)))
+  };
+};
+const DEFAULT_ACTION_RESULT = {
+  prevent: false
+};
+export const handleEmojiMousedown = $n => {
+  if (isEmoji($n)) {
+    return {
+      prevent: true,
+      range: createCollapsedRange(createEndCursorFromTextContent($n))
+    };
+  }
+  return DEFAULT_ACTION_RESULT;
+};
+export const getBeginRange = $root => {
+  const $block = getFirstTextBlock($root);
+  const $inline = getFirstTextContent($block);
+  return createCollapsedRange(createBeginCursorFromTextContent($inline));
+};
+export const getEndRange = $root => {
+  const $block = getLastTextBlock($root);
+  const $inline = getLastTextContent($block);
+  return createCollapsedRange(createEndCursorFromTextContent($inline));
+};
+export const getSelectionInfo = range => {
+  const aCursor = createIncomingCursorFromNodeWithOffset(range.startContainer, range.startOffset);
+  const bCursor = createIncomingCursorFromNodeWithOffset(range.endContainer, range.endOffset);
+  if (aCursor.$inline === bCursor.$inline) {
+    const {
+      $text,
+      $inline
+    } = aCursor;
+    if ($text !== null || isInline($inline)) {
+      assertInline($inline);
+      return {
+        bold: isFormatBold($inline),
+        italic: isFormatItalic($inline),
+        strikethrough: isFormatStrikethrough($inline),
+        codetag: isFormatCodetag($inline),
+        link: isFormatLink($inline),
+        olist: isInsideList(true, $inline),
+        ulist: isInsideList(false, $inline)
+      };
+    }
+    return {
+      italic: false,
+      bold: false,
+      strikethrough: false,
+      codetag: false,
+      link: false,
+      olist: false,
+      ulist: false
+    };
+  }
+  return {
+    bold: isAllInsideBold(aCursor.$inline, bCursor.$inline),
+    italic: isAllInsideItalic(aCursor.$inline, bCursor.$inline),
+    strikethrough: isAllInsideStrikethrough(aCursor.$inline, bCursor.$inline),
+    codetag: isAllInsideCodetag(aCursor.$inline, bCursor.$inline),
+    link: isAllInsideLink(aCursor.$inline, bCursor.$inline),
+    olist: isAllInsideList(true, aCursor.$inline, bCursor.$inline),
+    ulist: isAllInsideList(false, aCursor.$inline, bCursor.$inline)
+  };
+};
+export const isSelectionEqual = (a, b) => {
+  return a === b || a !== null && b !== null && a.bold === b.bold && a.codetag === b.codetag && a.italic === b.italic && a.link === b.link && a.strikethrough === b.strikethrough && a.olist === b.olist && a.ulist === b.ulist;
+};
+const isEmptyTextBlock = $block => {
+  const blockChildren = $block.childNodes;
+  if (blockChildren.length > 1) {
+    return false;
+  }
+  const $inline = blockChildren[0];
+  const isEmptyText = isInline($inline) && !isFormatCodetag($inline) && isEmptyTextNode(getChildText($inline));
+  return isEmptyText;
+};
+export const isEditorEmpty = $root => {
+  const rootChildren = $root.childNodes;
+  if (rootChildren.length > 1) {
+    return false;
+  }
+  const $block = rootChildren[0];
+  assertTextBlock($block);
+  return isEmptyTextBlock($block);
+};
+const serializeDescriptorReducer = range => (state, $n) => {
+  if (isEmoji($n)) {
+    const text = $n.getAttribute(EMOJI_CHAR_ATTR_NAME) ?? '';
+    if (text.length > 0) {
+      state.push({
+        isEmoji: true,
+        text
+      });
+    }
+    return state;
+  }
+  let text = getTextValue(getChildText($n));
+  let trailingSpaces = '';
+  if (range !== null) {
+    const [aCursor, bCursor] = range;
+    const isACursorPointingHere = aCursor.$inline === $n;
+    const isBCursorPointingHere = bCursor.$inline === $n;
+    if (isACursorPointingHere && isBCursorPointingHere) {
+      text = text.substring(aCursor.offset, bCursor.offset);
+    } else if (isACursorPointingHere) {
+      text = text.substring(aCursor.offset);
+    } else if (isBCursorPointingHere) {
+      text = text.substring(0, bCursor.offset);
+    }
+  }
+  if (isEmptyText(text)) {
+    return state;
+  }
+  if (isFormatCodetag($n)) {
+    state.push({
+      isCodetag: true,
+      text
+    });
+    return state;
+  }
+  if (isFormatLink($n)) {
+    const href = $n.getAttribute(LINK_HREF_ATTR_NAME) ?? '#';
+    state.push({
+      isLink: true,
+      text,
+      href
+    });
+    return state;
+  }
+  const leadingNonSpaceIndex = text.search(/\S/);
+  if (leadingNonSpaceIndex < 0) {
+    state.push({
+      isWhitespace: true,
+      text
+    });
+    return state;
+  }
+  if (leadingNonSpaceIndex > 0) {
+    state.push({
+      isWhitespace: true,
+      text: text.substring(0, leadingNonSpaceIndex)
+    });
+    text = text.substring(leadingNonSpaceIndex);
+  }
+  const trailingSpaceIndex = text.search(/\s+$/);
+  if (trailingSpaceIndex >= 0) {
+    trailingSpaces = text.substring(trailingSpaceIndex);
+    text = text.substring(0, trailingSpaceIndex);
+  }
+  state.push({
+    isBold: isFormatBold($n),
+    isItalic: isFormatItalic($n),
+    isStrikethrough: isFormatStrikethrough($n),
+    text
+  });
+  if (trailingSpaces.length > 0) {
+    state.push({
+      isWhitespace: true,
+      text: trailingSpaces
+    });
+  }
+  return state;
+};
+const MD_STRIKE_TOKEN = '~~';
+const MD_EM3_STAR_TOKEN = '***';
+const MD_EM2_STAR_TOKEN = '**';
+const MD_EM1_STAR_TOKEN = '*';
+const MD_EM3_UNDERSCORE_TOKEN = '___';
+const MD_EM2_UNDERSCORE_TOKEN = '__';
+const MD_EM1_UNDERSCORE_TOKEN = '_';
+const MD_LINEBREAK_TOKEN = '  \n';
+const MD_CODETAG_TOKEN = '`';
+const MD_ULISTITEM_TOKEN = '*';
+const MD_OLISTITEM_TOKEN = '1.';
+const MD_LISTITEM_JOIN = '\n';
+const MD_PARAGRAPH_JOIN = '\n\n';
+const serializeTextReducer = (state, desc, i, descArray) => {
+  const {
+    chunks
+  } = state;
+  if (desc.isLink === true) {
+    chunks.push(`[${desc.text}](${desc.href})`);
+    return state;
+  }
+  if (desc.isEmoji === true) {
+    chunks.push(desc.text);
+    return state;
+  }
+  if (desc.isCodetag === true) {
+    chunks.push(`${MD_CODETAG_TOKEN}${desc.text}${MD_CODETAG_TOKEN}`);
+    return state;
+  }
+  if (desc.isWhitespace === true) {
+    chunks.push(desc.text);
+    return state;
+  }
+  const prev = i === 0 ? null : descArray[i - 1];
+  const next = i >= descArray.length - 1 ? null : descArray[i + 1];
+  const shouldUseUnderscores = (i - state.lastUnderscoreIndex) % 2 === 0 && (prev === null || prev.isBold === true || prev.isItalic === true || prev.isWhitespace === true || prev.isCodetag === true) && (next === null || next.isBold === true || next.isItalic === true || next.isWhitespace === true || next.isCodetag === true);
+  const {
+    isBold,
+    isItalic,
+    isStrikethrough
+  } = desc;
+  if (shouldUseUnderscores) {
+    state.lastUnderscoreIndex = i;
+  }
+  if (isStrikethrough === true && (prev === null || prev.isStrikethrough !== true)) {
+    chunks.push(MD_STRIKE_TOKEN);
+  }
+  if (isBold === true && isItalic === true) {
+    chunks.push(shouldUseUnderscores ? MD_EM3_UNDERSCORE_TOKEN : MD_EM3_STAR_TOKEN);
+  } else if (isBold === true) {
+    chunks.push(shouldUseUnderscores ? MD_EM2_UNDERSCORE_TOKEN : MD_EM2_STAR_TOKEN);
+  } else if (isItalic === true) {
+    chunks.push(shouldUseUnderscores ? MD_EM1_UNDERSCORE_TOKEN : MD_EM1_STAR_TOKEN);
+  }
+  chunks.push(desc.text);
+  if (isBold === true && isItalic === true) {
+    chunks.push(shouldUseUnderscores ? MD_EM3_UNDERSCORE_TOKEN : MD_EM3_STAR_TOKEN);
+  } else if (isBold === true) {
+    chunks.push(shouldUseUnderscores ? MD_EM2_UNDERSCORE_TOKEN : MD_EM2_STAR_TOKEN);
+  } else if (isItalic === true) {
+    chunks.push(shouldUseUnderscores ? MD_EM1_UNDERSCORE_TOKEN : MD_EM1_STAR_TOKEN);
+  }
+  if (isStrikethrough === true && (next === null || next.isStrikethrough !== true)) {
+    chunks.push(MD_STRIKE_TOKEN);
+  }
+  return state;
+};
+const serializeTextBlock = ($n, range) => {
+  let children;
+  if (range !== null) {
+    const [aCursor, bCursor] = range;
+    const aBlock = getParentTextBlock(aCursor.$inline);
+    const bBlock = getParentTextBlock(bCursor.$inline);
+    const startIndex = aBlock === $n ? childIndexOf($n, aCursor.$inline) : 0;
+    const endIndex = bBlock === $n ? childIndexOf($n, bCursor.$inline) + 1 : $n.childNodes.length;
+    children = Array.prototype.slice.call($n.childNodes, startIndex, endIndex);
+  } else {
+    children = Array.from($n.childNodes);
+  }
+  const result = children.reduce(serializeDescriptorReducer(range), []).reduce(serializeTextReducer, {
+    lastUnderscoreIndex: 0,
+    chunks: []
+  });
+  return result.chunks.join('');
+};
+const serializeListItemIndent = (level, isOrderedStack) => {
+  let res = '';
+  for (let i = 0; i < level; i++) {
+    res = res.concat(isOrderedStack[i] ? '  ' : ' ', ' ');
+  }
+  return res;
+};
+const serializeListItem = ($li, isOrderedStack, range) => {
+  const isOrdered = isOrderedListItem($li);
+  const listMdToken = isOrdered ? MD_OLISTITEM_TOKEN : MD_ULISTITEM_TOKEN;
+  const level = getListItemLevel($li);
+  isOrderedStack[level] = isOrdered;
+  return `${serializeListItemIndent(level, isOrderedStack)}${listMdToken} ${serializeTextBlock($li, range)}`;
+};
+const serializeRoot = ($root, range) => {
+  let children;
+  if (range !== null) {
+    const [aCursor, bCursor] = range;
+    const aBlock = getParentTextBlock(aCursor.$inline);
+    const bBlock = getParentTextBlock(bCursor.$inline);
+    const startIndex = childIndexOf($root, aBlock);
+    const endIndex = childIndexOf($root, bBlock) + 1;
+    children = Array.prototype.slice.call($root.childNodes, startIndex, endIndex);
+  } else {
+    children = Array.from($root.childNodes);
+  }
+  const chunks = [];
+  const listChunks = [];
+  const listIsOrderedStack = [];
+  const paragraphChunks = [];
+  const flushListChunks = () => {
+    if (listChunks.length > 0) {
+      chunks.push(listChunks.join(MD_LISTITEM_JOIN));
+      listChunks.length = 0;
+    }
+  };
+  const flushParagraphChunks = () => {
+    if (paragraphChunks.length > 0) {
+      chunks.push(paragraphChunks.reduce((a, b) => {
+        return b.length > 0 ? a.concat(MD_LINEBREAK_TOKEN, b) : a.concat('<br>');
+      }));
+      paragraphChunks.length = 0;
+    }
+  };
+  for (let i = 0; i < children.length; i++) {
+    const $child = children[i];
+    if (isListItem($child)) {
+      flushParagraphChunks();
+      const isMainList = i === 0 || !isListItem(children[i - 1]) || isListItemMarkedArBlock($child);
+      if (isMainList) {
+        flushListChunks();
+      }
+      listChunks.push(serializeListItem($child, listIsOrderedStack, range));
+    } else {
+      assertTextBlock($child);
+      flushListChunks();
+      paragraphChunks.push(serializeTextBlock($child, range));
+    }
+  }
+  flushListChunks();
+  flushParagraphChunks();
+  return chunks.join(MD_PARAGRAPH_JOIN);
+};
+export const serializeMarkdown = ($root, range) => {
+  if (range !== null) {
+    const aCursor = createIncomingCursorFromNodeWithOffset(range.startContainer, range.startOffset);
+    const bCursor = createIncomingCursorFromNodeWithOffset(range.endContainer, range.endOffset);
+    return serializeRoot($root, [aCursor, bCursor]);
+  }
+  return serializeRoot($root, null);
+};
+export const createParseVisitor = doc => {
+  let emojiBaseUrl = null;
+  return {
+    updateEmojiBaseUrl(url) {
+      emojiBaseUrl = url;
+    },
+    createVisitor() {
+      const $root = doc.createDocumentFragment();
+      let $currentBlock = null;
+      const listsStack = [];
+      let isFirstListItem = false;
+      return {
+        emoji(emojiChar) {
+          const $emoji = createEmoji(emojiChar, emojiBaseUrl, doc);
+          $currentBlock.appendChild($emoji);
+        },
+        codetag(text) {
+          const $inline = createInlineWithText(text, doc);
+          setInlineFormat($inline, 'c', true);
+          $currentBlock.appendChild($inline);
+        },
+        inline(text, _ref2) {
+          let {
+            isBold,
+            isItalic,
+            isStrikethrough
+          } = _ref2;
+          const $inline = createInlineWithText(text, doc);
+          setInlineFormat($inline, 'b', isBold === true);
+          setInlineFormat($inline, 'i', isItalic === true);
+          setInlineFormat($inline, 's', isStrikethrough === true);
+          $currentBlock.appendChild($inline);
+        },
+        linebreak() {
+          if (listsStack.length === 0) {
+            $currentBlock = createActuallyEmptyParagraph(doc);
+            $root.appendChild($currentBlock);
+          }
+        },
+        link(text, href) {
+          const $link = createLink(text, href, doc);
+          $currentBlock.appendChild($link);
+        },
+        list(isOrdered) {
+          listsStack.push({
+            isOrdered
+          });
+          isFirstListItem = true;
+          $currentBlock = null;
+        },
+        endList() {
+          listsStack.length = listsStack.length - 1;
+          isFirstListItem = false;
+          $currentBlock = null;
+        },
+        listItem() {
+          const listLevel = listsStack.length - 1;
+          const {
+            isOrdered
+          } = listsStack.at(-1);
+          const $li = createActuallyEmptyListItem(isOrdered, listLevel, doc);
+          if (listsStack.length === 1 && isFirstListItem) {
+            markListItemAsBlock($li);
+            isFirstListItem = false;
+          }
+          $root.appendChild($li);
+          $currentBlock = $li;
+        },
+        paragraph() {
+          if (listsStack.length === 0) {
+            $currentBlock = createActuallyEmptyParagraph(doc);
+            $root.appendChild($currentBlock);
+          }
+        },
+        end() {
+          const children = $root.childNodes;
+          for (let i = 0; i < children.length; i++) {
+            const child = children[i];
+            assertTextBlock(child);
+            ensureCorrectTextBlockIfEmpty(child);
+          }
+          return $root;
+        }
+      };
+    }
+  };
+};
+export const setBrowserCaret = _ref3 => {
+  let {
+    startContainer,
+    startOffset,
+    endContainer,
+    endOffset
+  } = _ref3;
+  const selection = document.getSelection();
+  if (selection === null) {
+    return;
+  }
+  selection.removeAllRanges();
+  const range = document.createRange();
+  range.setStart(startContainer, startOffset);
+  range.setEnd(endContainer, endOffset);
+  selection.addRange(range);
+};