dragon-editor 3.8.6 → 4.0.0

package/dist/runtime/utils/data/cursor.js

@@ -0,0 +1,137 @@
+import { useEditorStore } from "../../store/editor.js";
+export function _getMultilinePosition(element) {
+  const editorStore = useEditorStore();
+  let position = { curruntLine: 1, lineCount: 1 };
+  if (editorStore.cursorSelection !== null && editorStore.cursorSelection.rangeCount !== 0) {
+    const range = editorStore.cursorSelection.getRangeAt(0);
+    const elemRect = element.getBoundingClientRect();
+    const computedStyle = window.getComputedStyle(element);
+    const paddingTop = parseFloat(computedStyle.paddingTop) || 0;
+    const paddingBottom = parseFloat(computedStyle.paddingBottom) || 0;
+    const elemTop = elemRect.top + paddingTop;
+    const elementHeight = Math.floor(elemRect.height - paddingTop - paddingBottom);
+    let rect = range.getBoundingClientRect();
+    let lineHeight = parseInt(computedStyle.lineHeight);
+    if (rect.height === 0) {
+      const rects = range.getClientRects();
+      if (rects.length > 0) {
+        rect = rects[0];
+      }
+    }
+    if (isNaN(lineHeight) == true) {
+      lineHeight = parseFloat(computedStyle.fontSize) * 1.2;
+    }
+    position.curruntLine = Math.floor((rect.top - paddingTop - elemTop) / lineHeight) + 1;
+    position.lineCount = Math.floor(elementHeight / lineHeight);
+    if (position.curruntLine < 1) {
+      position.curruntLine = 1;
+    }
+    if (position.lineCount < 1) {
+      position.lineCount = 1;
+    }
+  }
+  return position;
+}
+export function _getBeforeAndAfterHTMLOfCursor($target) {
+  const editorStore = useEditorStore();
+  const data = { beforeHTML: "", afterHTML: "" };
+  if (editorStore.cursorSelection !== null) {
+    const range = editorStore.cursorSelection.getRangeAt(0);
+    const cloneRangeBefore = range.cloneRange();
+    const cloneRangeAfter = range.cloneRange();
+    cloneRangeBefore.selectNodeContents($target);
+    cloneRangeBefore.setEnd(range.endContainer, range.endOffset);
+    cloneRangeAfter.selectNodeContents($target);
+    cloneRangeAfter.setStart(range.endContainer, range.endOffset);
+    const fragmentBefore = cloneRangeBefore.cloneContents();
+    const tempDivBefore = document.createElement("div");
+    const fragmentAfter = cloneRangeAfter.cloneContents();
+    const tempDivAfter = document.createElement("div");
+    tempDivBefore.appendChild(fragmentBefore);
+    tempDivAfter.appendChild(fragmentAfter);
+    data.beforeHTML = tempDivBefore.innerHTML;
+    data.afterHTML = tempDivAfter.innerHTML === "<br>" ? "" : tempDivAfter.innerHTML;
+  }
+  return data;
+}
+export function _isCursorAtLineBoundary() {
+  const editorStore = useEditorStore();
+  const result = { isStart: false, isEnd: false };
+  if (editorStore.cursorSelection !== null) {
+    if (editorStore.cursorSelection.rangeCount === 0) {
+      return result;
+    }
+    const originalRange = editorStore.cursorSelection.getRangeAt(0).cloneRange();
+    try {
+      let currentRect = originalRange.getBoundingClientRect();
+      if (currentRect.height === 0) {
+        const rects = originalRange.getClientRects();
+        if (rects.length > 0) {
+          currentRect = rects[0];
+        }
+      }
+      const currentTop = currentRect.top;
+      editorStore.cursorSelection.modify("move", "left", "character");
+      let leftRect = editorStore.cursorSelection.getRangeAt(0).getBoundingClientRect();
+      if (leftRect.height === 0) {
+        const rects = editorStore.cursorSelection.getRangeAt(0).getClientRects();
+        if (rects.length > 0) {
+          leftRect = rects[0];
+        }
+      }
+      if (leftRect.top < currentTop - 5 || leftRect.top === currentTop && leftRect.left === currentRect.left) {
+        result.isStart = true;
+      }
+      editorStore.cursorSelection.removeAllRanges();
+      editorStore.cursorSelection.addRange(originalRange);
+      editorStore.cursorSelection.modify("move", "right", "character");
+      let rightRect = editorStore.cursorSelection.getRangeAt(0).getBoundingClientRect();
+      if (rightRect.height === 0) {
+        const rects = editorStore.cursorSelection.getRangeAt(0).getClientRects();
+        if (rects.length > 0) {
+          rightRect = rects[0];
+        }
+      }
+      if (rightRect.top > currentTop + 5 || rightRect.top === currentTop && rightRect.left === currentRect.left) {
+        result.isEnd = true;
+      }
+    } catch (e) {
+      console.error("[Dragon Editor]: Failed to check cursor line boundary", e);
+    } finally {
+      editorStore.cursorSelection.removeAllRanges();
+      editorStore.cursorSelection.addRange(originalRange);
+    }
+  }
+  return result;
+}
+export function _getEditorbleEndPosition($element) {
+  const data = { nodeIndex: 0, offset: 0 };
+  const lastIndex = $element.childNodes.length - 1;
+  const $lastChild = $element.childNodes[lastIndex];
+  if ($lastChild !== void 0) {
+    data.nodeIndex = lastIndex;
+    data.offset = $lastChild.textContent?.length ?? 0;
+  }
+  return data;
+}
+export function _getEditorbleCursorPosition($element) {
+  const editorStore = useEditorStore();
+  const data = { nodeIndex: 0, offset: 0 };
+  if (editorStore.cursorSelection !== null && editorStore.cursorSelection.rangeCount > 0) {
+    const range = editorStore.cursorSelection.getRangeAt(0);
+    let container = range.startContainer;
+    if (container === $element) {
+      data.nodeIndex = range.startOffset;
+      data.offset = 0;
+    } else {
+      while (container.parentNode !== null && container.parentNode !== $element) {
+        container = container.parentNode;
+      }
+      if (container.parentNode === $element) {
+        data.nodeIndex = Array.prototype.indexOf.call($element.childNodes, container);
+        data.offset = range.startOffset;
+      }
+    }
+  }
+  return data;
+}

