@hailin-zheng/editor-core 1.0.6 → 1.0.9

package/{lib/framework/element-util.js → src/med_editor/framework/element-util.ts}

@@ -1,22 +1,48 @@
 import { nanoid } from "nanoid";
-import { BranchElement, LeafElement, Rect } from "./element-define";
-import { TextProps } from "./element-props";
+import { EditorContext } from "./document-context";
+import {
+    BlockContainerElement,
+    BranchElement,
+    Element,
+    LeafElement,
+    Position,
+    Rect,
+    SelectionContentRange,
+    ViewOptions
+} from "./element-define";
+import { HitRegion } from "./element-event-define";
+import { DataEleBaseProps, TextProps } from "./element-props";
 import { CommsContainerElement } from "./impl/comments/comments-container-impl";
-import { DataElementInlineGroup } from "./impl/data-element/data-element-base-impl";
+import { DataElementInlineGroup} from "./impl/data-element/data-element-base-impl";
 import { DocumentBodyElement } from "./impl/document/doc-body-impl";
 import { DocumentFooterElement } from "./impl/document/doc-footer-impl";
 import { DocumentHeaderElement } from "./impl/document/doc-header-impl";
 import { DocumentRenderObject } from "./impl/document/doc-impl";
 import { ParagraphElement, ParagraphLineRectRenderObject, ParagraphRenderObject } from "./impl/paragraph/p-impl";
 import { PSymbolElement } from "./impl/symbol/p-symbol-impl";
-import { TableCellElement } from "./impl/table/table-cell-impl";
-import { TableRenderObject } from "./impl/table/table-impl";
-import { TableRowRenderObject } from "./impl/table/table-row-impl";
+import { TableCellElement, TableCellRenderObject } from "./impl/table/table-cell-impl";
+import { TableElement, TableRenderObject } from "./impl/table/table-impl";
+import { TableRowElement, TableRowRenderObject } from "./impl/table/table-row-impl";
 import { TextGroupElement, TextGroupRenderObject } from "./impl/text/text-impl";
