vue-editify 0.2.16 → 0.2.18

package/src/core/function.ts

@@ -3,8 +3,8 @@
  */
 import { common as DapCommon } from 'dap-util'
 import { AlexEditor, AlexElement, AlexElementsRangeType, AlexElementCreateConfigType } from 'alex-editor'
-import { ButtonOptionsItemType } from '@/components/button'
-import { cloneData, queryHasValue, getButtonOptionsConfig, ObjectType } from './tool'
+import KaTex from 'katex'
+import { queryHasValue, ObjectType } from './tool'
 
 export type ElementMatchConfigType = {
 	parsedom?: string
@@ -12,6 +12,257 @@ export type ElementMatchConfigType = {
 	styles?: ObjectType
 }
 
+/** --------------------------------代码块操作相关函数------------------------------------------------ */
+
+/**
+ * 更新代码块内的光标位置
+ * @param editor
+ * @param element
+ * @param originalTextElements
+ * @param newElements
+ * @returns
+ */
+export const updateRangeInPre = (editor: AlexEditor, element: AlexElement, originalTextElements: AlexElement[], newElements: AlexElement[]) => {
+	if (!editor.range) {
+		return
+	}
+	//如果虚拟光标的起点在代码块内对虚拟光标的起点进行重新定位
+	if (editor.range.anchor.element.getBlock().isEqual(element)) {
+		//获取起点所在文本元素的在所有文本元素中的序列
+		const elIndex = originalTextElements.findIndex(el => editor.range!.anchor.element.isEqual(el))
+		//起点在整个代码内容中的位置
+		const offset = originalTextElements.filter((_el, i) => i < elIndex).reduce((total, item) => total + item.textContent!.length, 0) + editor.range.anchor.offset
+		//获取pre下新的子孙元素中全部的文本元素
+		const newTextElements = AlexElement.flatElements(newElements).filter(el => el.isText() && !el.isEmpty())
+		let i = 0
+		let index = 0
+		//遍历
+		while (i < newTextElements.length) {
+			let newIndex = index + newTextElements[i].textContent!.length
+			if (offset >= index && offset <= newIndex) {
+				editor.range.anchor.element = newTextElements[i]
+				editor.range.anchor.offset = offset - index
+				break
+			}
+			i++
+			index = newIndex
+		}
+	}
+	//如果虚拟光标的终点在代码块内需要对虚拟光标的终点进行重新定位
+	if (editor.range.focus.element.getBlock().isEqual(element)) {
+		//获取终点所在文本元素的在所有文本元素中的序列
+		const elIndex = originalTextElements.findIndex(el => editor.range!.focus.element.isEqual(el))
+		//终点在整个代码内容中的位置
+		const offset = originalTextElements.filter((_el, i) => i < elIndex).reduce((total, item) => total + item.textContent!.length, 0) + editor.range.focus.offset
+		//获取全部的新文本元素
+		const newTextElements = AlexElement.flatElements(newElements).filter(el => el.isText() && !el.isEmpty())
+		let i = 0
+		let index = 0
+		//遍历
+		while (i < newTextElements.length) {
+			let newIndex = index + newTextElements[i].textContent!.length
+			if (offset >= index && offset <= newIndex) {
+				editor.range.focus.element = newTextElements[i]
+				editor.range.focus.offset = offset - index
+				break
+			}
+			i++
+			index = newIndex
+		}
+	}
+}
+
+/** --------------------------------表格操作相关函数--------------------------------------------- */
+
+/**
+ * 自动隐藏被合并的单元格
+ * @param editor
+ * @param rowElements
+ */
+export const autoHideMergedTableCells = (editor: AlexEditor, rowElements: AlexElement[]) => {
+	const cells = AlexElement.flatElements(rowElements).filter(item => item.parsedom == 'td')
+	cells.forEach(cell => {
+		if (cell.hasMarks() && !cell.marks!['data-editify-merged']) {
+			//获取colspan
+			const colspan = isNaN(Number(cell.marks!['colspan'])) ? 1 : Number(cell.marks!['colspan'])
+			//获取rowspan
+			const rowspan = isNaN(Number(cell.marks!['rowspan'])) ? 1 : Number(cell.marks!['rowspan'])
+			//如果是跨列单元格，隐藏该单元格同行后的colspan-1个单元格
+			if (colspan > 1) {
+				let el = cell
+				let i = 1
+				while (i < colspan) {
+					const nextCell = editor.getNextElement(el)!
+					if (nextCell) {
+						if (nextCell.hasMarks()) {
+							nextCell.marks!['data-editify-merged'] = 'true'
+						} else {
+							nextCell.marks = {
+								'data-editify-merged': 'true'
+							}
+						}
+						el = nextCell
+						i++
+					} else {
+						break
+					}
+				}
+			}
+			//如果是跨行单元格，隐藏该单元格同列后的rowspan-1行单元格
+			if (rowspan > 1) {
+				const index = cell.parent!.children!.findIndex(item => item.isEqual(cell))
+				let el = cell
+				let i = 1
+				while (i < rowspan && el && editor.getNextElement(el.parent!)) {
+					const nextRow = editor.getNextElement(el.parent!)!
+					//根据跨行单元格占据的列数，在后的rowspan-1行中隐藏colspan个单元格
+					for (let j = index; j < index + colspan; j++) {
+						const current = nextRow.children![j]
+						if (current) {
+							if (current.hasMarks()) {
+								current.marks!['data-editify-merged'] = 'true'
+							} else {
+								current.marks = {
+									'data-editify-merged': 'true'
+								}
+							}
+						}
+					}
+					el = nextRow.children![index]
+					i++
+				}
+			}
+		}
+	})
+}
+
+/**
+ * 自动补全表格行和列
+ * @param editor
+ * @param rowElements
+ * @param rowNumber
+ * @param columnNumber
+ */
+export const autocompleteTableCells = (editor: AlexEditor, rowElements: AlexElement[], rowNumber: number, columnNumber: number) => {
+	//遍历所有的单元格
+	AlexElement.flatElements(rowElements).forEach(item => {
+		if (item.parsedom == 'td' && item.hasMarks()) {
+			//删除被合并的标识
+			if (item.marks!['data-editify-merged']) {
+				delete item.marks!['data-editify-merged']
+			}
+			//获取colspan
+			const colspan = isNaN(Number(item.marks!['colspan'])) ? 1 : Number(item.marks!['colspan'])
+			//获取rowspan
+			const rowspan = isNaN(Number(item.marks!['rowspan'])) ? 1 : Number(item.marks!['rowspan'])
+			//针对colspan>1的单元格在后面补全隐藏的单元格
+			if (colspan > 1) {
+				let i = 1
+				//补全的数量小于需要补全的数量并且列总数量小于理论数量
+				while (i < colspan && item.parent!.children!.length < columnNumber) {
+					const column = AlexElement.create({
+						type: 'inblock',
+						parsedom: 'td',
+						marks: {
+							'data-editify-merged': 'true'
+						},
+						children: [
+							{
+								type: 'closed',
+								parsedom: 'br'
+							}
+						]
+					})
+					editor.addElementAfter(column, item)
+					i++
+				}
+			}
+			//针对rowspan>1的单元格在后面的行中对应位置补全隐藏的单元格
+			if (rowspan > 1) {
+				let el = item
+				let i = 1
+				while (i < rowspan && editor.getNextElement(el.parent!) && editor.getNextElement(el.parent!)!.children!.length < columnNumber) {
+					//下一行
+					const nextRow = editor.getNextElement(el.parent!)!
+					//单元格在行中的序列
+					const index = el.parent!.children!.findIndex(item => item.isEqual(el))
+					//下一行对应的单元格
+					const nextCell = nextRow.children![index]
+					//根据当前单元格的跨列数补充符合跨列数的隐藏单元格
+					for (let j = 0; j < colspan; j++) {
+						const column = AlexElement.create({
+							type: 'inblock',
+							parsedom: 'td',
+							marks: {
+								'data-editify-merged': 'true'
+							},
+							children: [
+								{
+									type: 'closed',
+									parsedom: 'br'
+								}
+							]
+						})
+						if (nextCell) {
+							editor.addElementBefore(column, nextCell)
+						} else {
+							editor.addElementTo(column, nextRow, nextRow.children!.length)
+						}
+					}
+					el = nextRow.children![index]
+					i++
+				}
+			}
+		}
+	})
+	//遍历每一行，如果还缺少列则在后面补全列
+	rowElements.forEach(rowElement => {
+		//遍历该行的单元格获取总列数
+		const number = rowElement.children!.length
+		if (number < columnNumber) {
+			for (let i = 0; i < columnNumber - number; i++) {
+				const column = AlexElement.create({
+					type: 'inblock',
+					parsedom: 'td',
+					children: [
+						{
+							type: 'closed',
+							parsedom: 'br'
+						}
+					]
+				})
+				editor.addElementTo(column, rowElement, rowElement.children!.length)
+			}
+		}
+	})
+	//获取总行数
+	const length = rowElements.length
+	//判断总行数是否小于实际行数则补全行
+	if (length < rowNumber) {
+		for (let i = 0; i < rowNumber - length; i++) {
+			const children: AlexElementCreateConfigType[] = []
+			for (let j = 0; j < columnNumber; j++) {
+				children.push({
+					type: 'inblock',
+					parsedom: 'td',
+					children: [
+						{
+							type: 'closed',
+							parsedom: 'br'
+						}
+					]
+				})
+			}
+			const row = AlexElement.create({
+				type: 'inblock',
+				parsedom: 'tr',
+				children
+			})
+			rowElements.push(row)
+		}
+	}
+}
+
 /**
  * 清空单元格的内容并隐藏
  * @param editor
@@ -184,6 +435,8 @@ export const getTableSize = (rowElements: AlexElement[]) => {
 	}
 }
 
+/** --------------------------------通用的元素判断函数----------------------------------------------- */
+
 /**
  * Open API：判断元素是否符合指定的条件
  * @param element
@@ -292,6 +545,8 @@ export const getMatchElementByRange = (editor: AlexEditor, dataRangeCaches: Alex
 	return null
 }
 
+/** --------------------------------列表判断函数---------------------------------------------------------- */
+
 /**
  * Open API：判断元素是否有序或者无序列表，不做空元素判断
  * @param element
@@ -360,6 +615,8 @@ export const rangeIsInList = (editor: AlexEditor, dataRangeCaches: AlexElementsR
 	})
 }
 
+/** --------------------------------任务列表判断函数----------------------------------------------- */
+
 /**
  * Open API：判断元素是否任务列表，不做空元素判断
  * @param element
@@ -424,6 +681,8 @@ export const rangeIsInTask = (editor: AlexEditor, dataRangeCaches: AlexElementsR
 	})
 }
 
+/** --------------------------------附件判断函数------------------------------------------------- */
+
 /**
  * Open API：判断元素是否附件，不做空元素判断
  * @param element
@@ -456,6 +715,8 @@ export const hasAttachmentInRange = (editor: AlexEditor, dataRangeCaches: AlexEl
 	})
 }
 
+/** --------------------------------数学公式判断函数--------------------------------------------- */
+
 /**
  * Open API：判断元素是否数学公式，不做空元素判断
  * @param element
@@ -502,6 +763,8 @@ export const hasMathformulaInRange = (editor: AlexEditor, dataRangeCaches: AlexE
 	})
 }
 
+/** --------------------------------面板判断函数--------------------------------------------------- */
+
 /**
  * Open API：判断元素是否面板，不做空元素判断
  * @param el
@@ -548,6 +811,8 @@ export const hasPanelInRange = (editor: AlexEditor, dataRangeCaches: AlexElement
 	})
 }
 
+/** --------------------------------信息块判断函数---------------------------------------------- */
+
 /**
  * Open API：判断元素是否信息块，不做空元素判断
  * @param el
@@ -612,6 +877,8 @@ export const rangeIsInInfoBlock = (editor: AlexEditor, dataRangeCaches: AlexElem
 	})
 }
 
+/** --------------------------------代码块判断函数------------------------------------------------ */
+
 /**
  * Open API：选区是否含有代码块，不一定是同一个代码块，只要含有代码块即返回true
  * @param editor
@@ -630,41 +897,7 @@ export const hasPreInRange = (editor: AlexEditor, dataRangeCaches: AlexElementsR
 	})
 }
 
-/**
- * Open API：选区是否含有引用，不一定是同一个引用，只要含有引用即返回true
- * @param editor
- * @param dataRangeCaches
- * @returns
- */
-export const hasQuoteInRange = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => {
-	if (!editor.range) {
-		return false
-	}
-	if (editor.range.anchor.isEqual(editor.range.focus)) {
-		return !!getMatchElementByElement(editor.range.anchor.element, { parsedom: 'blockquote' })
-	}
-	return dataRangeCaches.flatList.some(item => {
-		return !!getMatchElementByElement(item.element, { parsedom: 'blockquote' })
-	})
-}
-
-/**
- * Open API：选区是否含有链接，不一定是同一个链接，只要含有链接即返回true
- * @param editor
- * @param dataRangeCaches
- * @returns
- */
-export const hasLinkInRange = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => {
-	if (!editor.range) {
-		return false
-	}
-	if (editor.range.anchor.isEqual(editor.range.focus)) {
-		return !!getMatchElementByElement(editor.range.anchor.element, { parsedom: 'a' })
-	}
-	return dataRangeCaches.flatList.some(item => {
-		return !!getMatchElementByElement(item.element, { parsedom: 'a' })
-	})
-}
+/** --------------------------------表格判断函数------------------------------------------------- */
 
 /**
  * Open API：选区是否含有表格，不一定是同一个表格，只要含有表格即返回true
@@ -684,161 +917,103 @@ export const hasTableInRange = (editor: AlexEditor, dataRangeCaches: AlexElement
 	})
 }
 
+/** --------------------------------引用判断函数----------------------------------------------- */
+
 /**
- * Open API：选区是否含有图片，不一定是同一个图片，只要含有图片即返回true
+ * Open API：选区是否含有引用，不一定是同一个引用，只要含有引用即返回true
  * @param editor
  * @param dataRangeCaches
  * @returns
  */
-export const hasImageInRange = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => {
+export const hasQuoteInRange = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => {
 	if (!editor.range) {
 		return false
 	}
 	if (editor.range.anchor.isEqual(editor.range.focus)) {
-		return elementIsMatch(editor.range.anchor.element, { parsedom: 'img' })
+		return !!getMatchElementByElement(editor.range.anchor.element, { parsedom: 'blockquote' })
 	}
 	return dataRangeCaches.flatList.some(item => {
-		return elementIsMatch(item.element, { parsedom: 'img' })
+		return !!getMatchElementByElement(item.element, { parsedom: 'blockquote' })
 	})
 }
 
 /**
- * Open API：选区是否含有视频，不一定是同一个视频，只要含有视频即返回true
+ * Open API：选区是否全部在引用内，不一定是同一个引用
  * @param editor
  * @param dataRangeCaches
  * @returns
  */
-export const hasVideoInRange = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => {
+export const rangeIsInQuote = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => {
 	if (!editor.range) {
 		return false
 	}
 	if (editor.range.anchor.isEqual(editor.range.focus)) {
-		return elementIsMatch(editor.range.anchor.element, { parsedom: 'video' })
+		return !!getMatchElementByElement(editor.range.anchor.element, { parsedom: 'blockquote' })
 	}
-	return dataRangeCaches.flatList.some(item => {
-		return elementIsMatch(item.element, { parsedom: 'video' })
+	return dataRangeCaches.list.every(item => {
+		return !!getMatchElementByElement(item.element, { parsedom: 'blockquote' })
 	})
 }
 
+/** --------------------------------链接判断函数-------------------------------------------------- */
+
 /**
- * Open API：选区是否全部在引用内，不一定是同一个引用
+ * Open API：选区是否含有链接，不一定是同一个链接，只要含有链接即返回true
  * @param editor
  * @param dataRangeCaches
  * @returns
  */
-export const rangeIsInQuote = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => {
+export const hasLinkInRange = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => {
 	if (!editor.range) {
 		return false
 	}
 	if (editor.range.anchor.isEqual(editor.range.focus)) {
-		return !!getMatchElementByElement(editor.range.anchor.element, { parsedom: 'blockquote' })
+		return !!getMatchElementByElement(editor.range.anchor.element, { parsedom: 'a' })
 	}
-	return dataRangeCaches.list.every(item => {
-		return !!getMatchElementByElement(item.element, { parsedom: 'blockquote' })
+	return dataRangeCaches.flatList.some(item => {
+		return !!getMatchElementByElement(item.element, { parsedom: 'a' })
 	})
 }
 
+/** --------------------------------图片视频判断函数--------------------------------------------- */
+
 /**
- * Open API：查询光标所在的文本元素是否具有某个样式
+ * Open API：选区是否含有图片，不一定是同一个图片，只要含有图片即返回true
  * @param editor
  * @param dataRangeCaches
- * @param name
- * @param value
  * @returns
  */
-export const queryTextStyle = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, name: string, value?: string | number) => {
+export const hasImageInRange = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => {
 	if (!editor.range) {
 		return false
 	}
-	//起点和终点在一起
 	if (editor.range.anchor.isEqual(editor.range.focus)) {
-		//如果是文本元素并且具有样式
-		if (editor.range.anchor.element.isText() && editor.range.anchor.element.hasStyles()) {
-			return queryHasValue(editor.range.anchor.element.styles!, name, value)
-		}
-		//不是文本元素或者没有样式直接返回
-		return false
-	}
-	//起点和终点不在一起获取选区中的文本元素
-	let result = dataRangeCaches.flatList.filter(item => {
-		return item.element.isText()
-	})
-	//如果不包含文本元素直接返回false
-	if (result.length == 0) {
-		return false
+		return elementIsMatch(editor.range.anchor.element, { parsedom: 'img' })
 	}
-	//判断每个文本元素是否都具有该样式
-	let flag = result.every(item => {
-		//文本元素含有样式进一步判断
-		if (item.element.hasStyles()) {
-			return queryHasValue(item.element.styles!, name, value)
-		}
-		//文本元素没有样式直接返回false
-		return false
+	return dataRangeCaches.flatList.some(item => {
+		return elementIsMatch(item.element, { parsedom: 'img' })
 	})
-	return flag
 }
 
 /**
- * Open API：查询光标所在的文本元素是否具有某个标记
+ * Open API：选区是否含有视频，不一定是同一个视频，只要含有视频即返回true
  * @param editor
  * @param dataRangeCaches
- * @param name
- * @param value
  * @returns
  */
-export const queryTextMark = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, name: string, value?: string | number) => {
+export const hasVideoInRange = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => {
 	if (!editor.range) {
 		return false
 	}
-	//起点和终点在一起
 	if (editor.range.anchor.isEqual(editor.range.focus)) {
-		//如果是文本元素并且具有标记
-		if (editor.range.anchor.element.isText() && editor.range.anchor.element.hasMarks()) {
-			return queryHasValue(editor.range.anchor.element.marks!, name, value)
-		}
-		//不是文本元素或者没有标记直接返回
-		return false
-	}
-	//起点和终点不在一起获取选区中的文本元素
-	let result = dataRangeCaches.flatList.filter(item => {
-		return item.element.isText()
-	})
-	//如果不包含文本元素直接返回false
-	if (result.length == 0) {
-		return false
+		return elementIsMatch(editor.range.anchor.element, { parsedom: 'video' })
 	}
-	//判断每个文本元素是否都具有该标记
-	let flag = result.every(item => {
-		//文本元素含有标记进一步判断
-		if (item.element.hasMarks()) {
-			return queryHasValue(item.element.marks!, name, value)
-		}
-		//文本元素没有标记直接返回false
-		return false
+	return dataRangeCaches.flatList.some(item => {
+		return elementIsMatch(item.element, { parsedom: 'video' })
 	})
-	return flag
 }
 
-/**
- * Open API：获取选区内的文字内容
- * @param dataRangeCaches
- * @returns
- */
-export const getRangeText = (dataRangeCaches: AlexElementsRangeType) => {
-	//存在选区的情况下预置链接文本值
-	let text = ''
-	dataRangeCaches.flatList.forEach(item => {
-		if (item.element.isText()) {
-			if (item.offset) {
-				text += item.element.textContent!.substring(item.offset[0], item.offset[1])
-			} else {
-				text += item.element.textContent || ''
-			}
-		}
-	})
-	return text
-}
+/** --------------------文本元素标记和样式相关函数--------------------------------------- */
 
 /**
  * 获取光标选取内的扁平化元素数组(可能会分割文本元素导致stack变更，同时也会更新选取元素和光标位置)
@@ -907,32 +1082,355 @@ export const getFlatElementsByRange = (editor: AlexEditor, dataRangeCaches: Alex
 }
 
 /**
- * 将某个元素转为段落标签
- * @param element
- */
-export const elementToParagraph = (element: AlexElement) => {
-	element.marks = null
-	element.styles = null
-	element.parsedom = AlexElement.BLOCK_NODE
-}
-
-/**
- * 其他元素转为有序或者无序列表
- * @param element
- * @param ordered
+ * Open API：查询光标所在的文本元素是否具有某个样式
+ * @param editor
+ * @param dataRangeCaches
+ * @param name
+ * @param value
  * @returns
  */
-export const elementToList = (element: AlexElement, ordered: boolean | undefined = false) => {
-	//如果是列表则返回
-	if (elementIsList(element, ordered)) {
-		return
-	}
-	//先转为段落
-	elementToParagraph(element)
-	//然后转为列表
-	element.parsedom = 'div'
-	if (!element.hasMarks()) {
-		element.marks = {}
+export const queryTextStyle = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, name: string, value?: string | number) => {
+	if (!editor.range) {
+		return false
+	}
+	//起点和终点在一起
+	if (editor.range.anchor.isEqual(editor.range.focus)) {
+		//如果是文本元素并且具有样式
+		if (editor.range.anchor.element.isText() && editor.range.anchor.element.hasStyles()) {
+			return queryHasValue(editor.range.anchor.element.styles!, name, value)
+		}
+		//不是文本元素或者没有样式直接返回
+		return false
+	}
+	//起点和终点不在一起获取选区中的文本元素
+	let result = dataRangeCaches.flatList.filter(item => {
+		return item.element.isText()
+	})
+	//如果不包含文本元素直接返回false
+	if (result.length == 0) {
+		return false
+	}
+	//判断每个文本元素是否都具有该样式
+	let flag = result.every(item => {
+		//文本元素含有样式进一步判断
+		if (item.element.hasStyles()) {
+			return queryHasValue(item.element.styles!, name, value)
+		}
+		//文本元素没有样式直接返回false
+		return false
+	})
+	return flag
+}
+
+/**
+ * Open API：设置文本元素的样式
+ * @param editor
+ * @param dataRangeCaches
+ * @param styles 值为{ 'font-weight':'bold' }这类格式
+ * @returns
+ */
+export const setTextStyle = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, styles: ObjectType) => {
+	if (!editor.range) {
+		return
+	}
+	//起点和终点在一起
+	if (editor.range.anchor.isEqual(editor.range.focus)) {
+		//如果是空白文本元素直接设置样式
+		if (editor.range.anchor.element.isSpaceText()) {
+			if (editor.range.anchor.element.hasStyles()) {
+				Object.assign(editor.range.anchor.element.styles!, DapCommon.clone(styles))
+			} else {
+				editor.range.anchor.element.styles = DapCommon.clone(styles)
+			}
+		}
+		//如果是文本元素
+		else if (editor.range.anchor.element.isText()) {
+			//新建一个空白文本元素
+			const el = AlexElement.getSpaceElement()
+			//继承文本元素的样式和标记
+			el.styles = DapCommon.clone(editor.range.anchor.element.styles)
+			el.marks = DapCommon.clone(editor.range.anchor.element.marks)
+			//设置样式
+			if (el.hasStyles()) {
+				Object.assign(el.styles!, DapCommon.clone(styles))
+			} else {
+				el.styles = DapCommon.clone(styles)
+			}
+			//插入空白文本元素
+			editor.insertElement(el)
+		}
+		//如果是自闭合元素
+		else {
+			const el = AlexElement.getSpaceElement()
+			el.styles = DapCommon.clone(styles)
+			editor.insertElement(el)
+		}
+	}
+	//不在同一个点
+	else {
+		const elements = getFlatElementsByRange(editor, dataRangeCaches)
+		elements.forEach(ele => {
+			if (ele.isText()) {
+				if (ele.hasStyles()) {
+					Object.assign(ele.styles!, DapCommon.clone(styles))
+				} else {
+					ele.styles = DapCommon.clone(styles)
+				}
+			}
+		})
+	}
+}
+
+/**
+ * Open API：移除文本元素的样式
+ * @param editor
+ * @param dataRangeCaches
+ * @param styleNames 样式名称数组，如果不存在则移除全部样式
+ * @returns
+ */
+export const removeTextStyle = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, styleNames?: string[]) => {
+	if (!editor.range) {
+		return
+	}
+	//移除样式的方法
+	const removeFn = (el: AlexElement) => {
+		//如果参数是数组，表示删除指定的样式
+		if (Array.isArray(styleNames)) {
+			if (el.hasStyles()) {
+				let styles: ObjectType = {}
+				Object.keys(el.styles!).forEach(key => {
+					if (!styleNames.includes(key)) {
+						styles[key] = el.styles![key]
+					}
+				})
+				el.styles = styles
+			}
+		}
+		//如果没有参数，则表示删除所有的样式
+		else {
+			el.styles = null
+		}
+	}
+	//如果起点和终点在一起
+	if (editor.range.anchor.isEqual(editor.range.focus)) {
+		//如果是空白文本元素直接移除样式
+		if (editor.range.anchor.element.isSpaceText()) {
+			removeFn(editor.range.anchor.element)
+		}
+		//如果是文本元素则新建一个空白文本元素
+		else if (editor.range.anchor.element.isText()) {
+			const el = AlexElement.getSpaceElement()
+			//继承文本元素的样式和标记
+			el.styles = DapCommon.clone(editor.range.anchor.element.styles)
+			el.marks = DapCommon.clone(editor.range.anchor.element.marks)
+			//移除样式
+			removeFn(el)
+			//插入
+			editor.insertElement(el)
+		}
+	}
+	//起点和终点不在一起
+	else {
+		const elements = getFlatElementsByRange(editor, dataRangeCaches)
+		elements.forEach(ele => {
+			if (ele.isText()) {
+				removeFn(ele)
+			}
+		})
+	}
+}
+
+/**
+ * Open API：查询光标所在的文本元素是否具有某个标记
+ * @param editor
+ * @param dataRangeCaches
+ * @param name
+ * @param value
+ * @returns
+ */
+export const queryTextMark = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, name: string, value?: string | number) => {
+	if (!editor.range) {
+		return false
+	}
+	//起点和终点在一起
+	if (editor.range.anchor.isEqual(editor.range.focus)) {
+		//如果是文本元素并且具有标记
+		if (editor.range.anchor.element.isText() && editor.range.anchor.element.hasMarks()) {
+			return queryHasValue(editor.range.anchor.element.marks!, name, value)
+		}
+		//不是文本元素或者没有标记直接返回
+		return false
+	}
+	//起点和终点不在一起获取选区中的文本元素
+	let result = dataRangeCaches.flatList.filter(item => {
+		return item.element.isText()
+	})
+	//如果不包含文本元素直接返回false
+	if (result.length == 0) {
+		return false
+	}
+	//判断每个文本元素是否都具有该标记
+	let flag = result.every(item => {
+		//文本元素含有标记进一步判断
+		if (item.element.hasMarks()) {
+			return queryHasValue(item.element.marks!, name, value)
+		}
+		//文本元素没有标记直接返回false
+		return false
+	})
+	return flag
+}
+
+/**
+ * Open API：设置文本元素的标记
+ * @param editor
+ * @param dataRangeCaches
+ * @param marks 值为{ 'class':'a' }这类格式
+ * @returns
+ */
+export const setTextMark = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, marks: ObjectType) => {
+	if (!editor.range) {
+		return
+	}
+	if (!DapCommon.isObject(marks)) {
+		throw new Error('The argument must be an object')
+	}
+	//起点和终点在一起
+	if (editor.range.anchor.isEqual(editor.range.focus)) {
+		//如果是空白文本元素直接设置标记
+		if (editor.range.anchor.element.isSpaceText()) {
+			if (editor.range.anchor.element.hasMarks()) {
+				Object.assign(editor.range.anchor.element.marks!, DapCommon.clone(marks))
+			} else {
+				editor.range.anchor.element.marks = DapCommon.clone(marks)
+			}
+		}
+		//如果是文本元素
+		else if (editor.range.anchor.element.isText()) {
+			//新建一个空白文本元素
+			const el = AlexElement.getSpaceElement()
+			//继承文本元素的样式和标记
+			el.styles = DapCommon.clone(editor.range.anchor.element.styles)
+			el.marks = DapCommon.clone(editor.range.anchor.element.marks)
+			//设置标记
+			if (el.hasMarks()) {
+				Object.assign(el.marks!, DapCommon.clone(marks))
+			} else {
+				el.marks = DapCommon.clone(marks)
+			}
+			//插入空白文本元素
+			editor.insertElement(el)
+		}
+		//如果是自闭合元素
+		else {
+			const el = AlexElement.getSpaceElement()
+			el.marks = DapCommon.clone(marks)
+			editor.insertElement(el)
+		}
+	}
+	//不在同一个点
+	else {
+		const elements = getFlatElementsByRange(editor, dataRangeCaches)
+		elements.forEach(ele => {
+			if (ele.isText()) {
+				if (ele.hasMarks()) {
+					Object.assign(ele.marks!, DapCommon.clone(marks))
+				} else {
+					ele.marks = DapCommon.clone(marks)
+				}
+			}
+		})
+	}
+}
+
+/**
+ * Open API：移除文本元素的标记
+ * @param editor
+ * @param dataRangeCaches
+ * @param markNames 标记名称数组，如果不存在则移除全部标记
+ * @returns
+ */
+export const removeTextMark = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, markNames?: string[]) => {
+	if (!editor.range) {
+		return
+	}
+	//移除样式的方法
+	const removeFn = (el: AlexElement) => {
+		//如果参数是数组，表示删除指定的样式
+		if (Array.isArray(markNames)) {
+			if (el.hasMarks()) {
+				let marks: ObjectType = {}
+				Object.keys(el.marks!).forEach(key => {
+					if (!markNames.includes(key)) {
+						marks[key] = el.marks![key]
+					}
+				})
+				el.marks = marks
+			}
+		}
+		//如果没有参数，则表示删除所有的样式
+		else {
+			el.marks = null
+		}
+	}
+	//如果起点和终点在一起
+	if (editor.range.anchor.isEqual(editor.range.focus)) {
+		//如果是空白文本元素直接移除标记
+		if (editor.range.anchor.element.isSpaceText()) {
+			removeFn(editor.range.anchor.element)
+		}
+		//如果是文本元素则新建一个空白文本元素
+		else if (editor.range.anchor.element.isText()) {
+			const el = AlexElement.getSpaceElement()
+			//继承文本元素的样式和标记
+			el.styles = DapCommon.clone(editor.range.anchor.element.styles)
+			el.marks = DapCommon.clone(editor.range.anchor.element.marks)
+			//移除标记
+			removeFn(el)
+			//插入
+			editor.insertElement(el)
+		}
+	}
+	//起点和终点不在一起
+	else {
+		const elements = getFlatElementsByRange(editor, dataRangeCaches)
+		elements.forEach(ele => {
+			if (ele.isText()) {
+				removeFn(ele)
+			}
+		})
+	}
+}
+
+/** --------------------------------元素转换函数-------------------------------------------------- */
+
+/**
+ * 将某个元素转为段落标签
+ * @param element
+ */
+export const elementToParagraph = (element: AlexElement) => {
+	element.marks = null
+	element.styles = null
+	element.parsedom = AlexElement.BLOCK_NODE
+}
+
+/**
+ * 其他元素转为有序或者无序列表
+ * @param element
+ * @param ordered
+ * @returns
+ */
+export const elementToList = (element: AlexElement, ordered: boolean | undefined = false) => {
+	//如果是列表则返回
+	if (elementIsList(element, ordered)) {
+		return
+	}
+	//先转为段落
+	elementToParagraph(element)
+	//然后转为列表
+	element.parsedom = 'div'
+	if (!element.hasMarks()) {
+		element.marks = {}
 	}
 	element.marks!['data-editify-list'] = ordered ? 'ol' : 'ul'
 }
@@ -957,22 +1455,70 @@ export const elementToTask = (element: AlexElement) => {
 	element.marks!['data-editify-task'] = 'uncheck'
 }
 
+/** --------------------------------封装的功能函数----------------------------------------------- */
+
+/**
+ * Open API：获取选区内的文字内容
+ * @param dataRangeCaches
+ * @returns
+ */
+export const getRangeText = (dataRangeCaches: AlexElementsRangeType) => {
+	//存在选区的情况下预置链接文本值
+	let text = ''
+	dataRangeCaches.flatList.forEach(item => {
+		if (item.element.isText()) {
+			if (item.offset) {
+				text += item.element.textContent!.substring(item.offset[0], item.offset[1])
+			} else {
+				text += item.element.textContent || ''
+			}
+		}
+	})
+	return text
+}
+
+/**
+ * Open API：给元素两侧加上空白文本元素
+ * @param editor
+ * @param element
+ */
+export const addSpaceTextToBothSides = (editor: AlexEditor, element: AlexElement) => {
+	const previousElement = editor.getPreviousElement(element)
+	const newTextElement = editor.getNextElement(element)
+	//如果不存在前一个元素或者前一个元素不是空白元素则设置空白元素
+	if (!previousElement || !previousElement.isSpaceText()) {
+		const spaceText = AlexElement.getSpaceElement()
+		editor.addElementBefore(spaceText, element)
+	}
+	//如果不存在后一个元素或者后一个元素不是空白元素则设置空白元素
+	if (!newTextElement || !newTextElement.isSpaceText()) {
+		const spaceText = AlexElement.getSpaceElement()
+		editor.addElementAfter(spaceText, element)
+	}
+	//如果光标在视频上则更新光标位置
+	if (editor.range && element.isContains(editor.range.anchor.element)) {
+		editor.range.anchor.moveToEnd(editor.getNextElement(element)!)
+	}
+	if (editor.range && element.isContains(editor.range.focus.element)) {
+		editor.range.focus.moveToEnd(editor.getNextElement(element)!)
+	}
+}
+
+/** --------------------------------菜单功能函数----------------------------------------------------- */
+
 /**
- * 设置标题
+ * OpenAPI：设置标题，支持h1-h6和p
  * @param editor
  * @param dataRangeCaches
  * @param editTrans
  * @param parsedom
  * @returns
  */
-export const setHeading = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, editTrans: (key: string) => any, parsedom: string) => {
+export const setHeading = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, parsedom: string) => {
 	if (!editor.range) {
 		return
 	}
-	const values = getButtonOptionsConfig(editTrans).heading!.map(item => {
-		return (<ButtonOptionsItemType>item).value
-	})
-	if (!values.includes(parsedom)) {
+	if (!['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p'].includes(parsedom)) {
 		throw new Error('The parameter supports only h1-h6 and p')
 	}
 	if (editor.range.anchor.isEqual(editor.range.focus)) {
@@ -1152,244 +1698,40 @@ export const setAlign = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeT
 			if (block.hasStyles()) {
 				block.styles!['text-align'] = value
 			} else {
-				block.styles = {
-					'text-align': value
-				}
-			}
-		}
-	} else {
-		dataRangeCaches.list.forEach(el => {
-			if (el.element.isBlock() || el.element.isInblock()) {
-				if (el.element.hasStyles()) {
-					el.element.styles!['text-align'] = value
-				} else {
-					el.element.styles = {
-						'text-align': value
-					}
-				}
-			} else {
-				const block = el.element.getBlock()
-				const inblock = el.element.getInblock()
-				if (inblock) {
-					if (inblock.hasStyles()) {
-						inblock.styles!['text-align'] = value
-					} else {
-						inblock.styles = {
-							'text-align': value
-						}
-					}
-				} else {
-					if (block.hasStyles()) {
-						block.styles!['text-align'] = value
-					} else {
-						block.styles = {
-							'text-align': value
-						}
-					}
-				}
-			}
-		})
-	}
-}
-
-/**
- * Open API：插入或者取消 有序或者无序列表
- * @param editor
- * @param dataRangeCaches
- * @param ordered 为true表示有序列表
- * @returns
- */
-export const setList = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, ordered: boolean) => {
-	if (!editor.range) {
-		return
-	}
-	//是否都在列表内
-	const flag = rangeIsInList(editor, dataRangeCaches, ordered)
-	//起点和终点在一起
-	if (editor.range.anchor.isEqual(editor.range.focus)) {
-		const block = editor.range.anchor.element.getBlock()
-		if (flag) {
-			elementToParagraph(block)
-		} else {
-			elementToList(block, ordered)
-		}
-	}
-	//起点和终点不在一起
-	else {
-		let blocks: AlexElement[] = []
-		dataRangeCaches.list.forEach(item => {
-			const block = item.element.getBlock()
-			const exist = blocks.some(el => block.isEqual(el))
-			if (!exist) {
-				blocks.push(block)
-			}
-		})
-		blocks.forEach(block => {
-			if (flag) {
-				elementToParagraph(block)
-			} else {
-				elementToList(block, ordered)
-			}
-		})
-	}
-}
-
-/**
- * Open API：插入或者取消任务列表
- * @param editor
- * @param dataRangeCaches
- * @returns
- */
-export const setTask = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => {
-	if (!editor.range) {
-		return
-	}
-	//是否都在任务列表里
-	const flag = rangeIsInTask(editor, dataRangeCaches)
-	//起点和终点在一起
-	if (editor.range.anchor.isEqual(editor.range.focus)) {
-		const block = editor.range.anchor.element.getBlock()
-		if (flag) {
-			elementToParagraph(block)
-		} else {
-			elementToTask(block)
-		}
-	}
-	//起点和终点不在一起
-	else {
-		let blocks: AlexElement[] = []
-		dataRangeCaches.list.forEach(item => {
-			const block = item.element.getBlock()
-			const exist = blocks.some(el => block.isEqual(el))
-			if (!exist) {
-				blocks.push(block)
-			}
-		})
-		blocks.forEach(block => {
-			if (flag) {
-				elementToParagraph(block)
-			} else {
-				elementToTask(block)
-			}
-		})
-	}
-}
-
-/**
- * Open API：设置文本元素的样式
- * @param editor
- * @param dataRangeCaches
- * @param styles 值为{ 'font-weight':'bold' }这类格式
- * @returns
- */
-export const setTextStyle = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, styles: ObjectType) => {
-	if (!editor.range) {
-		return
-	}
-	//起点和终点在一起
-	if (editor.range.anchor.isEqual(editor.range.focus)) {
-		//如果是空白文本元素直接设置样式
-		if (editor.range.anchor.element.isSpaceText()) {
-			if (editor.range.anchor.element.hasStyles()) {
-				Object.assign(editor.range.anchor.element.styles!, cloneData(styles))
-			} else {
-				editor.range.anchor.element.styles = cloneData(styles)
-			}
-		}
-		//如果是文本元素
-		else if (editor.range.anchor.element.isText()) {
-			//新建一个空白文本元素
-			const el = AlexElement.getSpaceElement()
-			//继承文本元素的样式和标记
-			el.styles = cloneData(editor.range.anchor.element.styles)
-			el.marks = cloneData(editor.range.anchor.element.marks)
-			//设置样式
-			if (el.hasStyles()) {
-				Object.assign(el.styles!, cloneData(styles))
-			} else {
-				el.styles = cloneData(styles)
-			}
-			//插入空白文本元素
-			editor.insertElement(el)
-		}
-		//如果是自闭合元素
-		else {
-			const el = AlexElement.getSpaceElement()
-			el.styles = cloneData(styles)
-			editor.insertElement(el)
-		}
-	}
-	//不在同一个点
-	else {
-		const elements = getFlatElementsByRange(editor, dataRangeCaches)
-		elements.forEach(ele => {
-			if (ele.isText()) {
-				if (ele.hasStyles()) {
-					Object.assign(ele.styles!, cloneData(styles))
-				} else {
-					ele.styles = cloneData(styles)
-				}
-			}
-		})
-	}
-}
-
-/**
- * Open API：设置文本元素的标记
- * @param editor
- * @param dataRangeCaches
- * @param marks 值为{ 'class':'a' }这类格式
- * @returns
- */
-export const setTextMark = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, marks: ObjectType) => {
-	if (!editor.range) {
-		return
-	}
-	if (!DapCommon.isObject(marks)) {
-		throw new Error('The argument must be an object')
-	}
-	//起点和终点在一起
-	if (editor.range.anchor.isEqual(editor.range.focus)) {
-		//如果是空白文本元素直接设置标记
-		if (editor.range.anchor.element.isSpaceText()) {
-			if (editor.range.anchor.element.hasMarks()) {
-				Object.assign(editor.range.anchor.element.marks!, cloneData(marks))
-			} else {
-				editor.range.anchor.element.marks = cloneData(marks)
-			}
-		}
-		//如果是文本元素
-		else if (editor.range.anchor.element.isText()) {
-			//新建一个空白文本元素
-			const el = AlexElement.getSpaceElement()
-			//继承文本元素的样式和标记
-			el.styles = cloneData(editor.range.anchor.element.styles)
-			el.marks = cloneData(editor.range.anchor.element.marks)
-			//设置标记
-			if (el.hasMarks()) {
-				Object.assign(el.marks!, cloneData(marks))
-			} else {
-				el.marks = cloneData(marks)
-			}
-			//插入空白文本元素
-			editor.insertElement(el)
-		}
-		//如果是自闭合元素
-		else {
-			const el = AlexElement.getSpaceElement()
-			el.marks = cloneData(marks)
-			editor.insertElement(el)
+				block.styles = {
+					'text-align': value
+				}
+			}
 		}
-	}
-	//不在同一个点
-	else {
-		const elements = getFlatElementsByRange(editor, dataRangeCaches)
-		elements.forEach(ele => {
-			if (ele.isText()) {
-				if (ele.hasMarks()) {
-					Object.assign(ele.marks!, cloneData(marks))
+	} else {
+		dataRangeCaches.list.forEach(el => {
+			if (el.element.isBlock() || el.element.isInblock()) {
+				if (el.element.hasStyles()) {
+					el.element.styles!['text-align'] = value
+				} else {
+					el.element.styles = {
+						'text-align': value
+					}
+				}
+			} else {
+				const block = el.element.getBlock()
+				const inblock = el.element.getInblock()
+				if (inblock) {
+					if (inblock.hasStyles()) {
+						inblock.styles!['text-align'] = value
+					} else {
+						inblock.styles = {
+							'text-align': value
+						}
+					}
 				} else {
-					ele.marks = cloneData(marks)
+					if (block.hasStyles()) {
+						block.styles!['text-align'] = value
+					} else {
+						block.styles = {
+							'text-align': value
+						}
+					}
 				}
 			}
 		})
@@ -1397,125 +1739,90 @@ export const setTextMark = (editor: AlexEditor, dataRangeCaches: AlexElementsRan
 }
 
 /**
- * Open API：移除文本元素的样式
+ * Open API：插入或者取消 有序或者无序列表
  * @param editor
  * @param dataRangeCaches
- * @param styleNames 样式名称数组，如果不存在则移除全部样式
+ * @param ordered 为true表示有序列表
  * @returns
  */
-export const removeTextStyle = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, styleNames?: string[]) => {
+export const setList = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, ordered: boolean) => {
 	if (!editor.range) {
 		return
 	}
-	//移除样式的方法
-	const removeFn = (el: AlexElement) => {
-		//如果参数是数组，表示删除指定的样式
-		if (Array.isArray(styleNames)) {
-			if (el.hasStyles()) {
-				let styles: ObjectType = {}
-				Object.keys(el.styles!).forEach(key => {
-					if (!styleNames.includes(key)) {
-						styles[key] = el.styles![key]
-					}
-				})
-				el.styles = styles
-			}
-		}
-		//如果没有参数，则表示删除所有的样式
-		else {
-			el.styles = null
-		}
-	}
-	//如果起点和终点在一起
+	//是否都在列表内
+	const flag = rangeIsInList(editor, dataRangeCaches, ordered)
+	//起点和终点在一起
 	if (editor.range.anchor.isEqual(editor.range.focus)) {
-		//如果是空白文本元素直接移除样式
-		if (editor.range.anchor.element.isSpaceText()) {
-			removeFn(editor.range.anchor.element)
-		}
-		//如果是文本元素则新建一个空白文本元素
-		else if (editor.range.anchor.element.isText()) {
-			const el = AlexElement.getSpaceElement()
-			//继承文本元素的样式和标记
-			el.styles = cloneData(editor.range.anchor.element.styles)
-			el.marks = cloneData(editor.range.anchor.element.marks)
-			//移除样式
-			removeFn(el)
-			//插入
-			editor.insertElement(el)
+		const block = editor.range.anchor.element.getBlock()
+		if (flag) {
+			elementToParagraph(block)
+		} else {
+			elementToList(block, ordered)
 		}
 	}
 	//起点和终点不在一起
 	else {
-		const elements = getFlatElementsByRange(editor, dataRangeCaches)
-		elements.forEach(ele => {
-			if (ele.isText()) {
-				removeFn(ele)
+		let blocks: AlexElement[] = []
+		dataRangeCaches.list.forEach(item => {
+			const block = item.element.getBlock()
+			const exist = blocks.some(el => block.isEqual(el))
+			if (!exist) {
+				blocks.push(block)
+			}
+		})
+		blocks.forEach(block => {
+			if (flag) {
+				elementToParagraph(block)
+			} else {
+				elementToList(block, ordered)
 			}
 		})
 	}
 }
 
 /**
- * Open API：移除文本元素的标记
+ * Open API：插入或者取消任务列表
  * @param editor
  * @param dataRangeCaches
- * @param markNames 标记名称数组，如果不存在则移除全部标记
  * @returns
  */
-export const removeTextMark = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, markNames?: string[]) => {
+export const setTask = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => {
 	if (!editor.range) {
 		return
 	}
-	//移除样式的方法
-	const removeFn = (el: AlexElement) => {
-		//如果参数是数组，表示删除指定的样式
-		if (Array.isArray(markNames)) {
-			if (el.hasMarks()) {
-				let marks: ObjectType = {}
-				Object.keys(el.marks!).forEach(key => {
-					if (!markNames.includes(key)) {
-						marks[key] = el.marks![key]
-					}
-				})
-				el.marks = marks
-			}
-		}
-		//如果没有参数，则表示删除所有的样式
-		else {
-			el.marks = null
-		}
-	}
-	//如果起点和终点在一起
+	//是否都在任务列表里
+	const flag = rangeIsInTask(editor, dataRangeCaches)
+	//起点和终点在一起
 	if (editor.range.anchor.isEqual(editor.range.focus)) {
-		//如果是空白文本元素直接移除标记
-		if (editor.range.anchor.element.isSpaceText()) {
-			removeFn(editor.range.anchor.element)
-		}
-		//如果是文本元素则新建一个空白文本元素
-		else if (editor.range.anchor.element.isText()) {
-			const el = AlexElement.getSpaceElement()
-			//继承文本元素的样式和标记
-			el.styles = cloneData(editor.range.anchor.element.styles)
-			el.marks = cloneData(editor.range.anchor.element.marks)
-			//移除标记
-			removeFn(el)
-			//插入
-			editor.insertElement(el)
+		const block = editor.range.anchor.element.getBlock()
+		if (flag) {
+			elementToParagraph(block)
+		} else {
+			elementToTask(block)
 		}
 	}
 	//起点和终点不在一起
 	else {
-		const elements = getFlatElementsByRange(editor, dataRangeCaches)
-		elements.forEach(ele => {
-			if (ele.isText()) {
-				removeFn(ele)
+		let blocks: AlexElement[] = []
+		dataRangeCaches.list.forEach(item => {
+			const block = item.element.getBlock()
+			const exist = blocks.some(el => block.isEqual(el))
+			if (!exist) {
+				blocks.push(block)
+			}
+		})
+		blocks.forEach(block => {
+			if (flag) {
+				elementToParagraph(block)
+			} else {
+				elementToTask(block)
 			}
 		})
 	}
 }
 
 /**
- * Open API：设置块元素或者根级块元素的行高
+ * Open API：设置内部块元素或者根级块元素的行高
  * @param editor
  * @param dataRangeCaches
  * @param value
@@ -1844,3 +2151,182 @@ export const insertSeparator = (editor: AlexEditor) => {
 	editor.range.anchor.moveToEnd(separator)
 	editor.range.focus.moveToEnd(separator)
 }
+
+/**
+ * Open API：插入附件
+ * @param editor
+ * @param url 附件地址
+ * @param name 附件名称
+ */
+export const insertAttachment = (editor: AlexEditor, url: string, name: string) => {
+	const marks: ObjectType = {
+		'data-editify-attachment': url,
+		'data-editify-attachment-name': name
+	}
+	//创建元素
+	const attachmentElement = AlexElement.create({
+		type: 'closed',
+		parsedom: 'span',
+		marks
+	})
+	//插入编辑器
+	editor.insertElement(attachmentElement)
+	//移动光标到新插入的元素
+	editor.range!.anchor.moveToEnd(attachmentElement)
+	editor.range!.focus.moveToEnd(attachmentElement)
+}
+
+/**
+ * Open API：插入数学公式
+ * @param editor
+ * @param dataRangeCaches
+ * @param mathContent 数学公式字符串
+ * @param errorCallback 错误处理
+ */
+export const insertMathformula = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, mathContent: string, errorCallback?: (err: Error) => void) => {
+	if (!mathContent) {
+		return
+	}
+	//获取选区所在的数学公式元素
+	const mathformulaElement = getMatchElementByRange(editor, dataRangeCaches, {
+		parsedom: 'span',
+		marks: {
+			'data-editify-mathformula': true
+		}
+	})
+	//如果在数学公式下
+	if (mathformulaElement) {
+		//清除该数学公式
+		mathformulaElement.toEmpty()
+		//移动光标到后一个元素上
+		const nextElement = editor.getNextElement(mathformulaElement)!
+		editor.range!.anchor.moveToStart(nextElement)
+		editor.range!.focus.moveToStart(nextElement)
+	}
+	//定义转换后的mathml内容
+	let mathml: string = ''
+	try {
+		//获取转换后的mathml
+		mathml = KaTex.renderToString(mathContent, {
+			output: 'mathml',
+			throwOnError: true
+		})
+	} catch (error) {
+		mathml = ''
+		if (typeof errorCallback == 'function') {
+			errorCallback(error as Error)
+		}
+	}
+	//如果mathml存在则表示数学公式渲染成功则插入到编辑器
+	if (mathml) {
+		//设置最终的html内容
+		const html = `<span data-editify-mathformula="${mathContent}" contenteditable="false">${mathml}</span>`
+		//html内容转为元素数组
+		const elements = editor.parseHtml(html)
+		//插入编辑器
+		editor.insertElement(elements[0])
+		//移动光标到新插入的元素
+		editor.range!.anchor.moveToEnd(elements[0])
+		editor.range!.focus.moveToEnd(elements[0])
+		//渲染
+		editor.domRender()
+		editor.rangeRender()
+	}
+}
+
+/**
+ * Open API：插入信息块
+ * @param editor
+ * @param dataRangeCaches
+ */
+export const insertInfoBlock = (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => {
+	//是否都在信息块里
+	const flag = rangeIsInInfoBlock(editor, dataRangeCaches)
+	//起点和终点在一起
+	if (editor.range!.anchor.isEqual(editor.range!.focus)) {
+		const block = editor.range!.anchor.element.getBlock()
+		elementToParagraph(block)
+		if (!flag) {
+			block.parsedom = 'div'
+			block.marks = {
+				'data-editify-info': 'true'
+			}
+		}
+	}
+	//起点和终点不在一起
+	else {
+		let blocks: AlexElement[] = []
+		dataRangeCaches.list.forEach(item => {
+			const block = item.element.getBlock()
+			const exist = blocks.some(el => block.isEqual(el))
+			if (!exist) {
+				blocks.push(block)
+			}
+		})
+		blocks.forEach(block => {
+			elementToParagraph(block)
+			if (!flag) {
+				block.parsedom = 'div'
+				block.marks = {
+					'data-editify-info': 'true'
+				}
+			}
+		})
+	}
+}
+
+/**
+ * Open API：插入面板
+ * @param editor
+ * @param panelTitle 面板标题
+ * @param panelContent 面板内容
+ */
+export const insertPanel = (editor: AlexEditor, panelTitle: string, panelContent: string) => {
+	const panelElement = AlexElement.create({
+		type: 'block',
+		parsedom: 'div',
+		marks: {
+			'data-editify-panel': 'true'
+		},
+		children: [
+			{
+				type: 'inblock',
+				parsedom: 'div',
+				behavior: 'block',
+				children: [
+					{
+						type: 'text',
+						textcontent: panelTitle
+					}
+				]
+			},
+			{
+				type: 'inblock',
+				parsedom: 'div',
+				behavior: 'block',
+				children: [
+					{
+						type: 'text',
+						textcontent: panelContent
+					}
+				]
+			}
+		]
+	})
+	editor.insertElement(panelElement)
+	//面板后面插入段落
+	const paragraph = AlexElement.create({
+		type: 'block',
+		parsedom: AlexElement.BLOCK_NODE,
+		children: [
+			{
+				type: 'closed',
+				parsedom: 'br'
+			}
+		]
+	})
+	editor.addElementAfter(paragraph, panelElement)
+	//移动光标到新插入的元素
+	editor.range!.anchor.moveToEnd(panelElement.children![0])
+	editor.range!.focus.moveToEnd(panelElement.children![0])
+}