suneditor 3.0.0-alpha.9 → 3.0.0-beta.2

package/src/helper/converter.js

@@ -12,6 +12,87 @@ const FONT_VALUES_MAP = {
 	'xxx-large': 8
 };
 
+function NodeToJson(node) {
+	// text
+	if (node.nodeType === 3) {
+		const text = node.nodeValue.trim();
+		if (text) return { type: 'text', content: text };
+		return null;
+	}
+
+	// element
+	if (node.nodeType === 1) {
+		const jsonNode = {
+			type: 'element',
+			tag: node.tagName.toLowerCase(),
+			attributes: {},
+			children: []
+		};
+
+		// get attribute
+		for (const attr of node.attributes) {
+			jsonNode.attributes[attr.name] = attr.value;
+		}
+
+		// children
+		for (const child of node.childNodes) {
+			const childJson = NodeToJson(child);
+			if (childJson) jsonNode.children.push(childJson);
+		}
+
+		return jsonNode;
+	}
+
+	return null;
+}
+
+/**
+ * @description Parses an HTML string into a DOM tree, then recursively traverses the nodes to convert them into a structured JSON representation.
+ * -Each element includes its tag name, attributes, and children.
+ * -Text nodes are represented as { type: 'text', content: '...' }.
+ * @param {string} content HTML string
+ * @returns {Object<string, *>} JSON data
+ */
+export function htmlToJson(content) {
+	const parser = new DOMParser();
+	const doc = parser.parseFromString(content, 'text/html');
+	return NodeToJson(doc.body);
+}
+
+/**
+ * @description Takes a JSON structure representing HTML elements and recursively serializes it into a valid HTML string.
+ * -It rebuilds each tag with attributes and inner content.
+ * Text content and attributes are safely escaped to prevent parsing issues or XSS.
+ * Useful for restoring dynamic HTML from a data format.
+ * @param {Object<string, *>} jsonData
+ * @returns {string} HTML string
+ */
+export function jsonToHtml(jsonData) {
+	if (!jsonData) return '';
+
+	if (jsonData.type === 'text') {
+		return htmlToEntity(jsonData.content || '');
+	}
+
+	if (jsonData.type === 'element') {
+		const { tag, attributes = {}, children = [] } = jsonData;
+
+		// 속성 문자열 구성
+		const attrString = Object.entries(attributes)
+			.map(([key, value]) => `${key}="${htmlToEntity(value)}"`)
+			.join(' ');
+
+		const openTag = attrString ? `<${tag} ${attrString}>` : `<${tag}>`;
+		const closeTag = `</${tag}>`;
+
+		const childrenHtml = children.map(jsonToHtml).join('');
+
+		return `${openTag}${childrenHtml}${closeTag}`;
+	}
+
+	return '';
+}
+
 /**
  * @description Convert HTML string to HTML Entity
  * @param {string} content
@@ -53,9 +134,9 @@ export function entityToHTML(content) {
 
 /**
  * @description Debounce function
- * @param {Function} func function
+ * @param {(...args: *) => void} func function
  * @param {number} wait delay ms
- * @returns
+ * @returns {*} executedFunction
  */
 export function debounce(func, wait) {
 	let timeout;
@@ -67,19 +148,84 @@ export function debounce(func, wait) {
 		};
 
 		_w.clearTimeout(timeout);
-		timeout = setTimeout(later, wait);
+		timeout = _w.setTimeout(later, wait);
 	};
 }
 
