@univerjs/docs-ui 0.4.1 → 0.4.2-nightly.202410301606

package/lib/core-editing.command-DAmOCaTR.mjs

@@ -0,0 +1,1905 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: !0 });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key != "symbol" ? key + "" : key, value);
+import { Tools, DOC_RANGE_TYPE, RANGE_DIRECTION, COLORS, BooleanNumber, Rectangle, Inject, RxDisposable, UniverInstanceType, DataStreamTreeTokenType, ILogService, IUniverInstanceService, CommandType, ICommandService, BuildTextUtils, TextX, JSONX, TextXActionType } from "@univerjs/core";
+import { DocSkeletonManagerService, DocSelectionManagerService, RichTextEditingMutation } from "@univerjs/docs";
+import { IRenderManagerService, Liquid, GlyphType, DocumentSkeletonPageType, getPageFromPath, getTableIdAndSliceIndex, NORMAL_TEXT_SELECTION_PLUGIN_STYLE, getColor, RegularPolygon, Rect, getOffsetRectForDom, ScrollTimer, CURSOR_TYPE, getSystemHighlightColor, Vector2, PageLayoutType } from "@univerjs/engine-render";
+import { ILayoutService } from "@univerjs/ui";
+import { Subject, BehaviorSubject, takeUntil, fromEvent } from "rxjs";
+function getCommandSkeleton(accessor, unitId) {
+  var _a2;
+  return (_a2 = accessor.get(IRenderManagerService).getRenderById(unitId)) == null ? void 0 : _a2.with(DocSkeletonManagerService);
+}
+__name(getCommandSkeleton, "getCommandSkeleton");
+function getRichTextEditPath(docDataModel, segmentId = "") {
+  if (!segmentId)
+    return ["body"];
+  const { headers, footers } = docDataModel.getSnapshot();
+  if (headers == null && footers == null)
+    throw new Error("Document data model must have headers or footers when update by segment id");
+  if ((headers == null ? void 0 : headers[segmentId]) != null)
+    return ["headers", segmentId, "body"];
+  if ((footers == null ? void 0 : footers[segmentId]) != null)
+    return ["footers", segmentId, "body"];
+  throw new Error("Segment id not found in headers or footers");
+}
+__name(getRichTextEditPath, "getRichTextEditPath");
+var NodePositionType = /* @__PURE__ */ ((NodePositionType2) => (NodePositionType2[NodePositionType2.page = 0] = "page", NodePositionType2[NodePositionType2.section = 1] = "section", NodePositionType2[NodePositionType2.column = 2] = "column", NodePositionType2[NodePositionType2.line = 3] = "line", NodePositionType2[NodePositionType2.divide = 4] = "divide", NodePositionType2[NodePositionType2.glyph = 5] = "glyph", NodePositionType2))(NodePositionType || {});
+const NodePositionMap = {
+  page: 0,
+  section: 1,
+  column: 2,
+  line: 3,
+  divide: 4,
+  glyph: 5
+};
+function compareNodePositionLogic(pos1, pos2) {
+  return pos1.page > pos2.page ? !1 : pos1.page < pos2.page ? !0 : pos1.section > pos2.section ? !1 : pos1.section < pos2.section ? !0 : pos1.column > pos2.column ? !1 : pos1.column < pos2.column ? !0 : pos1.line > pos2.line ? !1 : pos1.line < pos2.line ? !0 : pos1.divide > pos2.divide ? !1 : pos1.divide < pos2.divide ? !0 : pos1.glyph > pos2.glyph ? !1 : (pos1.glyph < pos2.glyph, !0);
+}
+__name(compareNodePositionLogic, "compareNodePositionLogic");
+function compareNodePosition(pos1, pos2) {
+  return compareNodePositionLogic(pos1, pos2) ? {
+    start: pos1,
+    end: pos2
+  } : {
+    start: pos2,
+    end: pos1
+  };
+}
+__name(compareNodePosition, "compareNodePosition");
+function getOneTextSelectionRange(rangeList) {
+  const rangeCount = rangeList.length;
+  if (rangeCount === 0)
+    return;
+  const firstCursor = rangeList[0], lastCursor = rangeList[rangeCount - 1], collapsed = rangeList.length === 1 && firstCursor.collapsed;
+  return {
+    startOffset: firstCursor.startOffset,
+    endOffset: lastCursor.endOffset,
+    collapsed
+  };
+}
+__name(getOneTextSelectionRange, "getOneTextSelectionRange");
+function getOffsetInDivide(glyphGroup, startGlyphIndex, endGlyphIndex, st) {
+  let startOffset = st, endOffset = st;
+  for (let i = 0; i < glyphGroup.length; i++) {
+    const contentLength = glyphGroup[i].count;
+    i < startGlyphIndex && (startOffset += contentLength), i < endGlyphIndex && (endOffset += contentLength);
+  }
+  return {
+    startOffset,
+    endOffset
+  };
+}
+__name(getOffsetInDivide, "getOffsetInDivide");
+function pushToPoints(position) {
+  const { startX, startY, endX, endY } = position, points = [];
+  return points.push({
+    x: startX,
+    y: startY
+  }), points.push({
+    x: endX,
+    y: startY
+  }), points.push({
+    x: endX,
+    y: endY
+  }), points.push({
+    x: startX,
+    y: endY
+  }), points.push({
+    x: startX,
+    y: startY
+  }), points;
+}
+__name(pushToPoints, "pushToPoints");
+const _NodePositionConvertToCursor = class _NodePositionConvertToCursor {
+  constructor(_documentOffsetConfig, _docSkeleton) {
+    __publicField(this, "_liquid", new Liquid());
+    __publicField(this, "_currentStartState", {
+      page: 0,
+      section: 0,
+      column: 0,
+      line: 0,
+      divide: 0,
+      glyph: 0
+      /* NORMAL */
+    });
+    __publicField(this, "_currentEndState", {
+      page: 0,
+      section: 0,
+      column: 0,
+      line: 0,
+      divide: 0,
+      glyph: 0
+      /* NORMAL */
+    });
+    this._documentOffsetConfig = _documentOffsetConfig, this._docSkeleton = _docSkeleton;
+  }
+  // eslint-disable-next-line max-lines-per-function
+  getRangePointData(startOrigin, endOrigin) {
+    const borderBoxPointGroup = [], contentBoxPointGroup = [], cursorList = [];
+    if (startOrigin == null || endOrigin == null)
+      return {
+        borderBoxPointGroup,
+        contentBoxPointGroup,
+        cursorList
+      };
+    if (!this._isValidPosition(startOrigin, endOrigin))
+      throw new Error(
+        `
+                Invalid positions in NodePositionConvertToCursor,
+                they are not in the same segment page when in header or footer.`
+      );
+    const { start, end } = compareNodePosition(startOrigin, endOrigin);
+    return this._selectionIterator(start, end, (start_sp, end_sp, isFirst, isLast, divide, line) => {
+      const { lineHeight, asc, paddingTop, marginTop, marginBottom } = line, { glyphGroup, st } = divide;
+      if (glyphGroup.length === 0)
+        return;
+      const { x: startX, y: startY } = this._liquid;
+      let borderBoxPosition, contentBoxPosition;
+      const firstGlyph = glyphGroup[start_sp], lastGlyph = glyphGroup[end_sp], preGlyph = glyphGroup[start_sp - 1], firstGlyphLeft = (firstGlyph == null ? void 0 : firstGlyph.left) || 0, firstGlyphWidth = (firstGlyph == null ? void 0 : firstGlyph.width) || 0, lastGlyphLeft = (lastGlyph == null ? void 0 : lastGlyph.left) || 0, lastGlyphWidth = (lastGlyph == null ? void 0 : lastGlyph.width) || 0, isCurrentList = (firstGlyph == null ? void 0 : firstGlyph.glyphType) === GlyphType.LIST, { startOffset, endOffset } = getOffsetInDivide(glyphGroup, start_sp, end_sp, st), isStartBack = start.glyph === start_sp && isFirst ? start.isBack : !0, isEndBack = end.glyph === end_sp && isLast ? end.isBack : !1, collapsed = start === end, anchorGlyph = isStartBack && preGlyph != null ? preGlyph : firstGlyph;
+      if (start_sp === 0 && end_sp === glyphGroup.length - 1)
+        borderBoxPosition = {
+          startX: startX + firstGlyphLeft + (isCurrentList ? firstGlyphWidth : 0),
+          startY,
+          endX: startX + lastGlyphLeft + (isEndBack ? 0 : lastGlyphWidth),
+          endY: startY + lineHeight - marginTop - marginBottom
+        }, contentBoxPosition = {
+          startX: startX + firstGlyphLeft + (isCurrentList ? firstGlyphWidth : 0),
+          startY: startY + paddingTop + asc - anchorGlyph.bBox.ba,
+          endX: startX + lastGlyphLeft + (isEndBack ? 0 : lastGlyphWidth),
+          endY: startY + paddingTop + asc + anchorGlyph.bBox.bd
+        };
+      else {
+        const isStartBackFin = isStartBack && !isCurrentList;
+        borderBoxPosition = {
+          startX: startX + firstGlyphLeft + (isStartBackFin ? 0 : firstGlyphWidth),
+          startY,
+          endX: startX + lastGlyphLeft + (isEndBack ? 0 : lastGlyphWidth),
+          endY: startY + lineHeight - marginTop - marginBottom
+        }, contentBoxPosition = {
+          startX: startX + firstGlyphLeft + (isStartBackFin ? 0 : firstGlyphWidth),
+          startY: startY + paddingTop + asc - anchorGlyph.bBox.ba,
+          endX: startX + lastGlyphLeft + (isEndBack ? 0 : lastGlyphWidth),
+          endY: startY + paddingTop + asc + anchorGlyph.bBox.bd
+        };
+      }
+      borderBoxPointGroup.push(pushToPoints(borderBoxPosition)), contentBoxPointGroup.push(pushToPoints(contentBoxPosition)), cursorList.push({
+        startOffset: isStartBack ? startOffset : startOffset + firstGlyph.count,
+        endOffset: isEndBack ? endOffset : endOffset + lastGlyph.count,
+        collapsed
+      });
+    }), {
+      borderBoxPointGroup,
+      contentBoxPointGroup,
+      cursorList
+    };
+  }
+  _isValidPosition(startOrigin, endOrigin) {
+    const { segmentPage: startPage, pageType: startPageType } = startOrigin, { segmentPage: endPage, pageType: endPageType } = endOrigin;
+    return startPageType !== endPageType ? !1 : startPageType === DocumentSkeletonPageType.HEADER || startPageType === DocumentSkeletonPageType.FOOTER ? startPage === endPage : !0;
+  }
+  _resetCurrentNodePositionState() {
+    this._currentStartState = {
+      page: 0,
+      section: 0,
+      column: 0,
+      line: 0,
+      divide: 0,
+      glyph: 0
+      /* NORMAL */
+    }, this._currentEndState = {
+      page: 0,
+      section: 0,
+      column: 0,
+      line: 0,
+      divide: 0,
+      glyph: 0
+      /* NORMAL */
+    };
+  }
+  _setNodePositionState(type = 0, start, end, current) {
+    current === start ? this._currentStartState[type] = 1 : this._currentStartState[type] = 0, current === end ? this._currentEndState[type] = 2 : this._currentEndState[type] = 0;
+  }
+  _checkPreviousNodePositionState(typeIndex, isStart = !0) {
+    let index = typeIndex, resultState;
+    for (; index >= 0; ) {
+      const type = NodePositionType[index];
+      let state;
+      if (isStart ? state = this._currentStartState[type] : state = this._currentEndState[type], state === void 0)
+        return;
+      if (resultState === void 0 && (resultState = state), state !== resultState)
+        return 0;
+      index--;
+    }
+    return resultState;
+  }
+  _getSelectionRuler(typeIndex, startPosition, endPosition, nextLength, current) {
+    let start_next = 0, end_next = nextLength;
+    const type = NodePositionType[typeIndex], nextType = NodePositionType[typeIndex + 1];
+    if (nextType === null || type === null)
+      return {
+        start_next,
+        end_next
+      };
+    const start = startPosition[type], end = endPosition[type];
+    this._setNodePositionState(type, start, end, current);
+    const preStartNestType = this._checkPreviousNodePositionState(typeIndex), preEndNestType = this._checkPreviousNodePositionState(typeIndex, !1);
+    return preStartNestType === 1 && (start_next = startPosition[nextType]), preEndNestType === 2 && (end_next = endPosition[nextType]), {
+      start_next,
+      end_next
+    };
+  }
+  // eslint-disable-next-line max-lines-per-function, complexity
+  _selectionIterator(startPosition, endPosition, func) {
+    var _a2, _b;
+    const skeleton = this._docSkeleton;
+    if (!skeleton)
+      return [];
+    const { pageType, path } = startPosition;
+    this._liquid.reset();
+    const skeletonData = skeleton.getSkeletonData();
+    if (skeletonData == null)
+      return [];
+    const { pages, skeHeaders, skeFooters } = skeletonData, { page: pageIndex, segmentPage } = startPosition, { page: endPageIndex, segmentPage: endSegmentPage } = endPosition;
+    if (this._resetCurrentNodePositionState(), this._documentOffsetConfig == null)
+      return [];
+    const { pageLayoutType, pageMarginLeft, pageMarginTop } = this._documentOffsetConfig, skipPageIndex = pageType === DocumentSkeletonPageType.BODY || pageType === DocumentSkeletonPageType.CELL ? pageIndex : segmentPage;
+    for (let p = 0; p < skipPageIndex; p++) {
+      const page = pages[p];
+      this._liquid.translatePage(page, pageLayoutType, pageMarginLeft, pageMarginTop);
+    }
+    const endIndex = pageType === DocumentSkeletonPageType.BODY || pageType === DocumentSkeletonPageType.CELL ? endPageIndex : endSegmentPage;
+    for (let p = skipPageIndex; p <= endIndex; p++) {
+      const page = pages[p], { headerId, footerId, pageWidth } = page;
+      let segmentPage2 = page;
+      if (pageType === DocumentSkeletonPageType.HEADER ? segmentPage2 = (_a2 = skeHeaders.get(headerId)) == null ? void 0 : _a2.get(pageWidth) : pageType === DocumentSkeletonPageType.FOOTER ? segmentPage2 = (_b = skeFooters.get(footerId)) == null ? void 0 : _b.get(pageWidth) : pageType === DocumentSkeletonPageType.CELL && (segmentPage2 = getPageFromPath(skeletonData, path)), segmentPage2 == null) {
+        this._liquid.translatePage(page, pageLayoutType, pageMarginLeft, pageMarginTop);
+        continue;
+      }
+      const sections = segmentPage2.sections, { start_next: start_s, end_next: end_s } = this._getSelectionRuler(
+        NodePositionMap.page,
+        startPosition,
+        endPosition,
+        sections.length - 1,
+        pageType === DocumentSkeletonPageType.BODY || pageType === DocumentSkeletonPageType.CELL ? p : 0
+      );
+      switch (this._liquid.translateSave(), pageType) {
+        case DocumentSkeletonPageType.HEADER:
+          this._liquid.translatePagePadding({
+            ...segmentPage2,
+            marginLeft: page.marginLeft
+            // Because header or footer margin Left is 0.
+          });
+          break;
+        case DocumentSkeletonPageType.FOOTER: {
+          const footerTop = page.pageHeight - segmentPage2.height - segmentPage2.marginBottom;
+          this._liquid.translate(page.marginLeft, footerTop);
+          break;
+        }
+        case DocumentSkeletonPageType.CELL: {
+          this._liquid.translatePagePadding(page);
+          const rowSke = segmentPage2.parent, tableSke = rowSke.parent, { left: cellLeft } = segmentPage2, { top: tableTop, left: tableLeft } = tableSke, { top: rowTop } = rowSke;
+          this._liquid.translate(tableLeft + cellLeft, tableTop + rowTop), this._liquid.translatePagePadding(segmentPage2);
+          break;
+        }
+        default:
+          this._liquid.translatePagePadding(page);
+          break;
+      }
+      for (let s = start_s; s <= end_s; s++) {
+        const section = sections[s], columns = section.columns, { start_next: start_c, end_next: end_c } = this._getSelectionRuler(
+          NodePositionMap.section,
+          startPosition,
+          endPosition,
+          columns.length - 1,
+          s
+        );
+        this._liquid.translateSection(section);
+        for (let c = start_c; c <= end_c; c++) {
+          const column = columns[c], lines = column.lines, { start_next: start_l, end_next: end_l } = this._getSelectionRuler(
+            NodePositionMap.column,
+            startPosition,
+            endPosition,
+            lines.length - 1,
+            c
+          );
+          this._liquid.translateColumn(column);
+          for (let l = start_l; l <= end_l; l++) {
+            const line = lines[l], { divides } = line, { start_next: start_d, end_next: end_d } = this._getSelectionRuler(
+              NodePositionMap.line,
+              startPosition,
+              endPosition,
+              divides.length - 1,
+              l
+            );
+            this._liquid.translateSave(), this._liquid.translateLine(line, !0, !1);
+            for (let d = start_d; d <= end_d; d++) {
+              const divide = divides[d];
+              this._liquid.translateSave(), this._liquid.translateDivide(divide);
+              const { glyphGroup } = divide, { start_next: start_sp, end_next: end_sp } = this._getSelectionRuler(
+                NodePositionMap.divide,
+                startPosition,
+                endPosition,
+                glyphGroup.length - 1,
+                d
+              );
+              let isFirst = !1, isLast = !1;
+              p === skipPageIndex && s === start_s && c === start_c && l === start_l && d === start_d && (isFirst = !0), p === endIndex && s === end_s && c === end_c && l === end_l && d === end_d && (isLast = !0), func && func(start_sp, end_sp, isFirst, isLast, divide, line, column, section, segmentPage2), this._liquid.translateRestore();
+            }
+            this._liquid.translateRestore();
+          }
+        }
+      }
+      this._liquid.translateRestore(), this._liquid.translatePage(page, pageLayoutType, pageMarginLeft, pageMarginTop);
+    }
+  }
+};
+__name(_NodePositionConvertToCursor, "NodePositionConvertToCursor");
+let NodePositionConvertToCursor = _NodePositionConvertToCursor;
+function isValidRectRange(anchorNodePosition, focusNodePosition) {
+  const { path: anchorPath } = anchorNodePosition, { path: focusPath } = focusNodePosition;
+  if (anchorPath.length !== focusPath.length || anchorPath.indexOf("cells") === -1)
+    return !1;
+  const tableIdIndex = anchorPath.indexOf("skeTables") + 1, rowIndex = anchorPath.indexOf("rows") + 1, cellIndex = anchorPath.indexOf("cells") + 1, anchorTableId = getTableIdAndSliceIndex(anchorPath[tableIdIndex]).tableId, focusTableId = getTableIdAndSliceIndex(focusPath[tableIdIndex]).tableId;
+  if (anchorTableId !== focusTableId)
+    return !1;
+  const anchorRowIndex = anchorPath[rowIndex], focusRowIndex = focusPath[rowIndex], anchorCellIndex = anchorPath[cellIndex], focusCellIndex = focusPath[cellIndex];
+  return !(anchorRowIndex === focusRowIndex && anchorCellIndex === focusCellIndex);
+}
+__name(isValidRectRange, "isValidRectRange");
+function isInSameTableCell(anchorNodePosition, focusNodePosition) {
+  const { path: anchorPath } = anchorNodePosition, { path: focusPath } = focusNodePosition;
+  return anchorPath.indexOf("cells") === -1 || focusPath.indexOf("cells") === -1 ? !1 : Tools.diffValue(anchorPath, focusPath);
+}
+__name(isInSameTableCell, "isInSameTableCell");
+function compareNodePositionInTable(a, b) {
+  if (isInSameTableCell(a, b))
+    return compareNodePositionLogic(a, b);
+  const { path: aPath } = a, { path: bPath } = b, aTableId = aPath[aPath.length - 5], bTableId = bPath[bPath.length - 5];
+  if (aTableId !== bTableId && typeof aTableId == "string" && typeof bTableId == "string") {
+    const aSlideId = aTableId.split("#-#")[1], bSlideId = bTableId.split("#-#")[1];
+    return +aSlideId < +bSlideId;
+  }
+  const aRowCount = aPath[aPath.length - 3], bRowCount = bPath[bPath.length - 3], aCellCount = aPath[aPath.length - 1], bCellCount = bPath[bPath.length - 1];
+  return aRowCount < bRowCount ? !0 : aRowCount > bRowCount ? !1 : aCellCount <= bCellCount;
+}
+__name(compareNodePositionInTable, "compareNodePositionInTable");
+function firstGlyphInCellPage(cellPage) {
+  return cellPage.sections[0].columns[0].lines[0].divides[0].glyphGroup[0];
+}
+__name(firstGlyphInCellPage, "firstGlyphInCellPage");
+function lastGlyphInCellPage(cellPage) {
+  const { sections } = cellPage, lastSection = sections[sections.length - 1], lastColumn = lastSection.columns[lastSection.columns.length - 1], lastLine = lastColumn.lines[lastColumn.lines.length - 1], lastGlyphGroup = lastLine.divides[lastLine.divides.length - 1].glyphGroup;
+  return lastGlyphGroup[lastGlyphGroup.length - 2];
+}
+__name(lastGlyphInCellPage, "lastGlyphInCellPage");
+const _NodePositionConvertToRectRange = class _NodePositionConvertToRectRange {
+  constructor(_documentOffsetConfig, _docSkeleton) {
+    __publicField(this, "_liquid", new Liquid());
+    this._documentOffsetConfig = _documentOffsetConfig, this._docSkeleton = _docSkeleton;
+  }
+  // eslint-disable-next-line max-lines-per-function
+  getRangePointData(startNodePosition, endNodePosition) {
+    const pointGroup = [], skeletonData = this._docSkeleton.getSkeletonData();
+    if (skeletonData == null)
+      return;
+    const { pages } = skeletonData, { segmentPage: startSegmentPage, page: startPage, pageType } = startNodePosition, { segmentPage: endSegmentPage, page: endPage } = endNodePosition, rectInfo = this._getTableRectRangeInfo(startNodePosition, endNodePosition);
+    if (rectInfo == null)
+      return;
+    const {
+      tableId,
+      startRowIndex: startRow,
+      startColumnIndex: startColumn,
+      endRowIndex: endRow,
+      endColumnIndex: endColumn
+    } = rectInfo;
+    this._liquid.reset();
+    const { pageLayoutType, pageMarginLeft, pageMarginTop } = this._documentOffsetConfig, skipPageIndex = pageType === DocumentSkeletonPageType.BODY || pageType === DocumentSkeletonPageType.CELL ? startPage : startSegmentPage;
+    for (let p = 0; p < skipPageIndex; p++) {
+      const page = pages[p];
+      this._liquid.translatePage(page, pageLayoutType, pageMarginLeft, pageMarginTop);
+    }
+    const endIndex = pageType === DocumentSkeletonPageType.BODY || pageType === DocumentSkeletonPageType.CELL ? endPage : endSegmentPage;
+    for (let p = skipPageIndex; p <= endIndex; p++) {
+      const page = pages[p];
+      this._liquid.translatePagePadding(page);
+      const { skeTables } = page;
+      let table = null;
+      for (const [id, tableSke] of skeTables.entries())
+        id.startsWith(tableId) && (table = tableSke);
+      if (table == null) {
+        this._liquid.restorePagePadding(page), this._liquid.translatePage(page, pageLayoutType, pageMarginLeft, pageMarginTop);
+        continue;
+      }
+      this._liquid.translateSave(), this._liquid.translate(0, table.top);
+      const { x, y } = this._liquid;
+      for (const row of table.rows)
+        if (row.index >= startRow && row.index <= endRow) {
+          const rowStartCell = row.cells[startColumn], rowEndCell = row.cells[endColumn], position = {
+            startX: x + rowStartCell.left,
+            startY: y + row.top,
+            endX: x + rowEndCell.left + rowEndCell.pageWidth,
+            endY: y + row.top + row.height
+          };
+          pointGroup.push(pushToPoints(position));
+        }
+      this._liquid.translateRestore(), this._liquid.restorePagePadding(page), this._liquid.translatePage(page, pageLayoutType, pageMarginLeft, pageMarginTop);
+    }
+    return {
+      pointGroup,
+      startRow,
+      startColumn,
+      endRow,
+      endColumn,
+      tableId
+    };
+  }
+  getNodePositionGroup(anchorNodePosition, focusNodePosition) {
+    const nodePositionGroup = [], compare = compareNodePositionInTable(anchorNodePosition, focusNodePosition), startNodePosition = compare ? anchorNodePosition : focusNodePosition, endNodePosition = compare ? focusNodePosition : anchorNodePosition, { segmentPage } = startNodePosition, rectInfo = this._getTableRectRangeInfo(startNodePosition, endNodePosition);
+    if (rectInfo == null)
+      return;
+    const { tableId, pages, startRowIndex, startColumnIndex, endRowIndex, endColumnIndex } = rectInfo, tables = [];
+    for (const page of pages) {
+      const { skeTables } = page;
+      for (const [id, table] of skeTables.entries())
+        id.startsWith(tableId) && tables.push(table);
+    }
+    if (tables.length === 0)
+      return;
+    for (const table of tables)
+      this._collectPositionGroup(table, nodePositionGroup, startRowIndex, endRowIndex, startColumnIndex, endColumnIndex, segmentPage, compare);
+    const totalColumns = tables[0].rows[0].cells.length;
+    if (startColumnIndex === 0 && endColumnIndex === totalColumns - 1) {
+      const firstPosition = nodePositionGroup[0], lastPosition = nodePositionGroup[nodePositionGroup.length - 1];
+      nodePositionGroup.length = 0, nodePositionGroup.push({
+        anchor: compare ? firstPosition.anchor : lastPosition.anchor,
+        focus: compare ? lastPosition.focus : firstPosition.focus
+      });
+    }
+    return nodePositionGroup;
+  }
+  _collectPositionGroup(table, nodePositionGroup, startRowIndex, endRowIndex, startColumnIndex, endColumnIndex, segmentPage, compare) {
+    for (let i = 0; i < table.rows.length; i++) {
+      const row = table.rows[i];
+      if (row.index < startRowIndex)
+        continue;
+      if (row.index > endRowIndex)
+        break;
+      const startCellInRow = row.cells[startColumnIndex], endCellInRow = row.cells[endColumnIndex], startCellGlyph = firstGlyphInCellPage(startCellInRow), endCellGlyph = lastGlyphInCellPage(endCellInRow);
+      if (startCellGlyph == null || endCellGlyph == null)
+        continue;
+      const startPosition = this._docSkeleton.findPositionByGlyph(startCellGlyph, segmentPage), endPosition = this._docSkeleton.findPositionByGlyph(endCellGlyph, segmentPage);
+      if (startPosition == null || endPosition == null)
+        continue;
+      const anchor = compare ? startPosition : endPosition, focus = compare ? endPosition : startPosition;
+      nodePositionGroup.push({
+        anchor: {
+          ...anchor,
+          isBack: !0
+          // true or false is the same.
+        },
+        focus: {
+          ...focus,
+          isBack: !0
+        }
+      });
+    }
+  }
+  _getTableRectRangeInfo(startNodePosition, endNodePosition) {
+    const skeletonData = this._docSkeleton.getSkeletonData();
+    if (skeletonData == null)
+      return;
+    const { pages } = skeletonData, { path: startPath } = startNodePosition, { path: endPath } = endNodePosition, startCell = getPageFromPath(skeletonData, startPath), endCell = getPageFromPath(skeletonData, endPath);
+    if (startCell == null || endCell == null)
+      return;
+    const tableId = startCell.segmentId, startRow = startCell.parent.index, startColumn = startCell.parent.cells.indexOf(startCell), endRow = (endCell == null ? void 0 : endCell.parent).index, endColumn = (endCell == null ? void 0 : endCell.parent).cells.indexOf(endCell);
+    return {
+      pages,
+      tableId,
+      startCell,
+      endCell,
+      startRowIndex: startRow,
+      startColumnIndex: startColumn,
+      endRowIndex: endRow,
+      endColumnIndex: endColumn
+    };
+  }
+};
+__name(_NodePositionConvertToRectRange, "NodePositionConvertToRectRange");
+let NodePositionConvertToRectRange = _NodePositionConvertToRectRange;
+const TEXT_RANGE_KEY_PREFIX = "__TestSelectionRange__", TEXT_ANCHOR_KEY_PREFIX = "__TestSelectionAnchor__", ID_LENGTH$1 = 6, BLINK_ON = 500, BLINK_OFF = 500, TEXT_RANGE_LAYER_INDEX = 3;
+function getAnchorBounding(pointsGroup) {
+  const points = pointsGroup[0], startPoint = points[0], endPoint = points[2], { x: startX, y: startY } = startPoint, { x: endX, y: endY } = endPoint;
+  return {
+    left: startX,
+    top: startY,
+    width: endX - startX,
+    height: endY - startY
+  };
+}
+__name(getAnchorBounding, "getAnchorBounding");
+function getLineBounding(pointsGroup) {
+  return pointsGroup.map((line) => {
+    let xMin = 1 / 0, xMax = -1 / 0, yMin = 1 / 0, yMax = -1 / 0;
+    return line.forEach((point) => {
+      xMin = Math.min(point.x, xMin), xMax = Math.max(point.x, xMax), yMax = Math.max(point.y, yMax), yMin = Math.min(point.y, yMin);
+    }), {
+      left: xMin,
+      right: xMax,
+      top: yMin,
+      bottom: yMax
+    };
+  });
+}
+__name(getLineBounding, "getLineBounding");
+const _TextRange = class _TextRange {
+  constructor(_scene, _document, _docSkeleton, anchorNodePosition, focusNodePosition, style = NORMAL_TEXT_SELECTION_PLUGIN_STYLE, _segmentId = "", _segmentPage = -1) {
+    __publicField(this, "rangeType", DOC_RANGE_TYPE.TEXT);
+    // Identifies whether the range is the current one, most of which is the last range.
+    __publicField(this, "_current", !1);
+    // The rendered range graphic when collapsed is false
+    __publicField(this, "_rangeShape");
+    // The rendered range graphic when collapsed is true
+    __publicField(this, "_anchorShape");
+    __publicField(this, "_cursorList", []);
+    __publicField(this, "_anchorBlinkTimer", null);
+    this._scene = _scene, this._document = _document, this._docSkeleton = _docSkeleton, this.anchorNodePosition = anchorNodePosition, this.focusNodePosition = focusNodePosition, this.style = style, this._segmentId = _segmentId, this._segmentPage = _segmentPage, this._anchorBlink(), this.refresh();
+  }
+  _anchorBlink() {
+    setTimeout(() => {
+      this._anchorShape && this._anchorShape.visible && this.deactivateStatic();
+    }, BLINK_ON), this._anchorBlinkTimer = setInterval(() => {
+      this._anchorShape && this._anchorShape.visible && (this.activeStatic(), setTimeout(() => {
+        this.deactivateStatic();
+      }, BLINK_ON));
+    }, BLINK_OFF + BLINK_ON);
+  }
+  // The start position of the range
+  get startOffset() {
+    var _a2;
+    const { startOffset } = (_a2 = getOneTextSelectionRange(this._cursorList)) != null ? _a2 : {}, body = this._docSkeleton.getViewModel().getDataModel().getSelfOrHeaderFooterModel(this._segmentId).getBody();
+    if (startOffset == null || body == null)
+      return startOffset;
+    const maxLength = body.dataStream.length - 2;
+    return Math.min(maxLength, startOffset);
+  }
+  // The end position of the range
+  get endOffset() {
+    var _a2;
+    const { endOffset } = (_a2 = getOneTextSelectionRange(this._cursorList)) != null ? _a2 : {}, body = this._docSkeleton.getViewModel().getDataModel().getSelfOrHeaderFooterModel(this._segmentId).getBody();
+    if (endOffset == null || body == null)
+      return endOffset;
+    const maxLength = body.dataStream.length - 2;
+    return Math.min(endOffset, maxLength);
+  }
+  get collapsed() {
+    const { startOffset, endOffset } = this;
+    return startOffset != null && startOffset === endOffset;
+  }
+  get startNodePosition() {
+    if (this.anchorNodePosition == null)
+      return null;
+    if (this.focusNodePosition == null)
+      return this.anchorNodePosition;
+    const { start } = compareNodePosition(this.anchorNodePosition, this.focusNodePosition);
+    return start;
+  }
+  get endNodePosition() {
+    if (this.anchorNodePosition == null)
+      return this.focusNodePosition;
+    if (this.focusNodePosition == null)
+      return null;
+    const { end } = compareNodePosition(this.anchorNodePosition, this.focusNodePosition);
+    return end;
+  }
+  get direction() {
+    const { collapsed, anchorNodePosition, focusNodePosition } = this;
+    return collapsed || anchorNodePosition == null || focusNodePosition == null ? RANGE_DIRECTION.NONE : compareNodePositionLogic(anchorNodePosition, focusNodePosition) ? RANGE_DIRECTION.FORWARD : RANGE_DIRECTION.BACKWARD;
+  }
+  get segmentId() {
+    return this._segmentId;
+  }
+  get segmentPage() {
+    return this._segmentPage;
+  }
+  getAbsolutePosition() {
+    const anchor = this.anchorNodePosition, focus = this.focusNodePosition;
+    if (this._isEmpty())
+      return;
+    const documentOffsetConfig = this._document.getOffsetConfig(), { docsLeft, docsTop } = documentOffsetConfig, convertor = new NodePositionConvertToCursor(documentOffsetConfig, this._docSkeleton);
+    if (this._isCollapsed()) {
+      const { contentBoxPointGroup, cursorList: cursorList2 } = convertor.getRangePointData(anchor, anchor);
+      if (this._setCursorList(cursorList2), contentBoxPointGroup.length === 0)
+        return;
+      const pos2 = getAnchorBounding(contentBoxPointGroup);
+      return {
+        ...pos2,
+        left: pos2.left + docsLeft,
+        top: pos2.top + docsTop
+      };
+    }
+    const { borderBoxPointGroup, cursorList } = convertor.getRangePointData(anchor, focus);
+    if (this._setCursorList(cursorList), borderBoxPointGroup.length === 0)
+      return;
+    const pos = getAnchorBounding(borderBoxPointGroup);
+    return {
+      ...pos,
+      left: pos.left + docsLeft,
+      top: pos.top + docsTop
+    };
+  }
+  getAnchor() {
+    return this._anchorShape;
+  }
+  activeStatic() {
+    var _a2, _b;
+    (_b = this._anchorShape) == null || _b.setProps({
+      stroke: ((_a2 = this.style) == null ? void 0 : _a2.strokeActive) || getColor(COLORS.black, 1)
+    });
+  }
+  deactivateStatic() {
+    var _a2, _b;
+    (_b = this._anchorShape) == null || _b.setProps({
+      stroke: ((_a2 = this.style) == null ? void 0 : _a2.stroke) || getColor(COLORS.black, 0)
+    });
+  }
+  isActive() {
+    return this._current === !0;
+  }
+  activate() {
+    this._current = !0;
+  }
+  deactivate() {
+    this._current = !1;
+  }
+  dispose() {
+    var _a2, _b;
+    (_a2 = this._rangeShape) == null || _a2.dispose(), this._rangeShape = null, (_b = this._anchorShape) == null || _b.dispose(), this._anchorShape = null, this._anchorBlinkTimer && (clearInterval(this._anchorBlinkTimer), this._anchorBlinkTimer = null);
+  }
+  isIntersection(compareRange) {
+    const { startOffset: activeStart, endOffset: activeEnd } = this, { startOffset: compareStart, endOffset: compareEnd } = compareRange;
+    return activeStart == null || activeEnd == null || compareStart == null || compareEnd == null ? !1 : activeStart <= compareEnd && activeEnd >= compareStart;
+  }
+  // render cursor and selection.
+  refresh() {
+    var _a2, _b;
+    const { _document, _docSkeleton } = this, anchor = this.anchorNodePosition, focus = this.focusNodePosition;
+    if ((_a2 = this._anchorShape) == null || _a2.hide(), (_b = this._rangeShape) == null || _b.hide(), this._isEmpty())
+      return;
+    const documentOffsetConfig = _document.getOffsetConfig(), { docsLeft, docsTop } = documentOffsetConfig, convertor = new NodePositionConvertToCursor(documentOffsetConfig, _docSkeleton);
+    if (this._isCollapsed()) {
+      const { contentBoxPointGroup, cursorList: cursorList2 } = convertor.getRangePointData(anchor, anchor);
+      if (this._setCursorList(cursorList2), contentBoxPointGroup.length > 0) {
+        const glyphAtCursor = _docSkeleton.findGlyphByPosition(anchor);
+        this._createOrUpdateAnchor(contentBoxPointGroup, docsLeft, docsTop, glyphAtCursor);
+      }
+      return;
+    }
+    const { borderBoxPointGroup, cursorList } = convertor.getRangePointData(anchor, focus);
+    this._setCursorList(cursorList), borderBoxPointGroup.length > 0 && this._createOrUpdateRange(borderBoxPointGroup, docsLeft, docsTop);
+  }
+  _isEmpty() {
+    return this.anchorNodePosition == null && this.focusNodePosition == null;
+  }
+  _isCollapsed() {
+    const anchor = this.anchorNodePosition, focus = this.focusNodePosition;
+    if (anchor != null && focus == null)
+      return !0;
+    if (anchor == null || focus == null)
+      return !1;
+    const keys = Object.keys(NodePositionMap);
+    for (const key of keys) {
+      const startNodeValue = anchor[key], endNodeValue = focus[key];
+      if (startNodeValue !== endNodeValue)
+        return !1;
+    }
+    return anchor.isBack === focus.isBack;
+  }
+  _createOrUpdateRange(pointsGroup, left, top) {
+    var _a2;
+    if (this._rangeShape) {
+      this._rangeShape.translate(left, top), this._rangeShape.updatePointGroup(pointsGroup), this._rangeShape.show();
+      return;
+    }
+    const OPACITY = 0.3, polygon = new RegularPolygon(TEXT_RANGE_KEY_PREFIX + Tools.generateRandomId(ID_LENGTH$1), {
+      pointsGroup,
+      fill: ((_a2 = this.style) == null ? void 0 : _a2.fill) || getColor(COLORS.black, OPACITY),
+      left,
+      top,
+      evented: !1,
+      debounceParentDirty: !1
+    });
+    this._rangeShape = polygon, this._scene.addObject(polygon, TEXT_RANGE_LAYER_INDEX);
+  }
+  _createOrUpdateAnchor(pointsGroup, docsLeft, docsTop, glyph) {
+    var _a2, _b, _c;
+    const bounding = getAnchorBounding(pointsGroup), { left: boundingLeft } = bounding;
+    let { top: boundingTop, height } = bounding;
+    const MIN_CURSOR_HEIGHT = 14;
+    height < MIN_CURSOR_HEIGHT && (boundingTop -= MIN_CURSOR_HEIGHT - height, height = MIN_CURSOR_HEIGHT);
+    const ITALIC_DEGREE = 12;
+    let left = boundingLeft + docsLeft;
+    const top = boundingTop + docsTop, isItalic = ((_a2 = glyph == null ? void 0 : glyph.ts) == null ? void 0 : _a2.it) === BooleanNumber.TRUE;
+    if (isItalic && (left += height * Math.tan(ITALIC_DEGREE * Math.PI / 180) / 2), this._anchorShape) {
+      this._anchorShape.transformByState({ left, top, height }), this._anchorShape.show(), isItalic ? this._anchorShape.skew(-ITALIC_DEGREE, 0) : this._anchorShape.skew(0, 0);
+      return;
+    }
+    const anchor = new Rect(TEXT_ANCHOR_KEY_PREFIX + Tools.generateRandomId(ID_LENGTH$1), {
+      left,
+      top,
+      height,
+      strokeWidth: ((_b = this.style) == null ? void 0 : _b.strokeWidth) || 1.5,
+      stroke: ((_c = this.style) == null ? void 0 : _c.strokeActive) || getColor(COLORS.black, 1),
+      evented: !1
+    });
+    isItalic && anchor.skew(-ITALIC_DEGREE, 0), this._anchorShape = anchor, this._scene.addObject(anchor, TEXT_RANGE_LAYER_INDEX);
+  }
+  _setCursorList(cursorList) {
+    cursorList.length !== 0 && (this._cursorList = cursorList);
+  }
+};
+__name(_TextRange, "TextRange");
+let TextRange = _TextRange;
+const RECT_RANGE_KEY_PREFIX = "__DocTableRectRange__", ID_LENGTH = 6;
+function convertPositionsToRectRanges(scene, document2, docSkeleton, anchorNodePosition, focusNodePosition, style = NORMAL_TEXT_SELECTION_PLUGIN_STYLE, segmentId = "", segmentPage = -1) {
+  const documentOffsetConfig = document2.getOffsetConfig(), nodePositionGroup = new NodePositionConvertToRectRange(documentOffsetConfig, docSkeleton).getNodePositionGroup(anchorNodePosition, focusNodePosition);
+  return (nodePositionGroup != null ? nodePositionGroup : []).map((position) => new RectRange(
+    scene,
+    document2,
+    docSkeleton,
+    position.anchor,
+    position.focus,
+    style,
+    segmentId,
+    segmentPage
+  ));
+}
+__name(convertPositionsToRectRanges, "convertPositionsToRectRanges");
+const _RectRange = class _RectRange {
+  constructor(_scene, _document, _docSkeleton, anchorNodePosition, focusNodePosition, style = NORMAL_TEXT_SELECTION_PLUGIN_STYLE, _segmentId = "", _segmentPage = -1) {
+    __publicField(this, "rangeType", DOC_RANGE_TYPE.RECT);
+    // The rendered rect range
+    __publicField(this, "_rangeShape");
+    // Identifies whether the range is the current one, most of which is the last range.
+    __publicField(this, "_current", !1);
+    // Rect Range start row.
+    __publicField(this, "_startRow");
+    // Rect Range start column.
+    __publicField(this, "_startCol");
+    // Rect Range end row.
+    __publicField(this, "_endRow");
+    // Rect Range end column.
+    __publicField(this, "_endCol");
+    // table id in view model.
+    __publicField(this, "_tableId");
+    this._scene = _scene, this._document = _document, this._docSkeleton = _docSkeleton, this.anchorNodePosition = anchorNodePosition, this.focusNodePosition = focusNodePosition, this.style = style, this._segmentId = _segmentId, this._segmentPage = _segmentPage, this.refresh();
+  }
+  get startOffset() {
+    const { startNodePosition } = this;
+    return this._docSkeleton.findCharIndexByPosition(startNodePosition);
+  }
+  get endOffset() {
+    const { endNodePosition } = this;
+    return this._docSkeleton.findCharIndexByPosition(endNodePosition);
+  }
+  get collapsed() {
+    return !1;
+  }
+  get startRow() {
+    return this._startRow;
+  }
+  get startColumn() {
+    return this._startCol;
+  }
+  get endRow() {
+    return this._endRow;
+  }
+  get endColumn() {
+    return this._endCol;
+  }
+  get tableId() {
+    return this._tableId;
+  }
+  get segmentId() {
+    return this._segmentId;
+  }
+  get segmentPage() {
+    return this._segmentPage;
+  }
+  get spanEntireRow() {
+    var _a2;
+    const table = (_a2 = this._docSkeleton.getViewModel().getSnapshot().tableSource) == null ? void 0 : _a2[this._tableId], { _startCol, _endCol } = this;
+    if (table == null)
+      throw new Error("Table is not found.");
+    const { tableColumns } = table;
+    return _startCol === 0 && _endCol === tableColumns.length - 1;
+  }
+  get spanEntireColumn() {
+    var _a2;
+    const table = (_a2 = this._docSkeleton.getViewModel().getSnapshot().tableSource) == null ? void 0 : _a2[this._tableId], { _startRow, _endRow } = this;
+    if (table == null)
+      throw new Error("Table is not found.");
+    const { tableRows } = table;
+    return _startRow === 0 && _endRow === tableRows.length - 1;
+  }
+  get spanEntireTable() {
+    return this.spanEntireRow && this.spanEntireColumn;
+  }
+  get startNodePosition() {
+    const { anchorNodePosition, focusNodePosition } = this;
+    return compareNodePositionInTable(anchorNodePosition, focusNodePosition) ? anchorNodePosition : focusNodePosition;
+  }
+  get endNodePosition() {
+    const { anchorNodePosition, focusNodePosition } = this;
+    return compareNodePositionInTable(anchorNodePosition, focusNodePosition) ? focusNodePosition : anchorNodePosition;
+  }
+  get direction() {
+    const { anchorNodePosition, focusNodePosition } = this;
+    return compareNodePositionInTable(anchorNodePosition, focusNodePosition) ? RANGE_DIRECTION.FORWARD : RANGE_DIRECTION.BACKWARD;
+  }
+  isActive() {
+    return this._current === !0;
+  }
+  activate() {
+    this._current = !0;
+  }
+  deactivate() {
+    this._current = !1;
+  }
+  dispose() {
+    var _a2;
+    (_a2 = this._rangeShape) == null || _a2.dispose(), this._rangeShape = null;
+  }
+  isIntersection(compareRange) {
+    const { startRow, startColumn, endRow, endColumn } = this, { startRow: cStartRow, startColumn: cStartColumn, endRow: cEndRow, endColumn: cEndColumn } = compareRange, rect1 = {
+      left: startColumn,
+      top: startRow,
+      right: endColumn,
+      bottom: endRow
+    }, rect2 = {
+      left: cStartColumn,
+      top: cStartRow,
+      right: cEndColumn,
+      bottom: cEndRow
+    };
+    return Rectangle.hasIntersectionBetweenTwoRect(rect1, rect2);
+  }
+  refresh() {
+    var _a2;
+    (_a2 = this._rangeShape) == null || _a2.hide();
+    const { startNodePosition, endNodePosition, _document, _docSkeleton } = this, documentOffsetConfig = _document.getOffsetConfig(), { docsLeft, docsTop } = documentOffsetConfig, rectInfo = new NodePositionConvertToRectRange(documentOffsetConfig, _docSkeleton).getRangePointData(startNodePosition, endNodePosition);
+    if (rectInfo == null)
+      return;
+    const { pointGroup = [], startRow, endRow, startColumn, endColumn, tableId } = rectInfo;
+    (pointGroup == null ? void 0 : pointGroup.length) > 0 && this._createOrUpdateRange(pointGroup, docsLeft, docsTop), this._updateTableInfo(startRow, endRow, startColumn, endColumn, tableId);
+  }
+  _updateTableInfo(startRow, endRow, startCol, endCol, tableId) {
+    this._startRow = startRow, this._endRow = endRow, this._startCol = startCol, this._endCol = endCol, this._tableId = tableId;
+  }
+  _createOrUpdateRange(pointsGroup, left, top) {
+    var _a2;
+    if (this._rangeShape) {
+      this._rangeShape.translate(left, top), this._rangeShape.updatePointGroup(pointsGroup), this._rangeShape.show();
+      return;
+    }
+    const OPACITY = 0.3, polygon = new RegularPolygon(RECT_RANGE_KEY_PREFIX + Tools.generateRandomId(ID_LENGTH), {
+      pointsGroup,
+      fill: ((_a2 = this.style) == null ? void 0 : _a2.fill) || getColor(COLORS.black, OPACITY),
+      left,
+      top,
+      evented: !1,
+      debounceParentDirty: !1
+    });
+    this._rangeShape = polygon, this._scene.addObject(polygon, TEXT_RANGE_LAYER_INDEX);
+  }
+};
+__name(_RectRange, "RectRange");
+let RectRange = _RectRange;
+function getTextRangeFromCharIndex(startOffset, endOffset, scene, document2, skeleton, style, segmentId, segmentPage, startIsBack = !0, endIsBack = !0) {
+  const startNodePosition = skeleton.findNodePositionByCharIndex(startOffset, startIsBack, segmentId, segmentPage), endNodePosition = skeleton.findNodePositionByCharIndex(endOffset, endIsBack, segmentId, segmentPage);
+  if (!(startNodePosition == null || endNodePosition == null))
+    return new TextRange(scene, document2, skeleton, startNodePosition, endNodePosition, style, segmentId, segmentPage);
+}
+__name(getTextRangeFromCharIndex, "getTextRangeFromCharIndex");
+function getRectRangeFromCharIndex(startOffset, endOffset, scene, document2, skeleton, style, segmentId, segmentPage) {
+  const startNodePosition = skeleton.findNodePositionByCharIndex(startOffset, !0, segmentId, segmentPage), endNodePosition = skeleton.findNodePositionByCharIndex(endOffset, !0, segmentId, segmentPage);
+  if (!(startNodePosition == null || endNodePosition == null))
+    return new RectRange(scene, document2, skeleton, startNodePosition, endNodePosition, style, segmentId, segmentPage);
+}
+__name(getRectRangeFromCharIndex, "getRectRangeFromCharIndex");
+function getRangeListFromCharIndex(startOffset, endOffset, scene, document2, skeleton, style, segmentId, segmentPage) {
+  const startNodePosition = skeleton.findNodePositionByCharIndex(startOffset, !0, segmentId, segmentPage), endNodePosition = skeleton.findNodePositionByCharIndex(endOffset, !0, segmentId, segmentPage);
+  if (!(startNodePosition == null || endNodePosition == null))
+    return getRangeListFromSelection(
+      startNodePosition,
+      endNodePosition,
+      scene,
+      document2,
+      skeleton,
+      style,
+      segmentId,
+      segmentPage
+    );
+}
+__name(getRangeListFromCharIndex, "getRangeListFromCharIndex");
+function getRangeListFromSelection(anchorPosition, focusPosition, scene, document2, skeleton, style, segmentId, segmentPage) {
+  const textRanges = [], rectRanges = [], rangeParams = [scene, document2, skeleton, anchorPosition, focusPosition, style, segmentId, segmentPage];
+  if (isInSameTableCell(anchorPosition, focusPosition))
+    return textRanges.push(new TextRange(...rangeParams)), {
+      textRanges,
+      rectRanges
+    };
+  if (isValidRectRange(anchorPosition, focusPosition)) {
+    const ranges = convertPositionsToRectRanges(
+      ...rangeParams
+    );
+    return rectRanges.push(...ranges), {
+      textRanges,
+      rectRanges
+    };
+  }
+  const viewModel = skeleton.getViewModel().getSelfOrHeaderFooterViewModel(segmentId), anchorOffset = skeleton.findCharIndexByPosition(anchorPosition), focusOffset = skeleton.findCharIndexByPosition(focusPosition);
+  if (anchorOffset == null || focusOffset == null)
+    return;
+  const direction = anchorOffset <= focusOffset ? RANGE_DIRECTION.FORWARD : RANGE_DIRECTION.BACKWARD, startOffset = Math.min(anchorOffset, focusOffset), endOffset = Math.max(anchorOffset, focusOffset);
+  let start = startOffset, end = endOffset;
+  for (const section of viewModel.children)
+    for (const paragraph of section.children) {
+      const { startIndex, endIndex, children } = paragraph, table = children[0];
+      let endInTable = !1;
+      if (table) {
+        const { startIndex: tableStart, endIndex: tableEnd, children: children2 } = table;
+        let tableStartPosition = null, tableEndPosition = null;
+        const startRow = children2.find((row) => row.startIndex <= startOffset && row.endIndex >= startOffset), endRow = children2.find((row) => row.startIndex <= endOffset && row.endIndex >= endOffset);
+        if (startOffset > tableStart && startOffset < tableEnd)
+          tableStartPosition = skeleton.findNodePositionByCharIndex(startRow.startIndex + 2, !0, segmentId, segmentPage), tableEndPosition = skeleton.findNodePositionByCharIndex(tableEnd - 4, !0, segmentId, segmentPage), start = tableEnd + 1;
+        else if (endOffset > tableStart && endOffset < tableEnd)
+          tableStartPosition = skeleton.findNodePositionByCharIndex(tableStart + 3, !0, segmentId, segmentPage), tableEndPosition = skeleton.findNodePositionByCharIndex(endRow.endIndex - 3, !0, segmentId, segmentPage), end = tableStart - 1, endInTable = !0;
+        else if (tableStart > startOffset && tableEnd < endOffset) {
+          if (tableStartPosition = skeleton.findNodePositionByCharIndex(tableStart + 3, !0, segmentId, segmentPage), tableEndPosition = skeleton.findNodePositionByCharIndex(tableEnd - 4, !0, segmentId, segmentPage), start <= tableStart - 1) {
+            const sp = skeleton.findNodePositionByCharIndex(start, !0, segmentId, segmentPage), ep = skeleton.findNodePositionByCharIndex(tableStart - 1, !1, segmentId, segmentPage), ap = direction === RANGE_DIRECTION.FORWARD ? sp : ep, fp = direction === RANGE_DIRECTION.FORWARD ? ep : sp;
+            textRanges.push(new TextRange(scene, document2, skeleton, ap, fp, style, segmentId, segmentPage));
+          }
+          start = tableEnd + 1;
+        }
+        if (tableStartPosition && tableEndPosition) {
+          const ap = direction === RANGE_DIRECTION.FORWARD ? tableStartPosition : tableEndPosition, fp = direction === RANGE_DIRECTION.FORWARD ? tableEndPosition : tableStartPosition;
+          rectRanges.push(...convertPositionsToRectRanges(
+            scene,
+            document2,
+            skeleton,
+            ap,
+            fp,
+            style,
+            segmentId,
+            segmentPage
+          ));
+        }
+      }
+      if (end >= startIndex && end <= endIndex || endInTable) {
+        const sp = skeleton.findNodePositionByCharIndex(start, !0, segmentId, segmentPage), ep = skeleton.findNodePositionByCharIndex(end, !endInTable, segmentId, segmentPage), ap = direction === RANGE_DIRECTION.FORWARD ? sp : ep, fp = direction === RANGE_DIRECTION.FORWARD ? ep : sp;
+        if (rectRanges.length && Tools.diffValue(ap, fp))
+          continue;
+        textRanges.push(new TextRange(scene, document2, skeleton, ap, fp, style, segmentId, segmentPage));
+      }
+    }
+  return {
+    textRanges,
+    rectRanges
+  };
+}
+__name(getRangeListFromSelection, "getRangeListFromSelection");
+function getCanvasOffsetByEngine(engine) {
+  const canvas = engine == null ? void 0 : engine.getCanvasElement();
+  if (!canvas)
+    return {
+      left: 0,
+      top: 0
+    };
+  const { top, left } = getOffsetRectForDom(canvas);
+  return {
+    left,
+    top
+  };
+}
+__name(getCanvasOffsetByEngine, "getCanvasOffsetByEngine");
+function getParagraphInfoByGlyph(node) {
+  var _a2;
+  const line = (_a2 = node.parent) == null ? void 0 : _a2.parent, column = line == null ? void 0 : line.parent;
+  if (line == null || column == null)
+    return;
+  const { paragraphIndex } = line, lines = column.lines.filter((line2) => line2.paragraphIndex === paragraphIndex);
+  let nodeIndex = -1, content = "", hasFound = !1;
+  for (const line2 of lines)
+    for (const divide of line2.divides)
+      for (const glyph of divide.glyphGroup)
+        hasFound || (nodeIndex += glyph.count), glyph === node && (hasFound = !0), content += glyph.count > 0 ? glyph.content : "";
+  return {
+    st: lines[0].st,
+    ed: paragraphIndex,
+    content,
+    nodeIndex
+  };
+}
+__name(getParagraphInfoByGlyph, "getParagraphInfoByGlyph");
+function serializeTextRange(textRange) {
+  const { startOffset, endOffset, collapsed, rangeType, startNodePosition, endNodePosition, direction, segmentId, segmentPage } = textRange;
+  return {
+    startOffset,
+    endOffset,
+    collapsed,
+    rangeType,
+    startNodePosition,
+    endNodePosition,
+    direction,
+    segmentId,
+    segmentPage,
+    isActive: textRange.isActive()
+  };
+}
+__name(serializeTextRange, "serializeTextRange");
+function serializeRectRange(rectRange) {
+  const serializedTextRange = serializeTextRange(rectRange), {
+    startRow,
+    startColumn,
+    endRow,
+    endColumn,
+    tableId,
+    spanEntireRow,
+    spanEntireColumn,
+    spanEntireTable
+  } = rectRange;
+  return {
+    ...serializedTextRange,
+    startRow,
+    startColumn,
+    endRow,
+    endColumn,
+    tableId,
+    spanEntireRow,
+    spanEntireColumn,
+    spanEntireTable
+  };
+}
+__name(serializeRectRange, "serializeRectRange");
+var __defProp2 = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __decorateClass = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp2(target, key, result), result;
+}, "__decorateClass"), __decorateParam = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam"), _a;
+let DocSelectionRenderService = (_a = class extends RxDisposable {
+  constructor(_context, _layoutService, _logService, _univerInstanceService, _docSkeletonManagerService) {
+    super();
+    __publicField(this, "_onInputBefore$", new Subject());
+    __publicField(this, "onInputBefore$", this._onInputBefore$.asObservable());
+    __publicField(this, "_onKeydown$", new Subject());
+    __publicField(this, "onKeydown$", this._onKeydown$.asObservable());
+    __publicField(this, "_onInput$", new Subject());
+    __publicField(this, "onInput$", this._onInput$.asObservable());
+    __publicField(this, "_onCompositionstart$", new BehaviorSubject(null));
+    __publicField(this, "onCompositionstart$", this._onCompositionstart$.asObservable());
+    __publicField(this, "_onCompositionupdate$", new BehaviorSubject(null));
+    __publicField(this, "onCompositionupdate$", this._onCompositionupdate$.asObservable());
+    __publicField(this, "_onCompositionend$", new BehaviorSubject(null));
+    __publicField(this, "onCompositionend$", this._onCompositionend$.asObservable());
+    __publicField(this, "_onSelectionStart$", new BehaviorSubject(null));
+    __publicField(this, "onSelectionStart$", this._onSelectionStart$.asObservable());
+    __publicField(this, "_onPaste$", new Subject());
+    __publicField(this, "onPaste$", this._onPaste$.asObservable());
+    __publicField(this, "_textSelectionInner$", new BehaviorSubject(null));
+    __publicField(this, "textSelectionInner$", this._textSelectionInner$.asObservable());
+    __publicField(this, "_onFocus$", new Subject());
+    __publicField(this, "onFocus$", this._onFocus$.asObservable());
+    __publicField(this, "_onBlur$", new Subject());
+    __publicField(this, "onBlur$", this._onBlur$.asObservable());
+    __publicField(this, "_onPointerDown$", new Subject());
+    __publicField(this, "onPointerDown$", this._onPointerDown$.asObservable());
+    __publicField(this, "_container");
+    __publicField(this, "_inputParent");
+    __publicField(this, "_input");
+    __publicField(this, "_scrollTimers", []);
+    __publicField(this, "_rangeList", []);
+    // Use to cache range list in moving.
+    __publicField(this, "_rangeListCache", []);
+    // Rect range list.
+    __publicField(this, "_rectRangeList", []);
+    // Use to cache rect range list in moving.
+    __publicField(this, "_rectRangeListCache", []);
+    __publicField(this, "_anchorNodePosition", null);
+    __publicField(this, "_focusNodePosition", null);
+    __publicField(this, "_currentSegmentId", "");
+    __publicField(this, "_currentSegmentPage", -1);
+    __publicField(this, "_selectionStyle", NORMAL_TEXT_SELECTION_PLUGIN_STYLE);
+    __publicField(this, "_viewPortObserverMap", /* @__PURE__ */ new Map());
+    __publicField(this, "_isIMEInputApply", !1);
+    __publicField(this, "_scenePointerMoveSubs", []);
+    __publicField(this, "_scenePointerUpSubs", []);
+    __publicField(this, "_editorFocusing", !0);
+    // When the user switches editors, whether to clear the doc ranges.
+    __publicField(this, "_reserveRanges", !1);
+    this._context = _context, this._layoutService = _layoutService, this._logService = _logService, this._univerInstanceService = _univerInstanceService, this._docSkeletonManagerService = _docSkeletonManagerService, this._initDOM(), this._registerContainer(), this._setSystemHighlightColorToStyle(), this._listenCurrentUnitChange();
+  }
+  _listenCurrentUnitChange() {
+    this._univerInstanceService.getCurrentTypeOfUnit$(UniverInstanceType.UNIVER_DOC).pipe(takeUntil(this.dispose$)).subscribe((documentModel) => {
+      if (documentModel == null)
+        return;
+      documentModel.getUnitId() !== this._context.unitId && !this._reserveRanges && this.removeAllRanges();
+    });
+  }
+  get activeViewPort() {
+    return this._context.scene.getViewports()[0];
+  }
+  setSegment(id) {
+    this._currentSegmentId = id;
+  }
+  getSegment() {
+    return this._currentSegmentId;
+  }
+  setSegmentPage(pageIndex) {
+    this._currentSegmentPage = pageIndex;
+  }
+  getSegmentPage() {
+    return this._currentSegmentPage;
+  }
+  setReserveRangesStatus(status) {
+    this._reserveRanges = status;
+  }
+  _setRangeStyle(style = NORMAL_TEXT_SELECTION_PLUGIN_STYLE) {
+    this._selectionStyle = style;
+  }
+  // eslint-disable-next-line max-lines-per-function
+  addDocRanges(ranges, isEditing = !0, options) {
+    const {
+      _currentSegmentId: segmentId,
+      _currentSegmentPage: segmentPage,
+      _selectionStyle: style
+    } = this, { scene, mainComponent } = this._context, document2 = mainComponent, docSkeleton = this._docSkeletonManagerService.getSkeleton();
+    for (const range of ranges) {
+      const { startOffset, endOffset, rangeType, startNodePosition, endNodePosition } = range;
+      if (rangeType === DOC_RANGE_TYPE.RECT) {
+        const rectRange = getRectRangeFromCharIndex(
+          startOffset,
+          endOffset,
+          scene,
+          document2,
+          docSkeleton,
+          style,
+          segmentId,
+          segmentPage
+        );
+        rectRange && this._addRectRanges([rectRange]);
+      } else if (rangeType === DOC_RANGE_TYPE.TEXT) {
+        let textRange = null;
+        startNodePosition && endNodePosition ? textRange = getTextRangeFromCharIndex(
+          startNodePosition.isBack ? startOffset : startOffset - 1,
+          endNodePosition.isBack ? endOffset : endOffset - 1,
+          scene,
+          document2,
+          docSkeleton,
+          style,
+          segmentId,
+          segmentPage,
+          startNodePosition.isBack,
+          endNodePosition.isBack
+        ) : textRange = getTextRangeFromCharIndex(
+          startOffset,
+          endOffset,
+          scene,
+          document2,
+          docSkeleton,
+          style,
+          segmentId,
+          segmentPage
+        ), textRange && this._addTextRange(textRange);
+      } else {
+        const rangeList = getRangeListFromCharIndex(
+          startOffset,
+          endOffset,
+          scene,
+          document2,
+          docSkeleton,
+          style,
+          segmentId,
+          segmentPage
+        );
+        if (rangeList == null)
+          continue;
+        const { textRanges, rectRanges } = rangeList;
+        for (const textRange of textRanges)
+          this._addTextRange(textRange);
+        this._addRectRanges(rectRanges);
+      }
+    }
+    this._textSelectionInner$.next({
+      textRanges: this._getAllTextRanges(),
+      rectRanges: this._getAllRectRanges(),
+      segmentId,
+      segmentPage,
+      style,
+      isEditing,
+      options
+    }), this._updateInputPosition(options == null ? void 0 : options.forceFocus);
+  }
+  setCursorManually(evtOffsetX, evtOffsetY) {
+    const startNode = this._findNodeByCoord(evtOffsetX, evtOffsetY, {
+      strict: !0,
+      segmentId: this._currentSegmentId,
+      segmentPage: this._currentSegmentPage
+    }), position = this._getNodePosition(startNode);
+    if (position == null) {
+      this._removeAllRanges();
+      return;
+    }
+    (startNode == null ? void 0 : startNode.node.streamType) === DataStreamTreeTokenType.PARAGRAPH && (position.isBack = !0), this._createTextRangeByAnchorPosition(position), this._textSelectionInner$.next({
+      textRanges: this._getAllTextRanges(),
+      rectRanges: this._getAllRectRanges(),
+      segmentId: this._currentSegmentId,
+      segmentPage: this._currentSegmentPage,
+      style: this._selectionStyle,
+      isEditing: !1
+    });
+  }
+  // Sync canvas selection to dom selection.
+  sync() {
+    this._updateInputPosition();
+  }
+  /**
+   * @deprecated
+   */
+  activate(x, y, force = !1) {
+    const isFocusing = this._input === document.activeElement || document.activeElement === document.body || document.activeElement === null;
+    this._container.style.left = `${x}px`, this._container.style.top = `${y}px`, this._container.style.zIndex = "1000", (isFocusing || force) && this.focus();
+  }
+  hasFocus() {
+    return document.activeElement === this._input;
+  }
+  focus() {
+    this._editorFocusing && this._input.focus();
+  }
+  blur() {
+    this._input.blur();
+  }
+  /**
+   * @deprecated
+   */
+  focusEditor() {
+    this._editorFocusing = !0, this.focus();
+  }
+  /**
+   * @deprecated
+   */
+  blurEditor() {
+    this._editorFocusing = !1, this.blur();
+  }
+  // FIXME: for editor cell editor we don't need to blur the input element
+  /**
+   * @deprecated
+   */
+  deactivate() {
+    this._container.style.left = "0px", this._container.style.top = "0px";
+  }
+  // Handler double click.
+  __handleDblClick(evt) {
+    const { offsetX: evtOffsetX, offsetY: evtOffsetY } = evt, startNode = this._findNodeByCoord(evtOffsetX, evtOffsetY, {
+      strict: !1,
+      segmentId: this._currentSegmentId,
+      segmentPage: this._currentSegmentPage
+    });
+    if (startNode == null || startNode.node == null)
+      return;
+    const paragraphInfo = getParagraphInfoByGlyph(startNode.node);
+    if (paragraphInfo == null)
+      return;
+    const { content, st, nodeIndex } = paragraphInfo;
+    if (nodeIndex === -1 || Intl.Segmenter == null)
+      return;
+    const segments = new Intl.Segmenter(void 0, { granularity: "word" }).segment(content);
+    let startOffset = Number.NEGATIVE_INFINITY, endOffset = Number.NEGATIVE_INFINITY;
+    for (const { segment, index, isWordLike } of segments)
+      if (index <= nodeIndex && nodeIndex < index + segment.length && isWordLike) {
+        startOffset = index + st, endOffset = index + st + segment.length;
+        break;
+      }
+    if (Number.isFinite(startOffset) && Number.isFinite(endOffset)) {
+      this.removeAllRanges();
+      const textRanges = [
+        {
+          startOffset,
+          endOffset
+        }
+      ];
+      this.addDocRanges(textRanges, !1, { forceFocus: !0 });
+    }
+  }
+  __handleTripleClick(evt) {
+    const { offsetX: evtOffsetX, offsetY: evtOffsetY } = evt, startNode = this._findNodeByCoord(evtOffsetX, evtOffsetY, {
+      strict: !1,
+      segmentId: this._currentSegmentId,
+      segmentPage: this._currentSegmentPage
+    });
+    if (startNode == null || startNode.node == null)
+      return;
+    const paragraphInfo = getParagraphInfoByGlyph(startNode.node);
+    if (paragraphInfo == null)
+      return;
+    this.removeAllRanges();
+    const { st, ed } = paragraphInfo, textRanges = [
+      {
+        startOffset: st,
+        endOffset: ed
+      }
+    ];
+    this.addDocRanges(textRanges, !1, { forceFocus: !0 });
+  }
+  // Handle pointer down.
+  // eslint-disable-next-line max-lines-per-function, complexity
+  __onPointDown(evt) {
+    var _a2, _b;
+    this._editorFocusing = !0;
+    const { scene, mainComponent } = this._context, skeleton = this._docSkeletonManagerService.getSkeleton(), { offsetX: evtOffsetX, offsetY: evtOffsetY } = evt, startNode = this._findNodeByCoord(evtOffsetX, evtOffsetY, {
+      strict: !1,
+      segmentId: this._currentSegmentId,
+      segmentPage: this._currentSegmentPage
+    }), position = this._getNodePosition(startNode);
+    if (position == null || startNode == null) {
+      this._removeAllRanges();
+      return;
+    }
+    (startNode == null ? void 0 : startNode.node.streamType) === DataStreamTreeTokenType.PARAGRAPH && (position.isBack = !0);
+    const docSelection = this._textSelectionInner$.value;
+    if (startNode && evt.button === 2 && docSelection) {
+      const nodeCharIndex = skeleton.findCharIndexByPosition(position);
+      if (typeof nodeCharIndex == "number" && docSelection.textRanges.some((textRange) => textRange.startOffset <= nodeCharIndex && textRange.endOffset > nodeCharIndex) || typeof nodeCharIndex == "number" && docSelection.rectRanges.some((rectRange) => rectRange.startOffset <= nodeCharIndex && rectRange.endOffset >= nodeCharIndex))
+        return;
+    }
+    const { segmentId, segmentPage } = startNode;
+    segmentId && this._currentSegmentId && segmentId !== this._currentSegmentId && this.setSegment(segmentId), segmentId && segmentPage !== this._currentSegmentPage && this.setSegmentPage(segmentPage), this._anchorNodePosition = position, evt.shiftKey && this._getActiveRangeInstance() ? this._updateActiveRangePosition(position) : evt.ctrlKey ? this._removeAllCollapsedTextRanges() : this._isEmpty() || this._removeAllRanges(), scene.disableObjectsEvent();
+    const scrollTimer = ScrollTimer.create(scene);
+    this._scrollTimers.push(scrollTimer), scrollTimer.startScroll(evtOffsetX, evtOffsetY), this._onSelectionStart$.next((_a2 = this._getActiveRangeInstance()) == null ? void 0 : _a2.startNodePosition), (_b = scene.getTransformer()) == null || _b.clearSelectedObjects();
+    let preMoveOffsetX = evtOffsetX, preMoveOffsetY = evtOffsetY;
+    this._scenePointerMoveSubs.push(scene.onPointerMove$.subscribeEvent((moveEvt) => {
+      const { offsetX: moveOffsetX, offsetY: moveOffsetY } = moveEvt;
+      scene.setCursor(CURSOR_TYPE.TEXT), !(Math.sqrt((moveOffsetX - preMoveOffsetX) ** 2 + (moveOffsetY - preMoveOffsetY) ** 2) < 3) && (this._moving(moveOffsetX, moveOffsetY), scrollTimer.scrolling(moveOffsetX, moveOffsetY, () => {
+        this._moving(moveOffsetX, moveOffsetY);
+      }), preMoveOffsetX = moveOffsetX, preMoveOffsetY = moveOffsetY);
+    })), this._scenePointerUpSubs.push(scene.onPointerUp$.subscribeEvent(() => {
+      if ([...this._scenePointerMoveSubs, ...this._scenePointerUpSubs].forEach((e) => {
+        e.unsubscribe();
+      }), scene.enableObjectsEvent(), this._anchorNodePosition && !this._focusNodePosition) {
+        if (evt.ctrlKey) {
+          this._disposeScrollTimers();
+          return;
+        }
+        const textRange = new TextRange(scene, mainComponent, skeleton, this._anchorNodePosition, void 0, this._selectionStyle, this._currentSegmentId, this._currentSegmentPage);
+        this._addTextRange(textRange);
+      } else if (this._anchorNodePosition && this._focusNodePosition) {
+        for (const textRange of this._rangeListCache)
+          evt.ctrlKey ? textRange.collapsed ? textRange.dispose() : this._addTextRange(textRange) : this._addTextRange(textRange);
+        this._addRectRanges(this._rectRangeListCache), this._rangeListCache = [], this._rectRangeListCache = [];
+      }
+      this._anchorNodePosition = null, this._focusNodePosition = null;
+      const selectionInfo = {
+        textRanges: this._getAllTextRanges(),
+        rectRanges: this._getAllRectRanges(),
+        segmentId: this._currentSegmentId,
+        segmentPage: this._currentSegmentPage,
+        style: this._selectionStyle,
+        isEditing: !1
+      };
+      this._textSelectionInner$.next(selectionInfo), this._disposeScrollTimers(), this._updateInputPosition(!0);
+    }));
+  }
+  removeAllRanges() {
+    this._removeAllRanges(), this.deactivate();
+  }
+  getActiveTextRange() {
+    return this._getActiveRangeInstance();
+  }
+  _disposeScrollTimers() {
+    this._scrollTimers.forEach((timer) => {
+      timer == null || timer.dispose();
+    }), this._scrollTimers = [];
+  }
+  _setSystemHighlightColorToStyle() {
+    const { r, g, b, a } = getSystemHighlightColor(), style = {
+      strokeWidth: 1.5,
+      stroke: "rgba(0, 0, 0, 0)",
+      strokeActive: "rgba(0, 0, 0, 1)",
+      fill: `rgba(${r}, ${g}, ${b}, ${a != null ? a : 0.3})`
+    };
+    this._setRangeStyle(style);
+  }
+  _getAllTextRanges() {
+    return this._rangeList.map(serializeTextRange);
+  }
+  _getAllRectRanges() {
+    return this._rectRangeList.map(serializeRectRange);
+  }
+  _getActiveRange() {
+    const activeRange = this._rangeList.find((range) => range.isActive());
+    if (activeRange == null)
+      return null;
+    const { startOffset, endOffset } = activeRange;
+    return startOffset == null || endOffset == null ? null : serializeTextRange(activeRange);
+  }
+  _getActiveRangeInstance() {
+    return this._rangeList.find((range) => range.isActive());
+  }
+  dispose() {
+    super.dispose(), this._detachEvent(), this._removeAllRanges(), this._container.remove();
+  }
+  _initDOM() {
+    const { unitId } = this._context, container = document.createElement("div");
+    container.style.position = "fixed", container.style.left = "0px", container.style.top = "0px", container.id = `univer-doc-selection-container-${unitId}`;
+    const inputParent = document.createElement("div"), inputDom = document.createElement("div");
+    inputParent.appendChild(inputDom), container.appendChild(inputParent), this._container = container, this._inputParent = inputParent, this._input = inputDom, this._initInput(), this._initInputEvents(), document.body.appendChild(container);
+  }
+  _registerContainer() {
+    this.disposeWithMe(
+      // the content editable div should be regarded as part of the applications container
+      this._layoutService.registerContainerElement(this._container)
+    );
+  }
+  _initInput() {
+    this._inputParent.style.cssText = `
+            position:absolute;
+            height:1px;
+            width:1px;
+            overflow: hidden;
+        `, this._input.contentEditable = "true", this._input.classList.add("univer-editor"), this._input.style.cssText = `
+            position: absolute;
+            overflow: hidden;
+            opacity: 1;
+            background: #000;
+            color: transparent;
+            outline: none;
+            z-index: -2;
+            caret-color: transparent;
+            white-space: pre-wrap;
+            user-select: text;
+        `;
+  }
+  _getNodePosition(node) {
+    if (node == null)
+      return;
+    const { node: glyph, ratioX, segmentPage } = node, position = this._docSkeletonManagerService.getSkeleton().findPositionByGlyph(glyph, segmentPage);
+    if (position == null)
+      return;
+    const isBack = ratioX < 0.5;
+    return {
+      ...position,
+      isBack
+    };
+  }
+  _interactTextRanges(textRanges) {
+    const newTextRanges = [];
+    for (const range of this._rangeList) {
+      if (textRanges.some((textRange) => textRange.isIntersection(range))) {
+        range.dispose();
+        continue;
+      }
+      newTextRanges.push(range);
+    }
+    this._rangeList = newTextRanges;
+  }
+  _interactRectRanges(rectRanges) {
+    const newRanges = [];
+    for (const range of this._rectRangeList) {
+      if (rectRanges.some((rectRange) => rectRange.isIntersection(range))) {
+        range.dispose();
+        continue;
+      }
+      newRanges.push(range);
+    }
+    this._rectRangeList = newRanges;
+  }
+  _removeCollapsedTextRange() {
+    const oldTextRanges = this._rangeList;
+    this._rangeList = [];
+    for (const textRange of oldTextRanges)
+      textRange.collapsed ? textRange.dispose() : this._rangeList.push(textRange);
+  }
+  _removeAllRanges() {
+    this._removeAllTextRanges(), this._removeAllRectRanges();
+  }
+  _removeAllCacheRanges() {
+    this._rangeListCache.forEach((range) => {
+      range.dispose();
+    }), this._rectRangeListCache.forEach((range) => {
+      range.dispose();
+    }), this._rangeListCache = [], this._rectRangeListCache = [];
+  }
+  _removeAllTextRanges() {
+    this._rangeList.forEach((range) => {
+      range.dispose();
+    }), this._rangeList = [];
+  }
+  _removeAllRectRanges() {
+    this._rectRangeList.forEach((range) => {
+      range.dispose();
+    }), this._rectRangeList = [];
+  }
+  _removeAllCollapsedTextRanges() {
+    for (const range of this._rangeList)
+      range.collapsed && range.dispose();
+  }
+  _deactivateAllTextRanges() {
+    this._rangeList.forEach((range) => {
+      range.deactivate();
+    });
+  }
+  _deactivateAllRectRanges() {
+    this._rectRangeList.forEach((range) => {
+      range.deactivate();
+    });
+  }
+  _addTextRangesToCache(textRanges) {
+    this._rangeListCache.push(...textRanges);
+  }
+  _addTextRange(textRange) {
+    this._deactivateAllTextRanges(), textRange.activate(), this._rangeList.push(textRange);
+  }
+  _addRectRangesToCache(rectRanges) {
+    this._rectRangeListCache.push(...rectRanges);
+  }
+  _addRectRanges(rectRanges) {
+    rectRanges.length !== 0 && (this._deactivateAllRectRanges(), rectRanges[rectRanges.length - 1].activate(), this._rectRangeList.push(...rectRanges));
+  }
+  _createTextRangeByAnchorPosition(position) {
+    this._removeAllRanges();
+    const { scene, mainComponent } = this._context, skeleton = this._docSkeletonManagerService.getSkeleton(), lastRange = new TextRange(scene, mainComponent, skeleton, position, void 0, this._selectionStyle, this._currentSegmentId, this._currentSegmentPage);
+    this._addTextRange(lastRange);
+  }
+  _updateActiveRangePosition(position) {
+    const activeTextRange = this._getActiveRangeInstance();
+    if (activeTextRange == null || activeTextRange.anchorNodePosition == null) {
+      this._logService.error(
+        "[DocSelectionRenderService] _updateActiveRangeFocusPosition: active range has no anchor"
+      );
+      return;
+    }
+    this._removeAllRanges(), this._anchorNodePosition = activeTextRange.anchorNodePosition, this._focusNodePosition = position;
+    const { scene, mainComponent } = this._context, skeleton = this._docSkeletonManagerService.getSkeleton(), { _anchorNodePosition, _focusNodePosition, _selectionStyle, _currentSegmentId, _currentSegmentPage } = this;
+    if (_anchorNodePosition == null || _focusNodePosition == null || mainComponent == null)
+      return;
+    const ranges = getRangeListFromSelection(
+      _anchorNodePosition,
+      _focusNodePosition,
+      scene,
+      mainComponent,
+      skeleton,
+      _selectionStyle,
+      _currentSegmentId,
+      _currentSegmentPage
+    );
+    if (ranges == null)
+      return;
+    const { textRanges, rectRanges } = ranges;
+    this._addTextRangesToCache(textRanges), this._addRectRangesToCache(rectRanges), this.deactivate();
+  }
+  _isEmpty() {
+    return this._rangeList.length === 0 && this._rectRangeList.length === 0;
+  }
+  _getCanvasOffset() {
+    var _a2;
+    const engine = (_a2 = this._context.scene) == null ? void 0 : _a2.getEngine();
+    return getCanvasOffsetByEngine(engine);
+  }
+  _updateInputPosition(forceFocus = !1) {
+    const activeRangeInstance = this._getActiveRangeInstance(), anchor = activeRangeInstance == null ? void 0 : activeRangeInstance.getAnchor();
+    if (!anchor || anchor && !anchor.visible || this.activeViewPort == null) {
+      this.focus();
+      return;
+    }
+    const { left, top } = anchor, absoluteCoord = this.activeViewPort.getAbsoluteVector(Vector2.FromArray([left, top])), { x, y } = absoluteCoord;
+    let { left: canvasLeft, top: canvasTop } = this._getCanvasOffset();
+    canvasLeft += x, canvasTop += y, this.activate(canvasLeft, canvasTop, forceFocus);
+  }
+  _moving(moveOffsetX, moveOffsetY) {
+    var _a2, _b;
+    const focusNode = this._findNodeByCoord(moveOffsetX, moveOffsetY, {
+      strict: !0,
+      segmentId: this._currentSegmentId,
+      segmentPage: this._currentSegmentPage
+    }), focusNodePosition = this._getNodePosition(focusNode);
+    if (!focusNodePosition || focusNode == null)
+      return;
+    const divide = focusNode == null ? void 0 : focusNode.node.parent, nextGlyph = divide == null ? void 0 : divide.glyphGroup[divide.glyphGroup.indexOf(focusNode.node) + 1];
+    (focusNode == null ? void 0 : focusNode.node.streamType) === DataStreamTreeTokenType.PARAGRAPH && (nextGlyph == null ? void 0 : nextGlyph.streamType) === DataStreamTreeTokenType.SECTION_BREAK && (focusNodePosition.isBack = !0), this._focusNodePosition = focusNodePosition, this._removeAllCacheRanges();
+    const { _anchorNodePosition, _focusNodePosition, _selectionStyle, _currentSegmentId, _currentSegmentPage } = this, { scene, mainComponent } = this._context, skeleton = this._docSkeletonManagerService.getSkeleton();
+    if (_anchorNodePosition == null || _focusNodePosition == null || mainComponent == null)
+      return;
+    const ranges = getRangeListFromSelection(
+      _anchorNodePosition,
+      _focusNodePosition,
+      scene,
+      mainComponent,
+      skeleton,
+      _selectionStyle,
+      _currentSegmentId,
+      _currentSegmentPage
+    );
+    if (ranges == null)
+      return;
+    const { textRanges, rectRanges } = ranges;
+    this._rangeList.length > 0 && textRanges.length > 0 && this._interactTextRanges(textRanges), this._rectRangeList.length > 0 && rectRanges.length > 0 && this._interactRectRanges(rectRanges), this._addTextRangesToCache(textRanges), this._addRectRangesToCache(rectRanges), this.deactivate(), (_b = (_a2 = this._context.scene) == null ? void 0 : _a2.getEngine()) == null || _b.setRemainCapture();
+  }
+  __attachScrollEvent() {
+    const viewport = this.activeViewPort;
+    if (!viewport)
+      return;
+    const { unitId } = this._context;
+    if (this._viewPortObserverMap.has(unitId))
+      return;
+    const scrollBefore = viewport.onScrollAfter$.subscribeEvent((param) => {
+      if (!param.viewport)
+        return;
+      const activeRangeInstance = this._getActiveRangeInstance();
+      activeRangeInstance == null || activeRangeInstance.activeStatic();
+    }), scrollStop = viewport.onScrollEnd$.subscribeEvent((param) => {
+      const viewport2 = param.viewport;
+      if (!viewport2)
+        return;
+      const bounds = viewport2.getBounding(), activeRangeInstance = this._getActiveRangeInstance(), anchor = activeRangeInstance == null ? void 0 : activeRangeInstance.getAnchor();
+      if (!(!anchor || anchor && !anchor.visible)) {
+        if (bounds) {
+          const { left, top, right, bottom } = bounds.viewBound;
+          if (anchor.left < left || anchor.left > right || anchor.top < top || anchor.top > bottom) {
+            activeRangeInstance == null || activeRangeInstance.deactivateStatic();
+            return;
+          }
+        }
+        this._updateInputPosition();
+      }
+    });
+    this._viewPortObserverMap.set(unitId, {
+      scrollBefore,
+      scrollStop
+    });
+  }
+  // FIXME: listeners here are not correctly disposed
+  // eslint-disable-next-line max-lines-per-function
+  _initInputEvents() {
+    this.disposeWithMe(
+      fromEvent(this._input, "keydown").subscribe((e) => {
+        this._isIMEInputApply || this._eventHandle(e, (config) => {
+          this._onKeydown$.next(config);
+        });
+      })
+    ), this.disposeWithMe(
+      fromEvent(this._input, "input").subscribe((e) => {
+        if (!(e.inputType === "historyUndo" || e.inputType === "historyRedo")) {
+          if (this._rectRangeList.length > 0)
+            return e.stopPropagation(), e.preventDefault();
+          this._isIMEInputApply || this._eventHandle(e, (config) => {
+            this._onInputBefore$.next(config), this._onInput$.next(config);
+          });
+        }
+      })
+    ), this.disposeWithMe(
+      fromEvent(this._input, "compositionstart").subscribe((e) => {
+        if (this._rectRangeList.length > 0)
+          return e.stopPropagation(), e.preventDefault();
+        this._isIMEInputApply = !0, this._eventHandle(e, (config) => {
+          this._onCompositionstart$.next(config);
+        });
+      })
+    ), this.disposeWithMe(
+      fromEvent(this._input, "compositionend").subscribe((e) => {
+        this._isIMEInputApply = !1, this._eventHandle(e, (config) => {
+          this._onCompositionend$.next(config);
+        });
+      })
+    ), this.disposeWithMe(
+      fromEvent(this._input, "compositionupdate").subscribe((e) => {
+        this._eventHandle(e, (config) => {
+          this._onInputBefore$.next(config), this._onCompositionupdate$.next(config);
+        });
+      })
+    ), this.disposeWithMe(
+      fromEvent(this._input, "paste").subscribe((e) => {
+        this._eventHandle(e, (config) => {
+          this._onPaste$.next(config);
+        });
+      })
+    ), this.disposeWithMe(
+      fromEvent(this._input, "focus").subscribe((e) => {
+        this._eventHandle(e, (config) => {
+          this._onFocus$.next(config);
+        });
+      })
+    ), this.disposeWithMe(
+      fromEvent(this._input, "blur").subscribe((e) => {
+        this._eventHandle(e, (config) => {
+          this._onBlur$.next(config);
+        });
+      })
+    );
+  }
+  _eventHandle(e, func) {
+    const content = this._input.textContent || "";
+    this._input.innerHTML = "";
+    const activeRange = this._getActiveRange(), rangeList = this._getAllTextRanges();
+    func({
+      event: e,
+      content,
+      activeRange,
+      rangeList
+    });
+  }
+  _getTransformCoordForDocumentOffset(evtOffsetX, evtOffsetY) {
+    const document2 = this._context.mainComponent, { documentTransform } = document2.getOffsetConfig();
+    if (this.activeViewPort == null || documentTransform == null)
+      return;
+    const originCoord = this.activeViewPort.transformVector2SceneCoord(Vector2.FromArray([evtOffsetX, evtOffsetY]));
+    if (originCoord)
+      return documentTransform.clone().invert().applyPoint(originCoord);
+  }
+  _findNodeByCoord(evtOffsetX, evtOffsetY, restrictions) {
+    const coord = this._getTransformCoordForDocumentOffset(evtOffsetX, evtOffsetY);
+    if (coord == null)
+      return;
+    const document2 = this._context.mainComponent, skeleton = this._docSkeletonManagerService.getSkeleton(), {
+      pageLayoutType = PageLayoutType.VERTICAL,
+      pageMarginLeft,
+      pageMarginTop
+    } = document2.getOffsetConfig();
+    return skeleton.findNodeByCoord(
+      coord,
+      pageLayoutType,
+      pageMarginLeft,
+      pageMarginTop,
+      restrictions
+    );
+  }
+  _detachEvent() {
+    this._onInputBefore$.complete(), this._onKeydown$.complete(), this._onInput$.complete(), this._onCompositionstart$.complete(), this._onCompositionupdate$.complete(), this._onCompositionend$.complete(), this._onSelectionStart$.complete(), this._textSelectionInner$.complete(), this._onPaste$.complete(), this._onFocus$.complete(), this._onBlur$.complete(), this._onPointerDown$.complete();
+  }
+}, __name(_a, "DocSelectionRenderService"), _a);
+DocSelectionRenderService = __decorateClass([
+  __decorateParam(1, ILayoutService),
+  __decorateParam(2, ILogService),
+  __decorateParam(3, IUniverInstanceService),
+  __decorateParam(4, Inject(DocSkeletonManagerService))
+], DocSelectionRenderService);
+var DeleteDirection = /* @__PURE__ */ ((DeleteDirection2) => (DeleteDirection2[DeleteDirection2.LEFT = 0] = "LEFT", DeleteDirection2[DeleteDirection2.RIGHT = 1] = "RIGHT", DeleteDirection2))(DeleteDirection || {});
+const EditorInsertTextCommandId = "doc.command.insert-text", InsertCommand = {
+  id: EditorInsertTextCommandId,
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name(async (accessor, params) => {
+    var _a2;
+    const commandService = accessor.get(ICommandService), { range, segmentId, body, unitId, cursorOffset, extendLastRange } = params, docSelectionManagerService = accessor.get(DocSelectionManagerService), docDataModel = accessor.get(IUniverInstanceService).getUnit(unitId, UniverInstanceType.UNIVER_DOC);
+    if (docDataModel == null)
+      return !1;
+    const activeRange = docSelectionManagerService.getActiveTextRange(), originBody = docDataModel.getSelfOrHeaderFooterModel((_a2 = activeRange == null ? void 0 : activeRange.segmentId) != null ? _a2 : "").getBody();
+    if (originBody == null)
+      return !1;
+    const actualRange = extendLastRange ? BuildTextUtils.selection.getDeleteSelection(range, originBody) : BuildTextUtils.selection.getInsertSelection(range, originBody), { startOffset, collapsed } = actualRange, cursorMove = cursorOffset != null ? cursorOffset : body.dataStream.length, textRanges = [
+      {
+        startOffset: startOffset + cursorMove,
+        endOffset: startOffset + cursorMove,
+        style: activeRange == null ? void 0 : activeRange.style,
+        collapsed
+      }
+    ], doMutation = {
+      id: RichTextEditingMutation.id,
+      params: {
+        unitId,
+        actions: [],
+        textRanges,
+        debounce: !0
+      }
+    }, textX = new TextX(), jsonX = JSONX.getInstance();
+    if (collapsed)
+      startOffset > 0 && textX.push({
+        t: TextXActionType.RETAIN,
+        len: startOffset
+      });
+    else {
+      const { dos, retain } = BuildTextUtils.selection.getDeleteActions(actualRange, segmentId, 0, originBody);
+      textX.push(...dos), doMutation.params.textRanges = [{
+        startOffset: startOffset + cursorMove + retain,
+        endOffset: startOffset + cursorMove + retain,
+        collapsed
+      }];
+    }
+    textX.push({
+      t: TextXActionType.INSERT,
+      body,
+      len: body.dataStream.length
+    });
+    const path = getRichTextEditPath(docDataModel, segmentId);
+    return doMutation.params.actions = jsonX.editOp(textX.serialize(), path), !!commandService.syncExecuteCommand(doMutation.id, doMutation.params);
+  }, "handler")
+}, DeleteCommand = {
+  id: "doc.command.delete-text",
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name(async (accessor, params) => {
+    var _a2;
+    const commandService = accessor.get(ICommandService), univerInstanceService = accessor.get(IUniverInstanceService), { range, segmentId, unitId, direction, len = 1 } = params, docDataModel = univerInstanceService.getUnit(unitId, UniverInstanceType.UNIVER_DOC), body = docDataModel == null ? void 0 : docDataModel.getSelfOrHeaderFooterModel(segmentId).getBody();
+    if (docDataModel == null || body == null)
+      return !1;
+    const { startOffset } = range, dataStream = body.dataStream, start = direction === DeleteDirection.LEFT ? startOffset - len : startOffset, end = start + len - 1, relativeCustomRanges = (_a2 = body.customRanges) == null ? void 0 : _a2.filter((customRange) => BuildTextUtils.customRange.isIntersecting(customRange.startIndex, customRange.endIndex, start, end)), toDeleteRanges = relativeCustomRanges == null ? void 0 : relativeCustomRanges.filter((customRange) => BuildTextUtils.customRange.shouldDeleteCustomRange(start, len, customRange, dataStream)), deleteIndexes = [];
+    for (let i = 0; i < len; i++)
+      deleteIndexes.push(start + i);
+    toDeleteRanges == null || toDeleteRanges.forEach((range2) => {
+      deleteIndexes.push(range2.startIndex, range2.endIndex);
+    }), deleteIndexes.sort((pre, aft) => pre - aft);
+    const deleteStart = deleteIndexes[0], doMutation = {
+      id: RichTextEditingMutation.id,
+      params: {
+        unitId,
+        actions: [],
+        textRanges: [{
+          startOffset: deleteStart,
+          endOffset: deleteStart,
+          collapsed: !0
+        }],
+        debounce: !0
+      }
+    }, textX = new TextX(), jsonX = JSONX.getInstance();
+    let cursor = 0;
+    for (let i = 0; i < deleteIndexes.length; i++) {
+      const deleteIndex = deleteIndexes[i];
+      deleteIndex - cursor > 0 && textX.push({
+        t: TextXActionType.RETAIN,
+        len: deleteIndex - cursor
+      }), textX.push({
+        t: TextXActionType.DELETE,
+        len: 1
+      }), cursor = deleteIndex + 1;
+    }
+    const path = getRichTextEditPath(docDataModel, segmentId);
+    return doMutation.params.actions = jsonX.editOp(textX.serialize(), path), !!commandService.syncExecuteCommand(doMutation.id, doMutation.params);
+  }, "handler")
+}, UpdateCommand = {
+  id: "doc.command.update-text",
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name(async (accessor, params) => {
+    const { range, segmentId, updateBody, coverType, unitId, textRanges } = params, commandService = accessor.get(ICommandService), docDataModel = accessor.get(IUniverInstanceService).getCurrentUniverDocInstance();
+    if (docDataModel == null)
+      return !1;
+    const doMutation = {
+      id: RichTextEditingMutation.id,
+      params: {
+        unitId,
+        actions: [],
+        textRanges
+      }
+    }, textX = new TextX(), jsonX = JSONX.getInstance(), { startOffset, endOffset } = range;
+    textX.push({
+      t: TextXActionType.RETAIN,
+      len: startOffset
+    }), textX.push({
+      t: TextXActionType.RETAIN,
+      body: updateBody,
+      len: endOffset - startOffset,
+      coverType
+    });
+    const path = getRichTextEditPath(docDataModel, segmentId);
+    return doMutation.params.actions = jsonX.editOp(textX.serialize(), path), !!commandService.syncExecuteCommand(doMutation.id, doMutation.params);
+  }, "handler")
+};
+export {
+  DocSelectionRenderService as D,
+  EditorInsertTextCommandId as E,
+  InsertCommand as I,
+  NodePositionConvertToCursor as N,
+  RectRange as R,
+  TEXT_RANGE_LAYER_INDEX as T,
+  UpdateCommand as U,
+  getCommandSkeleton as a,
+  DeleteDirection as b,
+  DeleteCommand as c,
+  getAnchorBounding as d,
+  getLineBounding as e,
+  isValidRectRange as f,
+  getRichTextEditPath as g,
+  NodePositionConvertToRectRange as h,
+  isInSameTableCell as i,
+  getOneTextSelectionRange as j,
+  convertPositionsToRectRanges as k,
+  getCanvasOffsetByEngine as l,
+  TextRange as m
+};