package/dist/runtime/utils/data/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./block.js";
+export * from "./cursor.js";
+export * from "./node.js";
+export declare function _generateId(): string;
+export declare function _isStrictlyEqualArrays(arr1: any[], arr2: any[]): boolean;

package/dist/runtime/utils/data/index.js

@@ -0,0 +1,17 @@
+export * from "./block.js";
+export * from "./cursor.js";
+export * from "./node.js";
+export function _generateId() {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let str = "";
+  for (let i = 0; i < 6; i += 1) {
+    str += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return str;
+}
+export function _isStrictlyEqualArrays(arr1, arr2) {
+  if (arr1.length !== arr2.length) {
+    return false;
+  }
+  return arr1.every((value, index) => value === arr2[index]);
+}

package/dist/runtime/utils/data/node.d.ts

@@ -0,0 +1,9 @@
+export declare function _arrangementNodeList(list: Node[], cursorStartNode: Node | null, cursorStartNodeOffset: number, cursorEndNode: Node | null, cursorEndNodeOffset: number): {
+    list: Node[];
+    cursorStartNode: Node | null;
+    cursorStartNodeOffset: number;
+    cursorEndNode: Node | null;
+    cursorEndNodeOffset: number;
+};
+export declare function _findHiddenStyleElement($target: HTMLElement): HTMLElement | null;
+export declare function _findScrollingElement($target: HTMLElement): HTMLElement | Window;

package/dist/runtime/utils/data/node.js

@@ -0,0 +1,101 @@
+import { _isStrictlyEqualArrays } from "./index.js";
+export function _arrangementNodeList(list, cursorStartNode, cursorStartNodeOffset, cursorEndNode, cursorEndNodeOffset) {
+  const arrangementNodeList = [];
+  list.forEach((node) => {
+    if (arrangementNodeList.length === 0) {
+      arrangementNodeList.push(node);
+    } else {
+      if (node !== void 0 && node !== null && node.textContent !== "") {
+        const prevNode = arrangementNodeList[arrangementNodeList.length - 1];
+        if (prevNode.nodeType === Node.TEXT_NODE && node.nodeType === Node.TEXT_NODE) {
+          if (prevNode.textContent !== null && node.textContent !== null) {
+            if (cursorStartNode === node) {
+              cursorStartNode = prevNode;
+              cursorStartNodeOffset += prevNode.textContent.length;
+            }
+            if (cursorEndNode === node) {
+              cursorEndNode = prevNode;
+              cursorEndNodeOffset += prevNode.textContent.length;
+            }
+            prevNode.textContent += node.textContent;
+          }
+        } else if (prevNode.nodeType === Node.ELEMENT_NODE && node.nodeType === Node.ELEMENT_NODE) {
+          const $prevNode = prevNode;
+          const $node = node;
+          if ($prevNode.tagName === "A" && $node.tagName === "A") {
+            if ($prevNode.href === $node.href) {
+              if (cursorStartNode !== null && cursorStartNode.parentElement === $node) {
+                cursorStartNode = $prevNode;
+                cursorStartNodeOffset += $prevNode.textContent.length;
+              }
+              if (cursorEndNode !== null && cursorEndNode.parentElement === $node) {
+                cursorEndNode = $prevNode;
+                cursorEndNodeOffset += $prevNode.textContent.length;
+              }
+              $prevNode.textContent += $node.textContent;
+            } else {
+              arrangementNodeList.push(node);
+            }
+          } else {
+            if (_isStrictlyEqualArrays(Array.from($prevNode.classList), Array.from($node.classList)) === true) {
+              if (cursorStartNode !== null && cursorStartNode.parentElement === $node) {
+                cursorStartNode = $prevNode;
+                cursorStartNodeOffset += $prevNode.textContent.length;
+              }
+              if (cursorEndNode !== null && cursorEndNode.parentElement === $node) {
+                cursorEndNode = $prevNode;
+                cursorEndNodeOffset += $prevNode.textContent.length;
+              }
+              $prevNode.textContent += $node.textContent;
+            } else {
+              arrangementNodeList.push(node);
+            }
+          }
+        } else {
+          arrangementNodeList.push(node);
+        }
+      }
+    }
+  });
+  return {
+    list: arrangementNodeList,
+    cursorStartNode,
+    cursorStartNodeOffset,
+    cursorEndNode,
+    cursorEndNodeOffset
+  };
+}
+export function _findHiddenStyleElement($target) {
+  const $wrap = $target.parentElement;
+  if ($wrap !== null) {
+    const style = window.getComputedStyle($wrap);
+    if (style.overflow === "hidden") {
+      return $wrap;
+    } else {
+      if ($wrap.tagName === "HTML") {
+        return null;
+      } else {
+        return _findHiddenStyleElement($wrap);
+      }
+    }
+  } else {
+    return null;
+  }
+}
+export function _findScrollingElement($target) {
+  const $wrap = $target.parentElement;
+  if ($wrap !== null) {
+    const style = window.getComputedStyle($wrap);
+    if (style.overflow !== "visible" && style.overflow !== "hidden") {
+      return $wrap;
+    } else {
+      if ($wrap.tagName === "BODY") {
+        return window;
+      } else {
+        return _findScrollingElement($wrap);
+      }
+    }
+  } else {
+    return window;
+  }
+}

package/dist/runtime/utils/event/cursor.d.ts

@@ -1,6 +1,3 @@
-import type { Ref } from "vue";
-import type { DEArrangeCursorData, DEditorCursor, DragonEditorStore } from "../../type.d.mts.js";
-export declare function _updateCursorData(store: Ref<DragonEditorStore>): void;
-export declare function _setCursor($target: Node, startIdx: number): void;
-export declare function _setRangeCursor($startTarget: Element, $endTarget: Element, startIdx: number, endIdx: number): void;
-export declare function _sortingCursorDataOnElement(cursorData: DEditorCursor, $element: HTMLElement): DEArrangeCursorData;
+export declare function _updateCursorData(): void;
+export declare function _setCursorPosition(node: Node, offset: number): void;
+export declare function _setRangeCursorPosition(startNode: Node, startNodeOffset: number, endNode: Node, endNodeOffset: number): void;

package/dist/runtime/utils/event/cursor.js

@@ -1,120 +1,67 @@
-export function _updateCursorData(store) {
-  const selection = window.getSelection();
-  if (selection.type !== "None") {
-    store.value.cursorData = {
-      type: selection.type,
-      startNode: selection.anchorNode,
-      startOffset: selection.anchorOffset,
-      endNode: selection.focusNode,
-      endOffset: selection.focusOffset
-    };
-  }
-}
-export function _setCursor($target, startIdx) {
-  const range = document.createRange();
-  const selection = window.getSelection();
-  if ($target.constructor.name === "Text") {
-    range.setStart($target, startIdx);
-  } else {
-    if ($target.hasChildNodes() === true) {
-      if ($target.textContent === "") {
-        range.setStart($target.childNodes[startIdx], 0);
+import { useEditorStore } from "../../store/editor.js";
+export function _updateCursorData() {
+  const editorStore = useEditorStore();
+  if (window !== void 0) {
+    editorStore.cursorSelection = null;
+    editorStore.cursorSelection = window.getSelection();
+    if (editorStore.cursorSelection.rangeCount > 0) {
+      const range = editorStore.cursorSelection.getRangeAt(0);
+      editorStore.cursorRange = range.cloneRange();
+      if (range.startContainer === range.endContainer) {
+        if (range.startContainer.nodeType === Node.TEXT_NODE) {
+          const $parentElement = range.startContainer.parentElement;
+          if ($parentElement !== null && $parentElement.tagName === "A") {
+            editorStore.status.anchorHerf = $parentElement.href;
+          } else {
+            editorStore.status.anchorHerf = "";
+          }
+        }
       } else {
-        range.setStart($target.childNodes[0], startIdx);
+        editorStore.status.anchorHerf = "";
       }
-    } else {
-      range.setStart($target, startIdx);
     }
+  } else {
+    console.error("[Dragon Editor]: It's not client environment");
   }
-  selection.removeAllRanges();
-  selection.addRange(range);
 }
-export function _setRangeCursor($startTarget, $endTarget, startIdx, endIdx) {
-  const range = document.createRange();
-  const selection = window.getSelection();
-  if ($startTarget.constructor.name === "Text") {
-    range.setStart($startTarget, startIdx);
-  } else {
-    if ($startTarget.hasChildNodes() === true) {
-      if ($startTarget.textContent === "") {
-        range.setStart($startTarget.childNodes[startIdx], 0);
+export function _setCursorPosition(node, offset) {
+  const editorStore = useEditorStore();
+  if (editorStore.cursorSelection !== null) {
+    if (node.nodeType !== Node.TEXT_NODE) {
+      if (node.childNodes.length !== 0) {
+        node = node.childNodes[0];
       } else {
-        range.setStart($startTarget.childNodes[0], startIdx);
+        offset = 0;
       }
-    } else {
-      range.setStart($startTarget, startIdx);
     }
+    editorStore.cursorSelection.removeAllRanges();
+    const range = document.createRange();
+    range.setStart(node, offset);
+    range.setEnd(node, offset);
+    editorStore.cursorSelection.addRange(range);
   }
-  if ($endTarget.constructor.name === "Text") {
-    range.setEnd($endTarget, endIdx);
-  } else {
-    if ($endTarget.hasChildNodes() === true) {
-      if ($endTarget.textContent === "") {
-        range.setEnd($endTarget.childNodes[endIdx], 0);
+}
+export function _setRangeCursorPosition(startNode, startNodeOffset, endNode, endNodeOffset) {
+  const editorStore = useEditorStore();
+  if (editorStore.cursorSelection !== null) {
+    editorStore.cursorSelection.removeAllRanges();
+    const newRange = document.createRange();
+    if (startNode.nodeType !== Node.TEXT_NODE) {
+      if (startNode.childNodes.length !== 0) {
+        startNode = startNode.childNodes[0];
       } else {
-        range.setEnd($endTarget.childNodes[0], endIdx);
+        startNodeOffset = 0;
       }
-    } else {
-      range.setEnd($endTarget, endIdx);
     }
-  }
-  selection.removeAllRanges();
-  selection.addRange(range);
-}
-export function _sortingCursorDataOnElement(cursorData, $element) {
-  const childList = $element.childNodes;
-  let startNode = cursorData.startNode;
-  let startIdx = -1;
-  let startOffset = cursorData.startOffset;
-  let endNode = cursorData.endNode;
-  let endIdx = -1;
-  let endOffset = cursorData.endOffset;
-  if (startNode.constructor.name === "Text") {
-    if (startNode.parentElement !== $element) {
-      startNode = startNode.parentElement;
-    }
-  }
-  if (endNode.constructor.name === "Text") {
-    if (endNode.parentElement !== $element) {
-      endNode = endNode.parentElement;
-    }
-  }
-  for (let i = 0; childList.length > i; i += 1) {
-    if (startIdx !== -1 && endIdx !== -1) {
-      break;
-    }
-    if (startNode === childList[i]) {
-      startIdx = i;
-    }
-    if (endNode === childList[i]) {
-      endIdx = i;
-    }
-  }
-  if (startIdx === endIdx) {
-    if (cursorData.startOffset > cursorData.endOffset) {
-      startOffset = cursorData.endOffset;
-      endOffset = cursorData.startOffset;
-    }
-  } else {
-    if (startIdx > endIdx) {
-      const originStartNode = startNode;
-      const originStartIdx = startIdx;
-      const originEndNode = endNode;
-      const originEndIdx = endIdx;
-      startNode = originEndNode;
-      startIdx = originEndIdx;
-      startOffset = cursorData.endOffset;
-      endNode = originStartNode;
-      endIdx = originStartIdx;
-      endOffset = cursorData.startOffset;
+    if (endNode.nodeType !== Node.TEXT_NODE) {
+      if (endNode.childNodes.length !== 0) {
+        endNode = endNode.childNodes[0];
+      } else {
+        endNodeOffset = 0;
+      }
     }
+    newRange.setStart(startNode, startNodeOffset);
+    newRange.setEnd(endNode, endNodeOffset);
+    editorStore.cursorSelection.addRange(newRange);
   }
-  return {
-    startNode,
-    startNodeIdx: startIdx,
-    startOffset,
-    endNode,
-    endNodeIdx: endIdx,
-    endOffset
-  };
 }

package/dist/runtime/utils/event/index.d.ts

@@ -1,8 +1,4 @@
 export * from "./keyboard.js";
-export * from "./mouse.js";
-export * from "./touch.js";
-export * from "./data.js";
-export * from "./window.js";
-export * from "./scroll.js";
 export * from "./cursor.js";
-export * from "./block.js";
+export declare function _editorMountedEvent(): void;
+export declare function _eidtorUnmountEvent(): void;

package/dist/runtime/utils/event/index.js

@@ -1,8 +1,50 @@
 export * from "./keyboard.js";
-export * from "./mouse.js";
-export * from "./touch.js";
-export * from "./data.js";
-export * from "./window.js";
-export * from "./scroll.js";
 export * from "./cursor.js";
-export * from "./block.js";
+import { useEditorStore } from "../../store/editor.js";
+import { _findHiddenStyleElement, _findScrollingElement } from "../data/index.js";
+export function _editorMountedEvent() {
+  const editorStore = useEditorStore();
+  if (editorStore.element.editor !== null) {
+    const $scrollParent = _findScrollingElement(editorStore.element.editor);
+    const $hiddenStyleElement = _findHiddenStyleElement(editorStore.element.editor);
+    editorStore.status.isParentOverflowHidden = $hiddenStyleElement !== null;
+    editorStore.element.scrollParentElement = $scrollParent;
+    if (editorStore.element.scrollParentElement !== null) {
+      editorStore.element.scrollParentElement.addEventListener("scroll", parentElementScrollEvent);
+    }
+  }
+}
+export function _eidtorUnmountEvent() {
+  const editorStore = useEditorStore();
+  if (editorStore.element.scrollParentElement !== null) {
+    editorStore.element.scrollParentElement.removeEventListener("scroll", parentElementScrollEvent);
+  }
+}
+function parentElementScrollEvent() {
+  const editorStore = useEditorStore();
+  if (editorStore.element.scrollParentElement !== null && editorStore.element.editor !== null) {
+    const editorRect = editorStore.element.editor.getBoundingClientRect();
+    const $scrollElement = editorStore.element.scrollParentElement;
+    let scrollY = 0;
+    let value = 0;
+    if ($scrollElement instanceof Window) {
+      scrollY = $scrollElement.scrollY;
+    } else {
+      scrollY = $scrollElement.scrollTop;
+    }
+    let realElementY = editorRect.y + scrollY;
+    if ($scrollElement instanceof HTMLElement) {
+      const parentRect = $scrollElement.getBoundingClientRect();
+      realElementY -= parentRect.y;
+    }
+    if (scrollY > realElementY) {
+      value = scrollY - realElementY - 1;
+    } else {
+      value = 0;
+    }
+    if (value > editorRect.height - 34) {
+      value = editorRect.height - 34;
+    }
+    editorStore.status.menuTop = Math.floor(value);
+  }
+}

package/dist/runtime/utils/event/keyboard.d.ts

@@ -1,7 +1,22 @@
-import type { Ref } from "vue";
-import type { DragonEditorStore } from "../../type.d.mts.js";
-export declare function _contentKeydownEvent(event: KeyboardEvent, store: Ref<DragonEditorStore>): void;
-export declare function _contentPasteEvent(event: ClipboardEvent, store: Ref<DragonEditorStore>): Promise<void>;
-export declare function _setIndent(store: Ref<DragonEditorStore>, type: "plus" | "minus"): void;
-export declare function _hotKeyEvent(event: KeyboardEvent, store: Ref<DragonEditorStore>): void;
-export declare function _contentKeyupEvent(event: KeyboardEvent, store: Ref<DragonEditorStore>): void;
+import type { DETextBlock, DEHeadingBlock } from "../../type.d.mts.js";
+export declare function _sliceAndNewTextBlock(event: KeyboardEvent, data: DETextBlock | DEHeadingBlock, index: number): Promise<void>;
+export declare function _imageEnterEvent(event: KeyboardEvent, data: DEImageBlock, index: number): Promise<void>;
+export declare function _listBlockEnterEvent(event: KeyboardEvent, data: DEListBlock, index: number, childIndex: number, setEvent: (liIndex: number, id: string) => void, abortEvent: Function): Promise<void>;
+export declare function _codeBlockShiftEnterEvent(event: KeyboardEvent, index: number): Promise<void>;
+export declare function _blockTabEvent(event: KeyboardEvent, data: DETextBlock | DEHeadingBlock, index: number, setEvent: Function, abortEvent: Function): Promise<void>;
+export declare function _listChildTabEvent(event: KeyboardEvent, data: DEListBlock, index: number, childIndex: number, setEvent: (liIndex: number, id: string) => void, abortEvent: Function): Promise<void>;
+export declare function _codeBlockTabEvent(event: KeyboardEvent): Promise<void>;
+export declare function _moveBlockDefaultEvent(event: KeyboardEvent, type: "up" | "down"): void;
+export declare function _moveListChildEvent(event: KeyboardEvent, data: DEListBlock, index: number, childIndex: number, type: "up" | "down"): void;
+export declare function _moveCodeBlockEvent(event: KeyboardEvent, direction: "up" | "down", type: "filename" | "content", $targetElement: HTMLElement): void;
+export declare function _defaultBackspaceEvent(event: KeyboardEvent): Promise<void>;
+export declare function _listBackspaceEvent(event: KeyboardEvent, childIndex: number): Promise<void>;
+export declare function _defaultDeleteEvent(event: KeyboardEvent, setEvent: (index: number, id: string) => void, abortEvent: Function): Promise<void>;
+export declare function _listDeleteEvent(event: KeyboardEvent, childIndex: number, setEvent: (liIndex: number, id: string) => void, abortEvent: Function): Promise<void>;
+export declare function _allDataPasteEvent(event: ClipboardEvent, setEvent: Function, abortEvent: Function): Promise<void>;
+export declare function _normalPasteEvent(event: ClipboardEvent, setEvent: Function, abortEvent: Function): Promise<void>;
+export declare function _convertTextBlockType(event: KeyboardEvent, data: DETextBlock, index: number): Promise<void>;
+export declare function _convertTextBlockToCodeBlock(event: KeyboardEvent, data: DETextBlock, index: number): Promise<void>;
+export declare function _convertTextBlockToDividerBlock(event: KeyboardEvent, data: DETextBlock, index: number): Promise<void>;
+export declare function _convertHeadingBlockType(event: KeyboardEvent, data: DEHeadingBlock, index: number, setEvent: Function, abortEvent: Function): Promise<void>;
+export declare function _hotKeyEvent(event: KeyboardEvent): void;