+/**
+ * @description Synchronizes two Map objects by updating the first Map with the values from the second,
+ * - and deleting any keys in the first Map that are not present in the second.
+ * @param {Map<*, *>} targetMap The Map to update (target).
+ * @param {Map<*, *>} referenceMap The Map providing the reference values (source).
+ */
+export function syncMaps(targetMap, referenceMap) {
+	referenceMap.forEach((value, key) => {
+		targetMap.set(key, value);
+	});
+
+	targetMap.forEach((_value, key) => {
+		if (!referenceMap.has(key)) {
+			targetMap.delete(key);
+		}
+	});
+}
+
+/**
+ * @description Object.values
+ * @param {Object<*, *>} obj Object parameter.
+ * @returns {Array<*>}
+ */
+export function getValues(obj) {
+	return !obj
+		? []
+		: Object.keys(obj).map(function (i) {
+				return obj[i];
+		  });
+}
+
+/**
+ * @description Convert the CamelCase To the KebabCase.
+ * @param {string|Array<string>} param [Camel string]
+ */
+export function camelToKebabCase(param) {
+	if (typeof param === 'string') {
+		return param.replace(/[A-Z]/g, (letter) => '-' + letter.toLowerCase());
+	} else {
+		return param.map(function (str) {
+			return camelToKebabCase(str);
+		});
+	}
+}
+
+/**
+ * @overload
+ * @param {string} param - Kebab-case string.
+ * @returns {string} CamelCase string.
+ */
+/**
+ * @overload
+ * @param {Array<string>} param - Array of Kebab-case strings.
+ * @returns {Array<string>} Array of CamelCase strings.
+ */
+export function kebabToCamelCase(param) {
+	if (typeof param === 'string') {
+		return param.replace(/-[a-zA-Z]/g, (letter) => letter.replace('-', '').toUpperCase());
+	} else {
+		return param.map(function (str) {
+			return camelToKebabCase(str);
+		});
+	}
+}
+
 /**
  *
  * @param {"em"|"rem"|"%"|"pt"|"px"} to Size units to be converted
  * @param {string} size siSize to convert with units (ex: "15rem")
  * @returns {string}
  */
