@hailin-zheng/editor-core 1.0.9 → 1.0.13

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

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