-import { TrackRunElement } from "./impl/text/track-run-impl";
-import { BranchRenderObject, LeafRenderObject } from "./render-define";
+import { TrackRunElement, TrackRunTypeEnum } from "./impl/text/track-run-impl";
+import {
+    BlockContainerRenderObject,
+    BlockContentRenderObject,
+    BorderType,
+    BranchRenderObject,
+    CursorType,
+    InlineGroupRenderObject,
+    LeafRenderObject,
+    RenderObject
+} from "./render-define";
+
+
+type PAIR = { x: number, y: number };
+
 export class ElementUtil {
-    static setCanvasProps(canvas, ctx, viewOptions, scale = 1) {
+
+
+    static setCanvasProps(canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D, viewOptions: { width: number, height: number }, scale: number = 1): void {
         // if (canvas instanceof OffscreenCanvas) {
         //     this.setOffscreenCanvas(canvas, ctx as OffscreenCanvasRenderingContext2D, viewOptions, scale);
         //     return
@@ -35,7 +61,9 @@ export class ElementUtil {
         canvas.height = scaleHeight * dpr;
         ctx.scale(dpr, dpr);
     }
+
     // static setOffscreenCanvas(canvas: OffscreenCanvas, ctx: OffscreenCanvasRenderingContext2D, viewOptions: { width: number, height: number }, scale: number = 1): void {
+
     //     const { width, height } = viewOptions;
     //     let dpr = window.devicePixelRatio || 1;
     //     if (scale > 1) {
@@ -48,15 +76,17 @@ export class ElementUtil {
     //     canvas.height = scaleHeight * dpr;
     //     ctx.scale(dpr, dpr);
     // }
-    static getDprNumber(val, scale = 1) {
+
+    static getDprNumber(val: number, scale: number = 1): number {
         let dpr = window.devicePixelRatio || 1;
         if (scale > 1) {
             dpr *= scale;
         }
         dpr = Math.ceil(dpr);
-        return Math.floor(val * dpr) / dpr;
+        return Math.floor(val * dpr) / dpr
     }
-    static readTextProps(dest, props, options) {
+
+    static readTextProps(dest: TextProps | null, props: TextProps | undefined, options: ViewOptions): TextProps {
         if (!props) {
             return this.createTextProps(dest, options);
         }
@@ -91,7 +121,8 @@ export class ElementUtil {
         }
         return textProps;
     }
-    static readEleBaseProps(dest, props) {
+
+    static readEleBaseProps(dest: DataEleBaseProps, props: DataEleBaseProps): DataEleBaseProps {
         dest.id = props.id ?? nanoid(5);
         dest.name = props.name;
         dest.caption = props.caption;
@@ -106,32 +137,35 @@ export class ElementUtil {
         dest.type = props.type;
         return dest;
     }
+
     /**
      * 获取内容区域最大高度
      * @param render
      * @param renderHeight
      * @returns
      */
-    static innerRectMaxHeight(render, renderHeight) {
+    static innerRectMaxHeight(render: RenderObject, renderHeight: number): number {
         const { padding } = render;
         return renderHeight - padding.top - padding.bottom;
     }
+
     /**
      * 根据内框内容高度，更新外框框体高度
      * @param render
      * @param innerRect
      */
-    static updateRenderHeightByInnerRect(render, innerRect) {
+    static updateRenderHeightByInnerRect(render: RenderObject, innerRect: Rect): void {
         const { padding, margin } = render;
         //外层容器高度等于内容高度+外边距+内边距
         render.rect.height = innerRect.height + margin.top + margin.bottom + padding.top + padding.bottom;
     }
+
     /**
      * 设置块级元素限制尺寸
      * @param render
      * @param parentLimitRect
      */
-    static setBlockElementLimitSize(render, parentLimitRect) {
+    static setBlockElementLimitSize(render: BlockContainerRenderObject | BlockContentRenderObject, parentLimitRect: Rect): void {
         render.rect.x = parentLimitRect.x;
         render.rect.y = parentLimitRect.y + parentLimitRect.height;
         render.rect.width = parentLimitRect.maxWidth ?? 0;
@@ -140,12 +174,13 @@ export class ElementUtil {
             render.rect.maxHeight = parentLimitRect.maxHeight - parentLimitRect.height;
         }
     }
+
     /**
      * 克隆框体
      * @param rect
      * @returns
      */
-    static cloneRect(rect) {
+    static cloneRect(rect: Rect): Rect {
         const cloneRect = new Rect();
         cloneRect.x = rect.x;
         cloneRect.y = rect.y;
@@ -155,13 +190,14 @@ export class ElementUtil {
         cloneRect.maxWidth = rect.maxWidth;
         return cloneRect;
     }
+
     /**
      * 重新限定子元素以及当前高度值,并返回内边框内容高度
      * @param render
      * @param resetX 测量段落外框时，内框不需要重置x，因为内框已经存在对齐
      * @returns
      */
-    static remeasure(render, resetX = true) {
+    static remeasure(render: BlockContainerRenderObject | BlockContentRenderObject, resetX = true): number {
         if (render.rect.width === 0) {
             return -1;
         }
@@ -184,8 +220,9 @@ export class ElementUtil {
         render.updateRenderHeight(innerRect);
         return innerRect.height;
     }
-    static remeasureTableRow(rowRender, foreceColIndex = -1) {
-        const rowEle = rowRender.element;
+
+    static remeasureTableRow(rowRender: TableRowRenderObject, foreceColIndex = -1): number {
+        const rowEle = rowRender.element as TableRowElement;
         const rowMinHeight = rowEle.props.minHeight > 19 ? rowEle.props.minHeight : 19;
         let maxCellheight = rowMinHeight;
         //限制行最小高度
@@ -193,15 +230,15 @@ export class ElementUtil {
         //获取行内非纵向合并单元格的最高单元格高度
         for (let i = 0; i < rowRender.length; i++) {
             const cellRender = rowRender.getChild(i);
-            const { vMerge } = cellRender.element.props;
+            const { vMerge } = (<TableCellElement>cellRender.element).props;
             if (cellRender.rect.height > maxCellheight && (vMerge !== 'restart' || i === foreceColIndex)) {
                 maxCellheight = cellRender.rect.height;
             }
         }
         //循环设置单元格高度为行内最大单元格高度
         for (let i = 0; i < rowRender.length; i++) {
-            const cellRender = rowRender.getChild(i);
-            const cellElement = cellRender.element;
+            const cellRender = rowRender.getChild(i) as TableCellRenderObject;
+            const cellElement = <TableCellElement>cellRender.element;
             const { vMerge } = cellElement.props;
             if ((vMerge !== 'restart' || i === foreceColIndex) || cellRender.rect.height < maxCellheight) {
                 cellRender.rect.height = maxCellheight;
@@ -213,43 +250,46 @@ export class ElementUtil {
         rowRender.updateRenderHeight(maxCellheight);
         return maxCellheight;
     }
+
     /**
      * 获取表格行绘制元素的内容高度，用于缩放行高度时，获取最小内容高度，缩放的高度不能小于内容最小高度
      */
-    static getTableRowRenderContentHeight(rowRender) {
-        const rowEle = rowRender.element;
+    static getTableRowRenderContentHeight(rowRender: TableRowRenderObject): number {
+        const rowEle = rowRender.element as TableRowElement;
         let maxCellheight = 19;
         //限制行最小高度
         //获取行内非纵向合并单元格的最高单元格高度
         for (let i = 0; i < rowRender.length; i++) {
-            const cellRender = rowRender.getChild(i);
+            const cellRender = rowRender.getChild(i) as TableCellRenderObject;
             const cellContentHeight = this.getTableCellRenderContentHeight(cellRender);
-            const { vMerge } = cellRender.element.props;
+            const { vMerge } = (<TableCellElement>cellRender.element).props;
             if (cellContentHeight > maxCellheight && vMerge !== 'restart') {
                 maxCellheight = cellContentHeight;
             }
         }
         return maxCellheight;
     }
+
     /**
      * 获取单元格内容高度
      * 单元格暂不处理上下margin、padding
      * @param cellRender
      * @returns
      */
-    static getTableCellRenderContentHeight(cellRender) {
+    static getTableCellRenderContentHeight(cellRender: TableCellRenderObject): number {
         let contentHeight = 0;
         for (let i = 0; i < cellRender.length; i++) {
             contentHeight += cellRender.getChild(i).rect.height;
         }
         return contentHeight;
     }
+
     /**
      * 处理单元格内容纵向对齐
      * @param render
      */
-    static measureCellVAlign(render) {
-        const tcElement = render.element;
+    private static measureCellVAlign(render: TableCellRenderObject): void {
+        const tcElement = render.element as TableCellElement;
         const { vAlign } = tcElement.props;
         if (!vAlign || vAlign === 'top') {
             return;
@@ -259,7 +299,7 @@ export class ElementUtil {
             sumHeight += render.getChild(i).rect.height;
         }
         let spaceHeight = 0;
-        spaceHeight = vAlign === 'middle' ? Math.floor((render.rect.height - sumHeight) / 2) : vAlign === 'bottom' ? render.rect.height - sumHeight : 0;
+        spaceHeight = vAlign === 'middle' ? Math.floor((render.rect.height - sumHeight) / 2) : vAlign === 'bottom' ? render.rect.height - sumHeight : 0
         if (spaceHeight <= 0) {
             return;
         }
@@ -269,19 +309,20 @@ export class ElementUtil {
             y += render.getChild(i).rect.height;
         }
     }
+
     /**
      * 重新测量合并单元格高度
      * @param tbRender
      * @returns
      */
-    static remeasureTableMerge(tbRender) {
+    static remeasureTableMerge(tbRender: TableRenderObject): void {
         //是否需要重新计算,主要解决：之前合并计算的列，可能会被后面合并计算的列所影响，需要再次重新计算测量
         let needReCalc = false;
         for (let i = 0; i < tbRender.length; i++) {
-            const row = tbRender.getChild(i);
+            const row = tbRender.getChild(i) as TableRowRenderObject;
             for (let j = 0; j < row.length; j++) {
-                const cellRender = row.getChild(j);
-                const ele = cellRender.element;
+                const cellRender = row.getChild(j) as TableCellRenderObject;
+                const ele = cellRender.element as TableCellElement;
                 const { vMerge } = ele.props;
                 if (vMerge === 'restart') {
                     const eleIndex = ele.getIndex();
@@ -294,7 +335,7 @@ export class ElementUtil {
                         }
                         continue;
                     }
-                    const continueCellHeight = continueRows.reduce((prev, curr) => prev + curr.rect.height, 0);
+                    const continueCellHeight = continueRows.reduce((prev, curr) => prev + curr.rect.height, 0)
                     const overflowHeight = cellRender.rect.height - row.rect.height - continueCellHeight;
                     //溢出的高度加到最后一个合并单元格中
                     if (overflowHeight > 0) {
@@ -302,8 +343,7 @@ export class ElementUtil {
                         lastRow.rect.height += overflowHeight;
                         this.resizeCellToFillRow(lastRow);
                         needReCalc = true;
-                    }
-                    else {
+                    } else {
                         cellRender.rect.height = row.rect.height + continueCellHeight;
                     }
                 }
@@ -314,6 +354,7 @@ export class ElementUtil {
             return;
         }
     }
+
     /**
      * 获取向下纵向合并的行
      * @param render
@@ -321,12 +362,12 @@ export class ElementUtil {
      * @param colIndex
      * @returns
      */
-    static getContinueVMergeRenderRows(render, rowIndex, colIndex) {
-        const rows = [];
+    private static getContinueVMergeRenderRows(render: TableRenderObject, rowIndex: number, colIndex: number): TableRowRenderObject[] {
+        const rows: Array<TableRowRenderObject> = [];
         for (let i = rowIndex + 1; i < render.length; i++) {
-            const rowRender = render.getChild(i);
-            const rowEle = rowRender.element;
-            const ele = rowEle.getChild(colIndex);
+            const rowRender = render.getChild(i) as TableRowRenderObject;
+            const rowEle = rowRender.element as TableRowElement;
+            const ele = rowEle.getChild(colIndex) as TableCellElement;
             const { vMerge } = ele.props;
             if (vMerge !== 'continue') {
                 break;
@@ -335,38 +376,41 @@ export class ElementUtil {
         }
         return rows;
     }
+
     /**
      * 根据横向当前被合并的单元格
      * @param tb
      * @param rowIndex
      * @param colIndex
      */
-    static getHorizontalRestartCellIndex(tb, rowIndex, colIndex) {
-        const row = tb.getChild(rowIndex);
+    static getHorizontalRestartCellIndex(tb: TableElement, rowIndex: number, colIndex: number): number {
+        const row = tb.getChild(rowIndex) as TableRowElement;
         for (let i = colIndex - 1; i >= 0; i--) {
-            const cell = row.getChild(i);
+            const cell = row.getChild(i) as TableCellElement;
             if (cell.props.hMerge === 'restart') {
                 return i;
             }
         }
         throw new Error('未找到主合并单元格');
     }
+
     /**
      * 根据横向当前被合并的单元格
      * @param tb
      * @param rowIndex
      * @param colIndex
      */
-    static getVerticalRestartCellIndex(tb, rowIndex, colIndex) {
+    static getVerticalRestartCellIndex(tb: TableElement, rowIndex: number, colIndex: number): number {
         for (let i = rowIndex - 1; i >= 0; i--) {
-            const row = tb.getChild(i);
-            const cell = row.getChild(colIndex);
+            const row = tb.getChild(i) as TableRowElement;
+            const cell = row.getChild(colIndex) as TableCellElement;
             if (cell.props.vMerge === 'restart') {
                 return i;
             }
         }
-        throw new Error('未找到横向当前被合并的单元格');
+        throw new Error('未找到横向当前被合并的单元格')
     }
+
     /**
      * 获取合并单元格主单元格
      * @param tb
@@ -374,9 +418,9 @@ export class ElementUtil {
      * @param colIndex
      * @returns
      */
-    static getRestartCellPosition(tb, rowIndex, colIndex) {
-        const row = tb.getChild(rowIndex);
-        const cell = row.getChild(colIndex);
+    static getRestartCellPosition(tb: TableElement, rowIndex: number, colIndex: number): { rowIndex: number, colIndex: number } {
+        const row = tb.getChild(rowIndex) as TableRowElement;
+        const cell = row.getChild(colIndex) as TableCellElement;
         if (cell.props.hMerge === 'continue') {
             const restartCellIndex = this.getHorizontalRestartCellIndex(tb, rowIndex, colIndex);
             return this.getRestartCellPosition(tb, rowIndex, restartCellIndex);
@@ -385,23 +429,26 @@ export class ElementUtil {
             const restartRowIndex = this.getVerticalRestartCellIndex(tb, rowIndex, colIndex);
             return this.getRestartCellPosition(tb, restartRowIndex, colIndex);
         }
-        return { rowIndex, colIndex };
+        return { rowIndex, colIndex }
     }
+
     /**
      * 调整单元格高度填满整个行的高度
      */
-    static resizeCellToFillRow(row) {
+    private static resizeCellToFillRow(row: TableRowRenderObject): void {
         for (let i = 0; i < row.length; i++) {
             const cell = row.getChild(i);
             cell.rect.height = row.rect.height;
         }
     }
+
+
     /**
      * 获取元素的全局索引位置
      * @param control
      * @returns
      */
-    static getControlIndex(control) {
+    static getControlIndex(control: Element): number {
         const parent = control.parent;
         if (parent) {
             const index = control.getIndex();
@@ -411,26 +458,25 @@ export class ElementUtil {
                 counter += child.getSelfLength();
             }
             return counter + this.getControlIndex(parent);
-        }
-        else {
+        } else {
             return 0;
         }
     }
+
     /**
      * 根据全局索引位置获取元素
      * @param control
      * @param counter
      * @returns
      */
-    static getControlByIndex(control, counter) {
+    static getControlByIndex(control: Element, counter: { currIndex: number, index: number }): Element | null {
         counter.currIndex++;
         if (counter.currIndex === counter.index) {
             return control;
         }
         if (control instanceof LeafElement) {
             return null;
-        }
-        else if (control instanceof BranchElement) {
+        } else if (control instanceof BranchElement) {
             for (let i = 0; i < control.length; i++) {
                 const res = this.getControlByIndex(control.getChild(i), counter);
                 if (res) {
@@ -440,12 +486,13 @@ export class ElementUtil {
         }
         return null;
     }
+
     /**
      * 获取同级紧挨前方的兄弟元素
      * @param element
      * @returns
      */
-    static getPrevSiblingElement(element) {
+    static getPrevSiblingElement(element: Element): Element | null {
         const parent = element.parent;
         if (!parent) {
             return null;
@@ -458,12 +505,13 @@ export class ElementUtil {
         }
         return null;
     }
+
     /**
      * 获取同级紧挨下方的元素
      * @param element
      * @returns
      */
-    static getNextSiblingElement(element) {
+    static getNextSiblingElement(element: Element): Element | null {
         const parent = element.parent;
         if (!parent) {
             return null;
@@ -471,12 +519,13 @@ export class ElementUtil {
         if (parent) {
             const index = parent.getChildIndex(element);
             if (index < parent.length - 1) {
-                return parent.getChild(index + 1);
+                return parent.getChild(index + 1)
             }
         }
         return null;
     }
-    static getNextSiblingTrackElement(element, type, userId) {
+
+    static getNextSiblingTrackElement(element: Element, type: TrackRunTypeEnum, userId: string): TrackRunElement | null {
         const nextSiblingEle = this.getNextSiblingElement(element);
         if (nextSiblingEle instanceof TrackRunElement) {
             if (nextSiblingEle.type === type && nextSiblingEle.props.userId === userId) {
@@ -485,7 +534,8 @@ export class ElementUtil {
         }
         return null;
     }
-    static getPrevSiblingTrackElement(element, type, userId) {
+
+    static getPrevSiblingTrackElement(element: Element, type: TrackRunTypeEnum, userId: string): TrackRunElement | null {
         const prevSiblingEle = this.getPrevSiblingElement(element);
         if (prevSiblingEle instanceof TrackRunElement) {
             if (prevSiblingEle.type === type && prevSiblingEle.props.userId === userId) {
@@ -494,33 +544,36 @@ export class ElementUtil {
         }
         return null;
     }
+
     /**
      * 根据默认配置创建长文本
      * @param viewOptions
      * @returns
      */
-    static getNewTextGroup(textProps) {
-        const text = new TextGroupElement();
+    static getNewTextGroup(textProps: TextProps): TextGroupElement {
+        const text = new TextGroupElement()
         textProps.clone(text.props);
         return text;
     }
-    static createTextProps(dest, viewOptions) {
+
+    static createTextProps(dest: TextProps | null, viewOptions: ViewOptions): TextProps {
         const textProps = dest ?? new TextProps();
         textProps.fontSize = viewOptions.defaultFontSize;
         textProps.fontName = viewOptions.defaultFontName;
         textProps.color = viewOptions.defaultColor;
         return textProps;
     }
+
     /**
      * 获取容器内的最小渲染元素集合
      * @param parPos
      * @param array
      */
-    static getAvailHitLeafRenderObjects(render, parPos) {
+    static getAvailHitLeafRenderObjects(render: RenderObject, parPos: Position): Array<{ render: LeafRenderObject, rect: Rect }> {
         if (!this.checkAvailHitRender(render)) {
             return [];
         }
-        const renderObjectRect = {
+        const renderObjectRect: Rect = {
             x: parPos.x + render.rect.x,
             y: parPos.y + render.rect.y,
             width: render.rect.width,
@@ -528,53 +581,52 @@ export class ElementUtil {
             maxWidth: 0,
             maxHeight: 0
         };
-        const array = [];
+        const array: Array<{ render: LeafRenderObject, rect: Rect }> = [];
         if (render instanceof BranchRenderObject) {
             for (let i = 0; i < render.length; i++) {
                 const child = render.getChild(i);
                 array.push(...this.getAvailHitLeafRenderObjects(child, { x: renderObjectRect.x, y: renderObjectRect.y }));
             }
-        }
-        else if (render instanceof LeafRenderObject) {
+        } else if (render instanceof LeafRenderObject) {
             array.push({ render: render, rect: renderObjectRect });
-        }
-        else {
+        } else {
             throw new Error('未实现');
         }
         return array;
     }
+
     /**
      * 获取容器内的最小渲染元素集合
      * @param parPos
      * @param array
      */
-    static getAvailHitRenderObjects(render, parPos) {
+    static getAvailHitRenderObjects(render: RenderObject, parPos: Position): Array<{ render: RenderObject, rect: Rect }> {
         if (!this.checkAvailHitRender(render)) {
             return [];
         }
-        const renderObjectRect = this.getRenderObjectAbsoluteRect(render, parPos);
-        const array = [];
+        const renderObjectRect: Rect = this.getRenderObjectAbsoluteRect(render, parPos);
+        const array: Array<{ render: RenderObject, rect: Rect }> = [];
         if (render instanceof BranchRenderObject) {
             for (let i = 0; i < render.length; i++) {
                 const child = render.getChild(i);
                 if (this.checkAvailHitRender(child)) {
-                    array.push({ render: child, rect: this.getRenderObjectAbsoluteRect(child, renderObjectRect) });
+                    array.push({ render: child, rect: this.getRenderObjectAbsoluteRect(child, renderObjectRect) })
+
                 }
             }
-        }
-        else if (render instanceof LeafRenderObject) {
+        } else if (render instanceof LeafRenderObject) {
             array.push({ render: render, rect: renderObjectRect });
-        }
-        else {
+        } else {
             throw new Error('未实现');
         }
         return array;
     }
+
     /**
      * 获取绘制元素的绝对位置框
      */
-    static getRenderObjectAbsoluteRect(render, parPos) {
-        const renderObjectRect = {
+    static getRenderObjectAbsoluteRect(render: RenderObject, parPos: Position): Rect {
+        const renderObjectRect: Rect = {
             x: parPos.x + render.rect.x,
             y: parPos.y + render.rect.y,
             width: render.rect.width,
@@ -584,26 +636,29 @@ export class ElementUtil {
         };
         return renderObjectRect;
     }
+
+
     /**
      * 检查当前绘制元素是否属于有效点击元素
      */
-    static checkAvailHitRender(render) {
+    static checkAvailHitRender(render: RenderObject): boolean {
         if (render.element && render.element.disableClick) {
             return false;
         }
         if (render instanceof TableRowRenderObject) {
-            const rowEle = render.element;
+            const rowEle = render.element as TableRowElement;
             if (rowEle.props.headerRow) {
                 return rowEle.paintRenders.indexOf(render) === 0;
             }
         }
         return !render.disableClick;
     }
+
     /**
      * 验证点击可操作性
      * 主要限制页眉页脚的编辑模式
      */
-    static verifyHitable(sourceElement) {
+    static verifyHitable(sourceElement: LeafElement | null | undefined): boolean {
         if (!sourceElement) {
             return false;
         }
@@ -616,14 +671,15 @@ export class ElementUtil {
         }
         return true;
     }
+
     /**
      * 获取一个点到一个矩形最短的距离
      * @param rect
      * @param p
      * @returns
      */
-    static getDistanceToRect(rect, p) {
-        const lines = [];
+    static getDistanceToRect(rect: Rect, p: Position) {
+        const lines: Array<{ f: PAIR, s: PAIR }> = [];
         lines.push({
             f: {
                 x: rect.x,
@@ -660,28 +716,33 @@ export class ElementUtil {
                 x: rect.x + rect.width,
                 y: rect.y + rect.height
             }
-        });
-        const distances = lines.map(item => this.minDistance(item.f, item.s, p));
+        })
+        const distances = lines.map(item => this.minDistance(item.f, item.s, p))
         return Math.min(...distances);
     }
-    static minDistance(A, B, E) {
-        const AB = { x: B.x - A.x, y: B.y - A.y };
-        const BE = { x: E.x - B.x, y: E.y - B.y };
-        const AE = { x: E.x - A.x, y: E.y - A.y };
+
+    static minDistance(A: PAIR, B: PAIR, E: PAIR) {
+
+        const AB: PAIR = { x: B.x - A.x, y: B.y - A.y }
+
+        const BE: PAIR = { x: E.x - B.x, y: E.y - B.y };
+
+        const AE: PAIR = { x: E.x - A.x, y: E.y - A.y }
+
         const AB_BE = (AB.x * BE.x + AB.y * BE.y);
         const AB_AE = (AB.x * AE.x + AB.y * AE.y);
+
         let reqAns = 0;
+
         if (AB_BE > 0) {
             const y = E.y - B.y;
             const x = E.x - B.x;
             reqAns = Math.sqrt(x * x + y * y);
-        }
-        else if (AB_AE < 0) {
+        } else if (AB_AE < 0) {
             const y = E.y - A.y;
             const x = E.x - A.x;
             reqAns = Math.sqrt(x * x + y * y);
-        }
-        else {
+        } else {
             const x1 = AB.x;
             const y1 = AB.y;
             const x2 = AE.x;
@@ -691,70 +752,71 @@ export class ElementUtil {
         }
         return reqAns;
     }
+
     /**
      * 获取父级层级渲染对象
      * @param render
      * @returns
      */
-    static getParentRenders(render) {
+    static getParentRenders(render: RenderObject): Array<RenderObject> {
         if (render) {
             return [render, ...this.getParentRenders(render.parent)];
-        }
-        else {
+        } else {
             return [];
         }
     }
-    static getRenderMapElements(render) {
+
+    static getRenderMapElements(render: RenderObject): Array<Element> {
         const renders = this.getParentRenders(render);
         return renders.map(render => render.element).filter(ele => ele);
     }
-    static getParentRender(child, parentType) {
+
+    static getParentRender<T extends BranchRenderObject>(child: RenderObject, parentType: { new(...args: any): T }): T | null {
         if (!child) {
             return null;
         }
         if (child instanceof parentType) {
             return child;
-        }
-        else {
+        } else {
             return this.getParentRender(child.parent, parentType);
         }
     }
-    static getParentRenderByPredicate(child, predicate) {
+
+    static getParentRenderByPredicate(child: RenderObject, predicate: (item: RenderObject) => boolean): RenderObject | null {
         if (!child) {
             return null;
         }
         if (predicate(child)) {
             return child;
-        }
-        else {
+        } else {
             return this.getParentRenderByPredicate(child.parent, predicate);
         }
     }
+
     /**
      * 获取父级层级元素对象
      * @param element
      * @returns
      */
-    static getParentElements(element) {
+    static getParentElements(element: Element | null | undefined): Array<Element> {
         if (element) {
             return [element, ...this.getParentElements(element.parent)];
-        }
-        else {
+        } else {
             return [];
         }
     }
+
     /**
      * 获取最后一个子元素
      * @param element
      * @returns
      */
-    static getLastLeafElement(element, predicate = null) {
+    static getLastLeafElement(element: Element, predicate: null | ((item: Element) => boolean) = null): LeafElement | null {
         if (element instanceof LeafElement && (!predicate || predicate(element))) {
             return element;
-        }
-        else if (element instanceof BranchElement) {
+        } else if (element instanceof BranchElement) {
             for (let i = element.length - 1; i >= 0; i--) {
-                const res = this.getLastLeafElement(element.getChild(i), predicate);
+                const res = this.getLastLeafElement(element.getChild(i), predicate)
                 if (res) {
                     return res;
                 }
@@ -763,16 +825,17 @@ export class ElementUtil {
         }
         return null;
     }
+
+
     /**
      * 获取第一个子元素
      * @param element
      * @returns
      */
-    static getFirstLeafElement(element) {
+    static getFirstLeafElement(element: Element): LeafElement | null {
         if (element instanceof LeafElement) {
             return element;
-        }
-        else if (element instanceof BranchElement) {
+        } else if (element instanceof BranchElement) {
             for (let i = 0; i < element.length; i++) {
                 const res = this.getFirstLeafElement(element.getChild(i));
                 if (res) {
@@ -783,17 +846,19 @@ export class ElementUtil {
         }
         return null;
     }
+
     /**
      * 校验两个元素是否在同一个段落中
      * @param element1
      * @param element2
      */
-    static isInSameParagraph(element1, element2) {
+    static isInSameParagraph(element1: Element, element2: Element): boolean {
         const par1 = this.getParentByType(element1, ParagraphElement);
         const par2 = this.getParentByType(element2, ParagraphElement);
         return par1 === par2;
     }
-    static getBorderCursor(borderType) {
+
+    static getBorderCursor(borderType: BorderType): CursorType {
         switch (borderType) {
             case 'none':
                 return 'text';
@@ -804,7 +869,7 @@ export class ElementUtil {
             case 'right':
                 return 'col-resize';
             case 'bottom':
-                return 'row-resize';
+                return 'row-resize'
             case 'left-middle':
             case 'right-middle':
                 return 'w-resize';
@@ -821,38 +886,40 @@ export class ElementUtil {
                 return 'text';
         }
     }
-    static getParentByType(child, parentType) {
+
+    static getParentByType<P extends Element, T>(child: P | null, parentType: { new(...args: any): T }): T | null {
         if (!child) {
             return null;
         }
         if (child instanceof parentType) {
             return child;
-        }
-        else {
+        } else {
             return this.getParentByType(child.parent, parentType);
         }
     }
-    static getParent(child, predicate) {
+
+    static getParent(child: Element | null, predicate: (item: Element) => boolean): Element | null {
         if (!child) {
             return null;
         }
         if (predicate(child)) {
             return child;
-        }
-        else {
+        } else {
             return this.getParent(child.parent, predicate);
         }
     }
+
+
     /**
      * 修正段落内容
      * @returns
      */
-    static fixParagraphContent(control) {
+    static fixParagraphContent(control: ParagraphElement): void {
         //如果最后一个元素不是段落符号，则补足
         if (!(control.getChild(control.length - 1) instanceof PSymbolElement)) {
             control.addChild(new PSymbolElement());
         }
-        const items = [];
+        const items: Array<PSymbolElement> = [];
         for (let i = 0; i < control.length - 1; i++) {
             const child = control.getChild(i);
             if (child instanceof PSymbolElement) {
@@ -860,14 +927,15 @@ export class ElementUtil {
             }
         }
         items.forEach(item => {
-            control.removeChild(item);
+            control.removeChild(item)
         });
     }
+
     /**
      * 修正块级容器内容
      * @param control
      */
-    static fixBlockContainer(control) {
+    static fixBlockContainer(control: BlockContainerElement): void {
         if (control.length === 0) {
             if (control instanceof TableCellElement && (control.props.vMerge === 'continue' || control.props.hMerge === 'continue')) {
                 return;
@@ -878,6 +946,8 @@ export class ElementUtil {
             control.addChild(new ParagraphElement());
         }
     }
+
+
     /**
      * 获取绘制元素相对于整个画布的绝对位置
      * 整个画布绘制的时候不一定从x=0,y=0时绘制的，下拉滚动时，上面从负y坐标开始绘制
@@ -886,51 +956,58 @@ export class ElementUtil {
      * @param refPos 参照位置
      * @returns
      */
-    static getRenderAbsolutePaintPos(render, refPos = null) {
+    static getRenderAbsolutePaintPos(render: RenderObject, refPos: Position | null = null): Position {
         refPos = refPos ?? { x: 0, y: 0 };
-        const currPos = { x: render.rect.x + refPos.x, y: render.rect.y + refPos.y };
+        const currPos: Position = { x: render.rect.x + refPos.x, y: render.rect.y + refPos.y };
         if (!render.parent) {
             return currPos;
         }
         return this.getRenderAbsolutePaintPos(render.parent, currPos);
     }
-    static getRenderAbsolutePaintRect(render, childPos = null) {
+
+    static getRenderAbsolutePaintRect(render: RenderObject, childPos: Position | null = null): Rect {
         const pos = this.getRenderAbsolutePaintPos(render, childPos);
         return { ...pos, width: render.rect.width, height: render.rect.height, maxWidth: 0, maxHeight: 0 };
     }
+
+
+
+
+
     /**
      * 获取选中区域的开始区域
      * @param range
      * @returns
      */
-    static getFirstSelectedRange(range) {
+    static getFirstSelectedRange(range: SelectionContentRange): SelectionContentRange {
         if (range.selectedChildren.length === 0 || range.target instanceof TextGroupElement) {
             return range;
-        }
-        else {
+        } else {
             return this.getFirstSelectedRange(range.selectedChildren[0]);
         }
     }
+
     /**
      * 获取选中区域的开始区域
      * @param range \
      * @returns
      */
-    static getLastSelectedRange(range) {
+    static getLastSelectedRange(range: SelectionContentRange): SelectionContentRange {
         if (range.selectedChildren.length === 0 || range.target instanceof TextGroupElement) {
             return range;
-        }
-        else {
+        } else {
             return this.getLastSelectedRange(range.selectedChildren[range.selectedChildren.length - 1]);
         }
     }
+
+
     /**
      * 克隆选区内容
      * @param range
      * @param isDelete
      * @returns
      */
-    static cloneRange(range, isDelete, cloneMode = 'clone') {
+    static cloneRange(range: SelectionContentRange, isDelete: boolean, cloneMode: 'clone' | 'source' | 'copy' = 'clone'): Element | null {
         const { target, isFullSelected, startOffset, endOffset, selectedChildren } = range;
         if (isFullSelected) {
             //修饰元素不能复制 审阅标记、数据元NullText
@@ -942,8 +1019,7 @@ export class ElementUtil {
                 target.remove();
             }
             return clone;
-        }
-        else {
+        } else {
             if (target instanceof LeafElement) {
                 if (target instanceof TextGroupElement && startOffset !== endOffset) {
                     if (isDelete) {
@@ -952,16 +1028,14 @@ export class ElementUtil {
                             target.remove();
                         }
                         return copyTarget;
-                    }
-                    else {
+                    } else {
                         const copyTarget = target.spliceText(startOffset, endOffset, false);
                         return copyTarget;
                     }
                 }
                 return null;
-            }
-            else if (target instanceof BranchElement) {
-                const array = [];
+            } else if (target instanceof BranchElement) {
+                const array: Array<Element> = [];
                 for (let i = 0; i < selectedChildren.length; i++) {
                     const copyChild = this.cloneRange(selectedChildren[i], isDelete, cloneMode);
                     if (copyChild) {
@@ -970,11 +1044,10 @@ export class ElementUtil {
                 }
                 if (!array.length) {
                     return null;
-                }
-                else {
-                    const copyTarget = target.clone(false);
+                } else {
+                    const copyTarget = target.clone(false) as BranchElement;
                     array.forEach(item => {
-                        copyTarget.addChild(item);
+                        copyTarget.addChild(item)
                     });
                     return copyTarget;
                 }
@@ -982,18 +1055,20 @@ export class ElementUtil {
         }
         return null;
     }
+
     /**
      * 获取所有的子级元素
      * @param branchEle
      * @returns
      */
-    static getChildrenElements(branchEle) {
+    static getChildrenElements(branchEle: BranchElement): Array<Element> {
         const array = [];
         for (let i = 0; i < branchEle.length; i++) {
             array.push(branchEle.getChild(i));
         }
         return array;
     }
+
     /**
      * 递归向前寻找最近的元素
      * @param currElement
@@ -1001,7 +1076,7 @@ export class ElementUtil {
      * @param forCursor 查找结果是否用于光标定位
      * @returns
      */
-    static getRecursionPrevSiblingElement(currElement, inPara = false, forCursor = false) {
+    static getRecursionPrevSiblingElement(currElement: Element | null, inPara: boolean = false, forCursor: boolean = false): LeafElement | null {
         const parent = currElement?.parent;
         //删除留痕块的measureRender在不显示留痕模式下，不生成render
         if (!currElement || !parent || (!currElement.measureRender && !(currElement instanceof TrackRunElement))) {
@@ -1020,9 +1095,8 @@ export class ElementUtil {
                 return null;
             }
             return this.getRecursionPrevSiblingElement(parent, inPara, forCursor);
-        }
-        else {
-            let prevElement = null;
+        } else {
+            let prevElement: Element | null = null;
             for (let i = index - 1; i >= 0; i--) {
                 prevElement = parent.getChild(i);
                 if (prevElement && !prevElement.disableClick) {
@@ -1039,18 +1113,19 @@ export class ElementUtil {
             }
             if (lastLeafElement) {
                 return lastLeafElement;
-            }
-            else {
+            } else {
                 return this.getRecursionPrevSiblingElement(prevElement.parent, inPara, forCursor);
             }
         }
     }
+
+
     /**
      * 循环向前寻找可定位的数据元
-     * @param currElement
+     * @param currElement 
      */
-    static getPrevDataElement(ctx, currElement) {
-        const dataEle = ctx.getCurrentCtx(currElement).getControlInstanceList().filter(item => item instanceof DataElementInlineGroup);
+    static getPrevDataElement(ctx: EditorContext, currElement: DataElementInlineGroup): DataElementInlineGroup | null {
+        const dataEle = ctx.getCurrentCtx(currElement).getControlInstanceList().filter(item => item instanceof DataElementInlineGroup) as Array<DataElementInlineGroup>;
         const index = dataEle.indexOf(currElement);
         if (index > 0) {
             for (let i = index - 1; i >= 0; i--) {
@@ -1061,6 +1136,7 @@ export class ElementUtil {
         }
         return null;
     }
+
     // /**
     // * 递归向前寻找最近的可点击元素
     // */
@@ -1071,6 +1147,7 @@ export class ElementUtil {
     //     } while (ele && ele.disableClick)
     //     return ele;
     // }
+
     // /**
     // * 在同一段落中，递归向前寻找最近的元素
     // */
@@ -1095,6 +1172,7 @@ export class ElementUtil {
     //         }
     //     }
     // }
+
     // /**
     // * 在同一段落中，递归向前寻找最近的可点击元素
     // */
@@ -1105,10 +1183,12 @@ export class ElementUtil {
     //     } while (ele && ele.disableClick)
     //     return ele;
     // }
+
+
     /**
      * 递归向后寻找最近的元素
      */
-    static getRecursionNextSiblingElement(currElement, inPara = false, forCursor = false) {
+    static getRecursionNextSiblingElement(currElement: Element | null, inPara: boolean = false, forCursor: boolean = false): LeafElement | null {
         const parent = currElement?.parent;
         if (!currElement || !parent || !currElement.measureRender) {
             return null;
@@ -1126,9 +1206,8 @@ export class ElementUtil {
                 return null;
             }
             return this.getRecursionNextSiblingElement(parent, inPara, forCursor);
-        }
-        else {
-            let nextElement = null;
+        } else {
+            let nextElement: Element | null = null;
             for (let i = index + 1; i < parent.length; i++) {
                 nextElement = parent.getChild(i);
                 if (nextElement && !nextElement.disableClick) {
@@ -1145,12 +1224,13 @@ export class ElementUtil {
             }
             if (lastLeafElement) {
                 return lastLeafElement;
-            }
-            else {
+            } else {
                 return this.getRecursionNextSiblingElement(nextElement.parent, inPara, forCursor);
             }
         }
     }
+
+
     // /**
     // * 在同一段落中，递归向后寻找最近的元素
     // */
@@ -1175,6 +1255,7 @@ export class ElementUtil {
     //         }
     //     }
     // }
+
     // /**
     // * 在同一段落中，递归向后寻找最近的可点击元素
     // */
@@ -1185,6 +1266,7 @@ export class ElementUtil {
     //     } while (ele && ele.disableClick)
     //     return ele;
     // }
+
     // /**
     // * 在同一段落中，递归向后寻找最近的可点击元素
     // */
@@ -1195,12 +1277,13 @@ export class ElementUtil {
     //     } while (ele && ele.disableClick)
     //     return ele;
     // }
+
     /**
      * 获取行内最大渲染单元格高度，主要处理纵向合并单元格问题
      * @param row
      * @returns
      */
-    static getRowMaxCellHeight(row) {
+    static getRowMaxCellHeight(row: TableRowRenderObject): number {
         let maxHeight = 0;
         for (let i = 0; i < row.length; i++) {
             if (row.getChild(i).rect.height > maxHeight) {
@@ -1209,26 +1292,29 @@ export class ElementUtil {
         }
         return maxHeight;
     }
+
+
     /**
      * 校验是否为空内容
      * @param ele
      */
-    static checkEmptyContent(ele) {
+    static checkEmptyContent(ele: BranchRenderObject): boolean {
         if (ele.length === 1) {
             const firstRender = ele.getChild(0);
             if (firstRender instanceof ParagraphRenderObject) {
-                if ((firstRender.element).length === 1) {
+                if ((<ParagraphElement>(firstRender.element)).length === 1) {
                     return true;
                 }
             }
         }
         return false;
     }
+
     /**
      * 测量行内编组元素
      * @param render
      */
-    static remeasureInlineGroupRender(render) {
+    static remeasureInlineGroupRender(render: InlineGroupRenderObject): void {
         let x = 0;
         let maxHeight = 0;
         for (let i = 0; i < render.length; i++) {
@@ -1246,34 +1332,37 @@ export class ElementUtil {
         render.rect.width = x;
         render.rect.height = maxHeight;
     }
-    static getParaLinePos(childRender, childRenderPos) {
+
+    static getParaLinePos(childRender: RenderObject, childRenderPos: Position): Rect {
         const parent = childRender.parent;
         const rect = ElementUtil.cloneRect(parent.rect);
         rect.x = childRenderPos.x - childRender.rect.x;
         rect.y = childRenderPos.y - childRender.rect.y;
         if (parent instanceof ParagraphLineRectRenderObject) {
             return rect;
-        }
-        else {
+        } else {
             return this.getParaLinePos(parent, rect);
         }
     }
-    static getParentRenderPos(parentRender, childRender, childRenderPos) {
+
+
+    static getParentRenderPos(parentRender: RenderObject, childRender: RenderObject, childRenderPos: Position): Rect {
         const parent = childRender.parent;
         const rect = ElementUtil.cloneRect(parent.rect);
         rect.x = childRenderPos.x - childRender.rect.x;
         rect.y = childRenderPos.y - childRender.rect.y;
         if (parent === parentRender) {
             return rect;
-        }
-        else {
+        } else {
             return this.getParentRenderPos(parentRender, parent, rect);
         }
     }
+
+
     /**
      * 获取绘制元素所在的区域
      */
-    static getRenderObjectRegion(render) {
+    static getRenderObjectRegion(render: RenderObject): HitRegion | undefined {
         if (!render) {
             return undefined;
         }
@@ -1282,16 +1371,18 @@ export class ElementUtil {
         }
         return this.getRenderObjectRegion(render.parent);
     }
+
     /**
      * 获取文档元素所在的区域
      * @param element
      * @returns
      */
-    static getElementRegion(element) {
+    static getElementRegion(element: Element): HitRegion | undefined {
         const regionTarget = this.getElementRegionTarget(element);
         return regionTarget?.type;
     }
-    static getElementRegionTarget(element) {
+
+    static getElementRegionTarget(element: Element | null): { type: HitRegion, target: BranchElement } | null {
         if (!element) {
             return null;
         }
@@ -1305,30 +1396,30 @@ export class ElementUtil {
             return { type: 'header', target: element };
         }
         if (element instanceof CommsContainerElement) {
-            return { type: 'review', target: element };
+            return { type: 'review', target: element }
         }
         return this.getElementRegionTarget(element.parent);
     }
+
     /**
      * 根据坐标系统偏移位获取所在的文本偏移位置
      * @param textRender
      * @param x
      * @returns
      */
-    static getTextRenderOffset(textRender, x) {
-        const ele = textRender.element;
+    static getTextRenderOffset(textRender: TextGroupRenderObject, x: number): number {
+        const ele = textRender.element as TextGroupElement;
         const docRender = ElementUtil.getParentRender(textRender, DocumentRenderObject);
         if (!docRender) {
-            throw new Error('docRender is null');
+            throw new Error('docRender is null')
         }
         const elePaintRenders = ele.paintRenders.filter(item => ElementUtil.getParentRender(item, DocumentRenderObject) === docRender);
         let count = 0;
         for (let i = 0; i < elePaintRenders.length; i++) {
-            const render = elePaintRenders[i];
+            const render = elePaintRenders[i] as TextGroupRenderObject;
             if (render !== textRender) {
                 count += render.textMeasures.length;
-            }
-            else {
+            } else {
                 let horX = 0;
                 for (let j = 0; j < render.textMeasures.length; j++) {
                     if (horX + render.textMeasures[j].actualSize >= x) {
@@ -1336,8 +1427,7 @@ export class ElementUtil {
                             if (j === 0 && i > 0) {
                                 j += 0.5;
                             }
-                        }
-                        else {
+                        } else {
                             j += 1;
                         }
                         return j + count;
@@ -1349,28 +1439,28 @@ export class ElementUtil {
         }
         throw new Error('未找到当前文本元素的光标偏移量');
     }
-    static getHitRenderOffset(render, x) {
+
+    static getHitRenderOffset(render: LeafRenderObject, x: number): number {
         if (render instanceof TextGroupRenderObject) {
             return this.getTextRenderOffset(render, x);
-        }
-        else {
+        } else {
             if (render.element && render.element.type === 'psym') {
                 return 0;
             }
             return (render.rect.width / 2) >= x ? 0 : 1;
         }
     }
-    static getTextRenderHorX(currRender, startOffset, endOffset) {
-        const textEle = currRender.element;
+
+    static getTextRenderHorX(currRender: TextGroupRenderObject, startOffset: number, endOffset: number): { startX: number, endX: number } {
+        const textEle = currRender.element as TextGroupElement;
         let endX = 0;
         let startX = 0;
         let count = 0;
         for (let i = 0; i < textEle.paintRenders.length; i++) {
-            const paintRender = textEle.paintRenders[i];
+            const paintRender = textEle.paintRenders[i] as TextGroupRenderObject;
             if (paintRender !== currRender) {
                 count += paintRender.textMeasures.length;
-            }
-            else {
+            } else {
                 if (count + paintRender.textMeasures.length < startOffset) {
                     continue;
                 }
@@ -1390,54 +1480,59 @@ export class ElementUtil {
         }
         return { startX, endX };
     }
+
     /**
      * 获取一个元素结尾偏移量
      * 文本以字符长度进行确定
      * @param ele
      * @returns
      */
-    static getElementEndOffset(ele) {
+    static getElementEndOffset(ele: LeafElement): number {
         if (ele instanceof TextGroupElement) {
             return ele.textMeasures.length;
         }
         return 1;
     }
+
     /**
      * 判断当前偏移量是否是最终偏移量
      * @param ele
      * @param offset
      */
-    static isElementEndOffset(ele, offset) {
+    static isElementEndOffset(ele: LeafElement, offset: number): boolean {
         return this.getElementEndOffset(ele) === offset;
     }
+
     /**
      * 获取直接子节点的所有渲染元素
      * @param ele
      * @returns
      */
-    static getChildRenders(ele) {
-        const items = [];
+    static getChildRenders<T extends RenderObject>(ele: BranchRenderObject): Array<T> {
+        const items: Array<T> = [];
         for (let i = 0; i < ele.length; i++) {
-            items.push(ele.getChild(i));
+            items.push(ele.getChild(i) as T);
         }
         return items;
     }
+
     /**
      * 获取当前单元格内所有的段落行
      * @param cell
      * @returns
      */
-    static getCellParaLines(cell) {
-        const items = [];
+    static getCellParaLines(cell: TableCellRenderObject): Array<ParagraphLineRectRenderObject> {
+        const items: Array<ParagraphLineRectRenderObject> = [];
         for (let i = 0; i < cell.length; i++) {
-            const para = cell.getChild(i);
+            const para = cell.getChild(i) as ParagraphRenderObject;
             for (let j = 0; j < para.length; j++) {
-                items.push(para.getChild(j));
+                items.push(para.getChild(j) as ParagraphLineRectRenderObject)
             }
         }
         return items;
     }
-    static getRandomColor(seed) {
+
+    static getRandomColor(seed: number) {
         let letters = '0123456789ABCDEF';
         let color = '#';
         for (let i = 0; i < 6; i++) {
@@ -1445,10 +1540,14 @@ export class ElementUtil {
         }
         return color;
     }
-    static getSeedRandom(seed) {
+
+
+    static getSeedRandom(seed: number): number {
         return Number("0." + Math.sin(seed * Math.random()).toString().substr(6));
     }
-    static findChildRender(render, predicate) {
+
+
+    static findChildRender(render: BranchRenderObject, predicate: (child: RenderObject) => boolean): RenderObject | null {
         for (let i = 0; i < render.length; i++) {
             if (predicate(render.getChild(i))) {
                 return render.getChild(i);
@@ -1456,8 +1555,10 @@ export class ElementUtil {
         }
         return null;
     }
-    static getDataElement(ele) {
-        return this.getParent(ele, item => item instanceof DataElementInlineGroup);
+
+
+    static getDataElement(ele: Element): DataElementInlineGroup {
+        return this.getParent(ele, item => item instanceof DataElementInlineGroup) as DataElementInlineGroup;
     }
 }
-//# sourceMappingURL=element-util.js.map
+