-export function fontSize(to, size) {
+export function toFontUnit(to, size) {
 	const value = size.match(/(\d+(?:\.\d+)?)(.+)/);
-	const sizeNum = value ? value[1] * 1 : FONT_VALUES_MAP[size];
+	const sizeNum = value ? Number(value[1]) : FONT_VALUES_MAP[size];
 	const from = value ? value[2] : 'rem';
 	let pxSize = sizeNum;
 
@@ -96,9 +242,9 @@ export function fontSize(to, size) {
 		case 'rem':
 			return (pxSize * 0.0625).toFixed(2) + to;
 		case '%':
-			return (pxSize * 0.0625).toFixed(2) * 100 + to;
+			return Number((pxSize * 0.0625).toFixed(2)) * 100 + to;
 		case 'pt':
-			return Math.floor(pxSize / 1.333) + to;
+			return Math.round(pxSize / 1.333) + to;
 		default:
 			// px
 			return pxSize + to;
@@ -107,7 +253,7 @@ export function fontSize(to, size) {
 
 /**
  * @description Convert the node list to an array. If not, returns an empty array.
- * @param {NodeList|null} nodeList
+ * @param {?__se__NodeCollection} nodeList
  * @returns Array
  */
 export function nodeListToArray(nodeList) {
@@ -117,8 +263,8 @@ export function nodeListToArray(nodeList) {
 
 /**
  * @description Returns a new object with keys and values swapped.
- * @param {Object} obj object
- * @returns {Object}
+ * @param {Object<*, *>} obj object
+ * @returns {Object<*, *>}
  */
 export function swapKeyValue(obj) {
 	const swappedObj = {};
@@ -134,9 +280,8 @@ export function swapKeyValue(obj) {
 
 /**
  * @description Create whitelist RegExp object.
- * Return RegExp format: new RegExp("<\\/?\\b(?!" + list + ")\\b[^>^<]*+>", "gi")
  * @param {string} list Tags list ("br|p|div|pre...")
- * @returns {RegExp}
+ * @returns {RegExp} Return RegExp format: new RegExp("<\\/?\\b(?!" + list + ")\\b[^>^<]*+>", "gi")
  */
 export function createElementWhitelist(list) {
 	return new RegExp(`<\\/?\\b(?!\\b${(list || '').replace(/\|/g, '\\b|\\b')}\\b)[^>]*>`, 'gi');
@@ -144,9 +289,8 @@ export function createElementWhitelist(list) {
 
 /**
  * @description Create blacklist RegExp object.
- * Return RegExp format: new RegExp("<\\/?\\b(?:" + list + ")\\b[^>^<]*+>", "gi")
  * @param {string} list Tags list ("br|p|div|pre...")
- * @returns {RegExp}
+ * @returns {RegExp} Return RegExp format: new RegExp("<\\/?\\b(?:" + list + ")\\b[^>^<]*+>", "gi")
  */
 export function createElementBlacklist(list) {
 	return new RegExp(`<\\/?\\b(?:\\b${(list || '^').replace(/\|/g, '\\b|\\b')}\\b)[^>]*>`, 'gi');
@@ -162,7 +306,7 @@ export function isHexColor(str) {
 
 /**
  * @description Function to convert hex format to a rgb color
- * @param {string} rgb RGB color format
+ * @param {string} rgba RGBA color format
  * @returns {string}
  */
 export function rgb2hex(rgba) {
@@ -191,15 +335,15 @@ export function rgb2hex(rgba) {
 
 /**
  * @description Computes the width as a percentage of the parent's width, and returns this value rounded to two decimal places.
- * @param {Element} target
- * @param {Element|null} parentTarget
+ * @param {HTMLElement} target The target element for which to calculate the width percentage.
+ * @param {?HTMLElement=} parentTarget The parent element to use as the reference for the width calculation. If not provided, the target's parent element is used.
  * @returns {number}
  */
 export function getWidthInPercentage(target, parentTarget) {
-	const parent = parentTarget || target.parentElement;
+	const parent = /** @type {HTMLElement} */ (parentTarget || target.parentElement);
 	const parentStyle = _w.getComputedStyle(parent);
-	const parentPaddingLeft = _w.parseFloat(parentStyle.paddingLeft);
-	const parentPaddingRight = _w.parseFloat(parentStyle.paddingRight);
+	const parentPaddingLeft = parseFloat(parentStyle.paddingLeft);
+	const parentPaddingRight = parseFloat(parentStyle.paddingRight);
 	const scrollbarWidth = parent.offsetWidth - parent.clientWidth;
 	const parentWidth = parent.offsetWidth - parentPaddingLeft - parentPaddingRight - scrollbarWidth;
 	const widthInPercentage = (target.offsetWidth / parentWidth) * 100;
@@ -209,11 +353,13 @@ export function getWidthInPercentage(target, parentTarget) {
 /**
  * @description Convert url pattern text node to anchor node
  * @param {Node} node Text node
+ * @returns {boolean} Return true if the text node is converted to an anchor node
  */
 export function textToAnchor(node) {
 	if (node.nodeType === 3 && URLPattern.test(node.textContent) && !/^A$/i.test(node.parentNode?.nodeName)) {
 		const textContent = node.textContent;
 		const fragment = _d.createDocumentFragment();
+
 		let lastIndex = 0;
 		textContent.replace(URLPattern, (match, offset) => {
 			if (offset > 0) {
@@ -228,20 +374,25 @@ export function textToAnchor(node) {
 			if (lastIndex < textContent.length) {
 				fragment.appendChild(_d.createTextNode(textContent.slice(lastIndex)));
 			}
+			return match;
 		});
+
 		node.parentNode.replaceChild(fragment, node);
+		return true;
 	}
+
+	return false;
 }
 
 /**
  * Converts styles within a <span> tag to corresponding HTML tags (e.g., <strong>, <em>, <u>, <s>).
  * Maintains the original <span> tag and wraps its content with the new tags.
- * @param {Object} styleToTag An object mapping style properties to HTML tags. ex) {bold: { regex: /font-weight\s*:\s*bold/i, tag: 'strong' },}
+ * @param {{ regex: RegExp, tag: string }} styleToTag An object mapping style properties to HTML tags. ex) {bold: { regex: /font-weight\s*:\s*bold/i, tag: 'strong' },}
  * @param {Node} node Node
  */
 export function spanToStyleNode(styleToTag, node) {
-	if (node.nodeType === 1 && /^SPAN$/i.test(node.nodeName) && node.hasAttribute('style')) {
-		const style = node.getAttribute('style');
+	if (node.nodeType === 1 && /^SPAN$/i.test(node.nodeName) && /** @type {HTMLElement} */ (node).hasAttribute('style')) {
+		const style = /** @type {HTMLElement} */ (node).getAttribute('style');
 		const tags = [];
 		Object.keys(styleToTag).forEach((key) => {
 			if (styleToTag[key].regex.test(style)) {
@@ -278,9 +429,27 @@ export function spanToStyleNode(styleToTag, node) {
 	}
 }
 
+/**
+ * Adds a query string to a URL. If the URL already contains a query string, the new query is appended to the existing one.
+ * @param {string} url The original URL to which the query string will be added.
+ * @param {string} query The query string to be added to the URL.
+ * @returns {string} The updated URL with the query string appended.
+ */
+export function addUrlQuery(url, query) {
+	if (query.length > 0) {
+		if (/\?/.test(url)) {
+			const splitUrl = url.split('?');
+			url = splitUrl[0] + '?' + query + '&' + splitUrl[1];
+		} else {
+			url += '?' + query;
+		}
+	}
+	return url;
+}
+
 /**
  * @description Converts options-related styles and returns them for each frame.
- * @param {Object.<string, any>} fo frameOptions
+ * @param {Map<string, *>} fo editor.frameOptions
  * @param {string} cssText Style string
  * @returns {{top: string, frame: string, editor: string}}
  * @private
@@ -325,7 +494,7 @@ export function _setDefaultOptionStyle(fo, cssText) {
 
 /**
  * @description Set default style tag of the iframe
- * @param {Object.<string, any>} options Options
+ * @param {Array<string>} linkNames link names array of CSS files
  * @returns {string} "<link rel="stylesheet" href=".." />.."
  */
 export function _setIframeStyleLinks(linkNames) {
@@ -367,10 +536,16 @@ export function _setAutoHeightStyle(frameHeight) {
 }
 
 const converter = {
+	htmlToJson,
+	jsonToHtml,
 	htmlToEntity,
 	entityToHTML,
 	debounce,
-	fontSize,
+	syncMaps,
+	getValues,
+	camelToKebabCase,
+	kebabToCamelCase,
+	toFontUnit,
 	nodeListToArray,
 	swapKeyValue,
 	createElementWhitelist,
@@ -380,6 +555,7 @@ const converter = {
 	getWidthInPercentage,
 	textToAnchor,
 	spanToStyleNode,
+	addUrlQuery,
 	_setDefaultOptionStyle,
 	_setIframeStyleLinks,
 	_setAutoHeightStyle

package/src/helper/dom/domCheck.js

@@ -0,0 +1,304 @@
+/**
+ * @fileoverview Implements Helper for checking the node type and attributes.
+ */
+
+import { onlyZeroWidthRegExp } from '../unicode';
+import domUtils from './domUtils';
+
+/**
+ * @description A method that checks If the text is blank or to see if it contains 'ZERO WIDTH SPACE' or empty (unicode.zeroWidthSpace)
+ * @param {string|Node} text String value or Node
+ * @returns {boolean}
+ */
+export function isZeroWidth(text) {
+	if (text === null || text === undefined) return false;
+	if (typeof text !== 'string') text = text.textContent;
+	return text === '' || onlyZeroWidthRegExp.test(text);
+}
+
+/**
+ * @description Determine if this offset is the edge offset of container
+ * @param {Node} container The node of the selection object. (range.startContainer..)
+ * @param {number} offset The offset of the selection object. (core.getRange().startOffset...)
+ * @param {?"front"|"end"=} dir Select check point - Both edge, Front edge or End edge. ("front": Front edge, "end": End edge, undefined: Both edge)
+ * @returns {boolean}
+ */
+export function isEdgePoint(container, offset, dir) {
+	return (dir !== 'end' && offset === 0) || ((!dir || dir !== 'front') && !container.nodeValue && offset === 1) || ((!dir || dir === 'end') && container.nodeValue && offset >= container.nodeValue.length);
+}
+
+/**
+ * @description Check the node is a text node.
+ * @param {?Node} node The node to check
+ * @returns {node is Text}
+ */
+export function isText(node) {
+	return node?.nodeType === 3;
+}
+
+/**
+ * @description Check the node is an HTMLElement node.
+ * @param {?Node} node The node to check
+ * @returns {node is HTMLElement}
+ */
+export function isElement(node) {
+	return node?.nodeType === 1;
+}
+
+/**
+ * @description It is judged whether it is the input element (INPUT, TEXTAREA)
+ * @param {?Node} node The node to check
+ * @returns {node is HTMLInputElement}
+ */
+export function isInputElement(node) {
+	return isElement(node) && /^(INPUT|TEXTAREA|SELECT|OPTION)$/i.test(node.nodeName);
+}
+
+/**
+ * @description It is judged whether it is the button element
+ * @param {?Node} node The node to check
+ * @returns {node is HTMLButtonElement}
+ */
+export function isButtonElement(node) {
+	return isElement(node) && /^(BUTTON)$/i.test(node.nodeName);
+}
+
+/**
+ * @description Check the node is a list (ol, ul)
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLOListElement|HTMLUListElement}
+ */
+export function isList(node) {
+	return /^(OL|UL)$/i.test(typeof node === 'string' ? node : node?.nodeName);
+}
+
+/**
+ * @description Check the node is a list cell (li)
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLLIElement}
+ */
+export function isListCell(node) {
+	return /^LI$/i.test(typeof node === 'string' ? node : node?.nodeName);
+}
+
+/**
+ * @description Check the node is a table
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLTableElement}
+ */
+export function isTable(node) {
+	return /^TABLE$/i.test(typeof node === 'string' ? node : node?.nodeName);
+}
+
+/**
+ * @description Check the node is a table elements. (table, thead, tbody, tr, th, td)
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLTableElement|HTMLTableSectionElement|HTMLTableRowElement|HTMLTableCellElement|HTMLTableColElement|HTMLTableColElement}
+ */
+export function isTableElements(node) {
+	return /^(TABLE|THEAD|TBODY|TR|TH|TD|COL)$/i.test(typeof node === 'string' ? node : node?.nodeName);
+}
+
+/**
+ * @description Check the node is a table cell (td, th)
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLTableCellElement|HTMLTableColElement}
+ */
+export function isTableCell(node) {
+	return /^(TD|TH)$/i.test(typeof node === 'string' ? node : node?.nodeName);
+}
+
+/**
+ * @description Check the node is a table row (tr)
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLTableRowElement}
+ */
+export function isTableRow(node) {
+	return /^TR$/i.test(typeof node === 'string' ? node : node?.nodeName);
+}
+
+/**
+ * @description Check the node is a break node (BR)
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLBRElement}
+ */
+export function isBreak(node) {
+	return /^BR$/i.test(typeof node === 'string' ? node : node?.nodeName);
+}
+
+/**
+ * @description Check the node is a anchor node (A)
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLAnchorElement}
+ */
+export function isAnchor(node) {
+	return /^A$/i.test(typeof node === 'string' ? node : node?.nodeName);
+}
+
+/**
+ * @description Check the node is a media node (img, iframe, audio, video, canvas)
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLImageElement|HTMLIFrameElement|HTMLAudioElement|HTMLVideoElement|HTMLCanvasElement}
+ */
+export function isMedia(node) {
+	return /^(IMG|IFRAME|AUDIO|VIDEO|CANVAS)$/i.test(typeof node === 'string' ? node : node?.nodeName);
+}
+
+/**
+ * @description Check the node is a iframe tag
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLIFrameElement}
+ */
+export function isIFrame(node) {
+	return /^IFRAME$/i.test(typeof node === 'string' ? node : node?.nodeName);
+}
+
+/**
+ * @description Check the node is a figure tag
+ * @param {?Node|string} node The element or element name to check
+ * @returns {boolean}
+ */
+export function isFigure(node) {
+	return /^FIGURE$/i.test(typeof node === 'string' ? node : node?.nodeName);
+}
+
+/**
+ * @description Checks whether the given node is a content-less (void) HTML tag
+ * @param {?Node|string} node The element or element name to check
+ * @returns {boolean}
+ */
+export function isContentLess(node) {
+	return /^(BR|COLGROUP|COL|THEAD|TBODY|TFOOT|TR|AREA|BASE|EMBED|HR|IMG|INPUT|KEYGEN|LINK|META|PARAM|SOURCE|TRACK|WBR)$/i.test(typeof node === 'string' ? node : node?.nodeName);
+}
+
+/**
+ * @description Check the line element is empty.
+ * @param {Node} node "line" element node
+ * @returns {boolean}
+ */
+export function isEmptyLine(node) {
+	if (!node?.parentNode) return true;
+	const el = /** @type {HTMLElement} */ (node);
+	return !el.querySelector('IMG, IFRAME, AUDIO, VIDEO, CANVAS, TABLE') && el.children.length === 0 && check.isZeroWidth(el.textContent);
+}
+
+/**
+ * @description It is judged whether it is the edit region top div element or iframe's body tag.
+ * @param {?Node} node The node to check
+ * @returns {node is HTMLElement}
+ */
+export function isWysiwygFrame(node) {
+	return node?.nodeType === 1 && (domUtils.hasClass(node, 'se-wrapper-wysiwyg|sun-editor-carrier-wrapper') || /^BODY$/i.test(node.nodeName));
+}
+
+/**
+ * @description It is judged whether it is the contenteditable property is false.
+ * @param {?Node} node The node to check
+ * @returns {node is HTMLElement}
+ */
+export function isNonEditable(node) {
+	return node?.nodeType === 1 && /** @type {HTMLElement} */ (node).getAttribute('contenteditable') === 'false';
+}
+
+/**
+ * @description Check the span's attributes are empty.
+ * @param {?Node} node Element node
+ * @returns {boolean}
+ */
+export function isSpanWithoutAttr(node) {
+	if (node?.nodeType !== 1) return false;
+	const el = /** @type {HTMLElement} */ (node);
+	return /^SPAN$/i.test(el.nodeName) && !el.className && !el.style.cssText;
+}
+
+/**
+ * @description Compares the style and class for equal values.
+ * @param {Node} a Node to compare
+ * @param {Node} b Node to compare
+ * @returns {boolean} Returns true if both are text nodes.
+ */
+export function isSameAttributes(a, b) {
+	if (a.nodeType === 3 && b.nodeType === 3) return true;
+	if (a.nodeType === 3 || b.nodeType === 3) return false;
+
+	const aEl = /** @type {HTMLElement} */ (a);
+	const bEl = /** @type {HTMLElement} */ (b);
+
+	const style_a = aEl.style;
+	const style_b = bEl.style;
+	let compStyle = 0;
+
+	for (let i = 0, len = style_a.length; i < len; i++) {
+		if (style_a[style_a[i]] === style_b[style_a[i]]) compStyle++;
+	}
+
+	const class_a = aEl.classList;
+	const class_b = bEl.classList;
+	const wRegExp = RegExp;
+	let compClass = 0;
+
+	for (let i = 0, len = class_a.length; i < len; i++) {
+		if (wRegExp('(s|^)' + class_a[i] + '(s|$)').test(class_b.value)) compClass++;
+	}
+
+	return compStyle === style_b.length && compStyle === style_a.length && compClass === class_b.length && compClass === class_a.length;
+}
+
+/**
+ * @description It is judged whether it is the not checking node. (class="katex", "MathJax", "se-exclude-format")
+ * @param {Node} node The node to check
+ * @returns {node is HTMLElement}
+ */
+export function isExcludeFormat(node) {
+	return /(\s|^)(katex|MathJax|se-exclude-format)(\s|$)/.test(/** @type {HTMLElement} */ (node)?.className);
+}
+
+/**
+ * @description Checks for "__se__uneditable" in the class list.
+ * - Components with class "__se__uneditable" cannot be modified.
+ * @param {Node} node The element to check
+ * @returns {boolean}
+ */
+export function isUneditable(node) {
+	return domUtils.hasClass(node, '__se__uneditable');
+}
+
+/**
+ * @description Checks if element can't be easily enabled
+ * @param {Node} node Element to check for
+ * @returns {boolean}
+ */
+export function isImportantDisabled(node) {
+	return /** @type {HTMLElement} */ (node).hasAttribute('data-important-disabled');
+}
+
+const check = {
+	isZeroWidth,
+	isEdgePoint,
+	isText,
+	isElement,
+	isInputElement,
+	isButtonElement,
+	isList,
+	isListCell,
+	isTable,
+	isTableElements,
+	isTableCell,
+	isTableRow,
+	isBreak,
+	isAnchor,
+	isMedia,
+	isIFrame,
+	isFigure,
+	isContentLess,
+	isEmptyLine,
+	isWysiwygFrame,
+	isNonEditable,
+	isSpanWithoutAttr,
+	isSameAttributes,
+	isExcludeFormat,
+	isUneditable,
+	isImportantDisabled
+};
+
+export default check;