';\n }\n return node;\n };\n const resolveCaretPositionBookmark = (dom, bookmark) => {\n const startPos = Optional.from(resolve$1(dom.getRoot(), bookmark.start));\n const endPos = Optional.from(resolve$1(dom.getRoot(), bookmark.end));\n return lift2(startPos, endPos, (start, end) => {\n const range = dom.createRng();\n range.setStart(start.container(), start.offset());\n range.setEnd(end.container(), end.offset());\n return {\n range,\n forward: isForwardBookmark(bookmark)\n };\n });\n };\n const insertZwsp = (node, rng) => {\n var _a;\n const doc = (_a = node.ownerDocument) !== null && _a !== void 0 ? _a : document;\n const textNode = doc.createTextNode(ZWSP$1);\n node.appendChild(textNode);\n rng.setStart(textNode, 0);\n rng.setEnd(textNode, 0);\n };\n const isEmpty$1 = node => !node.hasChildNodes();\n const tryFindRangePosition = (node, rng) => lastPositionIn(node).fold(never, pos => {\n rng.setStart(pos.container(), pos.offset());\n rng.setEnd(pos.container(), pos.offset());\n return true;\n });\n const padEmptyCaretContainer = (root, node, rng) => {\n if (isEmpty$1(node) && getParentCaretContainer(root, node)) {\n insertZwsp(node, rng);\n return true;\n } else {\n return false;\n }\n };\n const setEndPoint = (dom, start, bookmark, rng) => {\n const point = bookmark[start ? 'start' : 'end'];\n const root = dom.getRoot();\n if (point) {\n let node = root;\n let offset = point[0];\n for (let i = point.length - 1; node && i >= 1; i--) {\n const children = node.childNodes;\n if (padEmptyCaretContainer(root, node, rng)) {\n return true;\n }\n if (point[i] > children.length - 1) {\n if (padEmptyCaretContainer(root, node, rng)) {\n return true;\n }\n return tryFindRangePosition(node, rng);\n }\n node = children[point[i]];\n }\n if (isText$a(node)) {\n offset = Math.min(point[0], node.data.length);\n }\n if (isElement$6(node)) {\n offset = Math.min(point[0], node.childNodes.length);\n }\n if (start) {\n rng.setStart(node, offset);\n } else {\n rng.setEnd(node, offset);\n }\n }\n return true;\n };\n const isValidTextNode = node => isText$a(node) && node.data.length > 0;\n const restoreEndPoint = (dom, suffix, bookmark) => {\n const marker = dom.get(bookmark.id + '_' + suffix);\n const markerParent = marker === null || marker === void 0 ? void 0 : marker.parentNode;\n const keep = bookmark.keep;\n if (marker && markerParent) {\n let container;\n let offset;\n if (suffix === 'start') {\n if (!keep) {\n container = markerParent;\n offset = dom.nodeIndex(marker);\n } else {\n if (marker.hasChildNodes()) {\n container = marker.firstChild;\n offset = 1;\n } else if (isValidTextNode(marker.nextSibling)) {\n container = marker.nextSibling;\n offset = 0;\n } else if (isValidTextNode(marker.previousSibling)) {\n container = marker.previousSibling;\n offset = marker.previousSibling.data.length;\n } else {\n container = markerParent;\n offset = dom.nodeIndex(marker) + 1;\n }\n }\n } else {\n if (!keep) {\n container = markerParent;\n offset = dom.nodeIndex(marker);\n } else {\n if (marker.hasChildNodes()) {\n container = marker.firstChild;\n offset = 1;\n } else if (isValidTextNode(marker.previousSibling)) {\n container = marker.previousSibling;\n offset = marker.previousSibling.data.length;\n } else {\n container = markerParent;\n offset = dom.nodeIndex(marker);\n }\n }\n }\n if (!keep) {\n const prev = marker.previousSibling;\n const next = marker.nextSibling;\n Tools.each(Tools.grep(marker.childNodes), node => {\n if (isText$a(node)) {\n node.data = node.data.replace(/\\uFEFF/g, '');\n }\n });\n let otherMarker;\n while (otherMarker = dom.get(bookmark.id + '_' + suffix)) {\n dom.remove(otherMarker, true);\n }\n if (isText$a(next) && isText$a(prev) && !Env.browser.isOpera()) {\n const idx = prev.data.length;\n prev.appendData(next.data);\n dom.remove(next);\n container = prev;\n offset = idx;\n }\n }\n return Optional.some(CaretPosition(container, offset));\n } else {\n return Optional.none();\n }\n };\n const resolvePaths = (dom, bookmark) => {\n const range = dom.createRng();\n if (setEndPoint(dom, true, bookmark, range) && setEndPoint(dom, false, bookmark, range)) {\n return Optional.some({\n range,\n forward: isForwardBookmark(bookmark)\n });\n } else {\n return Optional.none();\n }\n };\n const resolveId = (dom, bookmark) => {\n const startPos = restoreEndPoint(dom, 'start', bookmark);\n const endPos = restoreEndPoint(dom, 'end', bookmark);\n return lift2(startPos, endPos.or(startPos), (spos, epos) => {\n const range = dom.createRng();\n range.setStart(addBogus(dom, spos.container()), spos.offset());\n range.setEnd(addBogus(dom, epos.container()), epos.offset());\n return {\n range,\n forward: isForwardBookmark(bookmark)\n };\n });\n };\n const resolveIndex = (dom, bookmark) => Optional.from(dom.select(bookmark.name)[bookmark.index]).map(elm => {\n const range = dom.createRng();\n range.selectNode(elm);\n return {\n range,\n forward: true\n };\n });\n const resolve = (selection, bookmark) => {\n const dom = selection.dom;\n if (bookmark) {\n if (isPathBookmark(bookmark)) {\n return resolvePaths(dom, bookmark);\n } else if (isStringPathBookmark(bookmark)) {\n return resolveCaretPositionBookmark(dom, bookmark);\n } else if (isIdBookmark(bookmark)) {\n return resolveId(dom, bookmark);\n } else if (isIndexBookmark(bookmark)) {\n return resolveIndex(dom, bookmark);\n } else if (isRangeBookmark(bookmark)) {\n return Optional.some({\n range: bookmark.rng,\n forward: isForwardBookmark(bookmark)\n });\n }\n }\n return Optional.none();\n };\n\n const getBookmark$1 = (selection, type, normalized) => {\n return getBookmark$2(selection, type, normalized);\n };\n const moveToBookmark = (selection, bookmark) => {\n resolve(selection, bookmark).each(({range, forward}) => {\n selection.setRng(range, forward);\n });\n };\n const isBookmarkNode$1 = node => {\n return isElement$6(node) && node.tagName === 'SPAN' && node.getAttribute('data-mce-type') === 'bookmark';\n };\n\n const is = expected => actual => expected === actual;\n const isNbsp = is(nbsp);\n const isWhiteSpace = chr => chr !== '' && ' \\f\\n\\r\\t\\x0B'.indexOf(chr) !== -1;\n const isContent = chr => !isWhiteSpace(chr) && !isNbsp(chr) && !isZwsp$1(chr);\n\n const hexColour = value => ({ value });\n const toHex = component => {\n const hex = component.toString(16);\n return (hex.length === 1 ? '0' + hex : hex).toUpperCase();\n };\n const fromRgba = rgbaColour => {\n const value = toHex(rgbaColour.red) + toHex(rgbaColour.green) + toHex(rgbaColour.blue);\n return hexColour(value);\n };\n\n const rgbRegex = /^\\s*rgb\\s*\\(\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(\\d+)\\s*\\)\\s*$/i;\n const rgbaRegex = /^\\s*rgba\\s*\\(\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(\\d?(?:\\.\\d+)?)\\s*\\)\\s*$/i;\n const rgbaColour = (red, green, blue, alpha) => ({\n red,\n green,\n blue,\n alpha\n });\n const fromStringValues = (red, green, blue, alpha) => {\n const r = parseInt(red, 10);\n const g = parseInt(green, 10);\n const b = parseInt(blue, 10);\n const a = parseFloat(alpha);\n return rgbaColour(r, g, b, a);\n };\n const fromString = rgbaString => {\n if (rgbaString === 'transparent') {\n return Optional.some(rgbaColour(0, 0, 0, 0));\n }\n const rgbMatch = rgbRegex.exec(rgbaString);\n if (rgbMatch !== null) {\n return Optional.some(fromStringValues(rgbMatch[1], rgbMatch[2], rgbMatch[3], '1'));\n }\n const rgbaMatch = rgbaRegex.exec(rgbaString);\n if (rgbaMatch !== null) {\n return Optional.some(fromStringValues(rgbaMatch[1], rgbaMatch[2], rgbaMatch[3], rgbaMatch[4]));\n }\n return Optional.none();\n };\n\n const rgbaToHexString = color => fromString(color).map(fromRgba).map(h => '#' + h.value).getOr(color);\n\n const getRanges$1 = selection => {\n const ranges = [];\n if (selection) {\n for (let i = 0; i < selection.rangeCount; i++) {\n ranges.push(selection.getRangeAt(i));\n }\n }\n return ranges;\n };\n const getSelectedNodes = ranges => {\n return bind$3(ranges, range => {\n const node = getSelectedNode(range);\n return node ? [SugarElement.fromDom(node)] : [];\n });\n };\n const hasMultipleRanges = selection => {\n return getRanges$1(selection).length > 1;\n };\n\n const getCellsFromRanges = ranges => filter$5(getSelectedNodes(ranges), isTableCell$2);\n const getCellsFromElement = elm => descendants(elm, 'td[data-mce-selected],th[data-mce-selected]');\n const getCellsFromElementOrRanges = (ranges, element) => {\n const selectedCells = getCellsFromElement(element);\n return selectedCells.length > 0 ? selectedCells : getCellsFromRanges(ranges);\n };\n const getCellsFromEditor = editor => getCellsFromElementOrRanges(getRanges$1(editor.selection.getSel()), SugarElement.fromDom(editor.getBody()));\n const getClosestTable = (cell, isRoot) => ancestor$2(cell, 'table', isRoot);\n\n const getStartNode = rng => {\n const sc = rng.startContainer, so = rng.startOffset;\n if (isText$a(sc)) {\n return so === 0 ? Optional.some(SugarElement.fromDom(sc)) : Optional.none();\n } else {\n return Optional.from(sc.childNodes[so]).map(SugarElement.fromDom);\n }\n };\n const getEndNode = rng => {\n const ec = rng.endContainer, eo = rng.endOffset;\n if (isText$a(ec)) {\n return eo === ec.data.length ? Optional.some(SugarElement.fromDom(ec)) : Optional.none();\n } else {\n return Optional.from(ec.childNodes[eo - 1]).map(SugarElement.fromDom);\n }\n };\n const getFirstChildren = node => {\n return firstChild(node).fold(constant([node]), child => {\n return [node].concat(getFirstChildren(child));\n });\n };\n const getLastChildren = node => {\n return lastChild(node).fold(constant([node]), child => {\n if (name(child) === 'br') {\n return prevSibling(child).map(sibling => {\n return [node].concat(getLastChildren(sibling));\n }).getOr([]);\n } else {\n return [node].concat(getLastChildren(child));\n }\n });\n };\n const hasAllContentsSelected = (elm, rng) => {\n return lift2(getStartNode(rng), getEndNode(rng), (startNode, endNode) => {\n const start = find$2(getFirstChildren(elm), curry(eq, startNode));\n const end = find$2(getLastChildren(elm), curry(eq, endNode));\n return start.isSome() && end.isSome();\n }).getOr(false);\n };\n const moveEndPoint = (dom, rng, node, start) => {\n const root = node;\n const walker = new DomTreeWalker(node, root);\n const moveCaretBeforeOnEnterElementsMap = filter$4(dom.schema.getMoveCaretBeforeOnEnterElements(), (_, name) => !contains$2([\n 'td',\n 'th',\n 'table'\n ], name.toLowerCase()));\n let currentNode = node;\n do {\n if (isText$a(currentNode) && Tools.trim(currentNode.data).length !== 0) {\n if (start) {\n rng.setStart(currentNode, 0);\n } else {\n rng.setEnd(currentNode, currentNode.data.length);\n }\n return;\n }\n if (moveCaretBeforeOnEnterElementsMap[currentNode.nodeName]) {\n if (start) {\n rng.setStartBefore(currentNode);\n } else {\n if (currentNode.nodeName === 'BR') {\n rng.setEndBefore(currentNode);\n } else {\n rng.setEndAfter(currentNode);\n }\n }\n return;\n }\n } while (currentNode = start ? walker.next() : walker.prev());\n if (root.nodeName === 'BODY') {\n if (start) {\n rng.setStart(root, 0);\n } else {\n rng.setEnd(root, root.childNodes.length);\n }\n }\n };\n const hasAnyRanges = editor => {\n const sel = editor.selection.getSel();\n return isNonNullable(sel) && sel.rangeCount > 0;\n };\n const runOnRanges = (editor, executor) => {\n const fakeSelectionNodes = getCellsFromEditor(editor);\n if (fakeSelectionNodes.length > 0) {\n each$e(fakeSelectionNodes, elem => {\n const node = elem.dom;\n const fakeNodeRng = editor.dom.createRng();\n fakeNodeRng.setStartBefore(node);\n fakeNodeRng.setEndAfter(node);\n executor(fakeNodeRng, true);\n });\n } else {\n executor(editor.selection.getRng(), false);\n }\n };\n const preserve = (selection, fillBookmark, executor) => {\n const bookmark = getPersistentBookmark(selection, fillBookmark);\n executor(bookmark);\n selection.moveToBookmark(bookmark);\n };\n\n const isNode = node => isNumber(node === null || node === void 0 ? void 0 : node.nodeType);\n const isElementNode$1 = node => isElement$6(node) && !isBookmarkNode$1(node) && !isCaretNode(node) && !isBogus$2(node);\n const isElementDirectlySelected = (dom, node) => {\n if (isElementNode$1(node) && !/^(TD|TH)$/.test(node.nodeName)) {\n const selectedAttr = dom.getAttrib(node, 'data-mce-selected');\n const value = parseInt(selectedAttr, 10);\n return !isNaN(value) && value > 0;\n } else {\n return false;\n }\n };\n const isEditable$3 = elm => elm.isContentEditable === true;\n const preserveSelection = (editor, action, shouldMoveStart) => {\n const {selection, dom} = editor;\n const selectedNodeBeforeAction = selection.getNode();\n const isSelectedBeforeNodeNoneditable = isContentEditableFalse$a(selectedNodeBeforeAction);\n preserve(selection, true, () => {\n action();\n });\n const isBeforeNodeStillNoneditable = isSelectedBeforeNodeNoneditable && isContentEditableFalse$a(selectedNodeBeforeAction);\n if (isBeforeNodeStillNoneditable && dom.isChildOf(selectedNodeBeforeAction, editor.getBody())) {\n editor.selection.select(selectedNodeBeforeAction);\n } else if (shouldMoveStart(selection.getStart())) {\n moveStartToNearestText(dom, selection);\n }\n };\n const moveStartToNearestText = (dom, selection) => {\n var _a, _b;\n const rng = selection.getRng();\n const {startContainer, startOffset} = rng;\n const selectedNode = selection.getNode();\n if (isElementDirectlySelected(dom, selectedNode)) {\n return;\n }\n if (isElement$6(startContainer)) {\n const nodes = startContainer.childNodes;\n const root = dom.getRoot();\n let walker;\n if (startOffset < nodes.length) {\n const startNode = nodes[startOffset];\n walker = new DomTreeWalker(startNode, (_a = dom.getParent(startNode, dom.isBlock)) !== null && _a !== void 0 ? _a : root);\n } else {\n const startNode = nodes[nodes.length - 1];\n walker = new DomTreeWalker(startNode, (_b = dom.getParent(startNode, dom.isBlock)) !== null && _b !== void 0 ? _b : root);\n walker.next(true);\n }\n for (let node = walker.current(); node; node = walker.next()) {\n if (dom.getContentEditable(node) === 'false') {\n return;\n } else if (isText$a(node) && !isWhiteSpaceNode$1(node)) {\n rng.setStart(node, 0);\n selection.setRng(rng);\n return;\n }\n }\n }\n };\n const getNonWhiteSpaceSibling = (node, next, inc) => {\n if (node) {\n const nextName = next ? 'nextSibling' : 'previousSibling';\n for (node = inc ? node : node[nextName]; node; node = node[nextName]) {\n if (isElement$6(node) || !isWhiteSpaceNode$1(node)) {\n return node;\n }\n }\n }\n return undefined;\n };\n const isTextBlock$1 = (schema, node) => !!schema.getTextBlockElements()[node.nodeName.toLowerCase()] || isTransparentBlock(schema, node);\n const isValid = (ed, parent, child) => {\n return ed.schema.isValidChild(parent, child);\n };\n const isWhiteSpaceNode$1 = (node, allowSpaces = false) => {\n if (isNonNullable(node) && isText$a(node)) {\n const data = allowSpaces ? node.data.replace(/ /g, '\\xA0') : node.data;\n return isWhitespaceText(data);\n } else {\n return false;\n }\n };\n const isEmptyTextNode$1 = node => {\n return isNonNullable(node) && isText$a(node) && node.length === 0;\n };\n const isWrapNoneditableTarget = (editor, node) => {\n const baseDataSelector = '[data-mce-cef-wrappable]';\n const formatNoneditableSelector = getFormatNoneditableSelector(editor);\n const selector = isEmpty$3(formatNoneditableSelector) ? baseDataSelector : `${ baseDataSelector },${ formatNoneditableSelector }`;\n return is$1(SugarElement.fromDom(node), selector);\n };\n const isWrappableNoneditable = (editor, node) => {\n const dom = editor.dom;\n return isElementNode$1(node) && dom.getContentEditable(node) === 'false' && isWrapNoneditableTarget(editor, node) && dom.select('[contenteditable=\"true\"]', node).length === 0;\n };\n const replaceVars = (value, vars) => {\n if (isFunction(value)) {\n return value(vars);\n } else if (isNonNullable(vars)) {\n value = value.replace(/%(\\w+)/g, (str, name) => {\n return vars[name] || str;\n });\n }\n return value;\n };\n const isEq$5 = (str1, str2) => {\n str1 = str1 || '';\n str2 = str2 || '';\n str1 = '' + (str1.nodeName || str1);\n str2 = '' + (str2.nodeName || str2);\n return str1.toLowerCase() === str2.toLowerCase();\n };\n const normalizeStyleValue = (value, name) => {\n if (isNullable(value)) {\n return null;\n } else {\n let strValue = String(value);\n if (name === 'color' || name === 'backgroundColor') {\n strValue = rgbaToHexString(strValue);\n }\n if (name === 'fontWeight' && value === 700) {\n strValue = 'bold';\n }\n if (name === 'fontFamily') {\n strValue = strValue.replace(/[\\'\\\"]/g, '').replace(/,\\s+/g, ',');\n }\n return strValue;\n }\n };\n const getStyle = (dom, node, name) => {\n const style = dom.getStyle(node, name);\n return normalizeStyleValue(style, name);\n };\n const getTextDecoration = (dom, node) => {\n let decoration;\n dom.getParent(node, n => {\n if (isElement$6(n)) {\n decoration = dom.getStyle(n, 'text-decoration');\n return !!decoration && decoration !== 'none';\n } else {\n return false;\n }\n });\n return decoration;\n };\n const getParents$2 = (dom, node, selector) => {\n return dom.getParents(node, selector, dom.getRoot());\n };\n const isFormatPredicate = (editor, formatName, predicate) => {\n const formats = editor.formatter.get(formatName);\n return isNonNullable(formats) && exists(formats, predicate);\n };\n const isVariableFormatName = (editor, formatName) => {\n const hasVariableValues = format => {\n const isVariableValue = val => isFunction(val) || val.length > 1 && val.charAt(0) === '%';\n return exists([\n 'styles',\n 'attributes'\n ], key => get$a(format, key).exists(field => {\n const fieldValues = isArray$1(field) ? field : values(field);\n return exists(fieldValues, isVariableValue);\n }));\n };\n return isFormatPredicate(editor, formatName, hasVariableValues);\n };\n const areSimilarFormats = (editor, formatName, otherFormatName) => {\n const validKeys = [\n 'inline',\n 'block',\n 'selector',\n 'attributes',\n 'styles',\n 'classes'\n ];\n const filterObj = format => filter$4(format, (_, key) => exists(validKeys, validKey => validKey === key));\n return isFormatPredicate(editor, formatName, fmt1 => {\n const filteredFmt1 = filterObj(fmt1);\n return isFormatPredicate(editor, otherFormatName, fmt2 => {\n const filteredFmt2 = filterObj(fmt2);\n return equal$1(filteredFmt1, filteredFmt2);\n });\n });\n };\n const isBlockFormat = format => hasNonNullableKey(format, 'block');\n const isWrappingBlockFormat = format => isBlockFormat(format) && format.wrapper === true;\n const isNonWrappingBlockFormat = format => isBlockFormat(format) && format.wrapper !== true;\n const isSelectorFormat = format => hasNonNullableKey(format, 'selector');\n const isInlineFormat = format => hasNonNullableKey(format, 'inline');\n const isMixedFormat = format => isSelectorFormat(format) && isInlineFormat(format) && is$2(get$a(format, 'mixed'), true);\n const shouldExpandToSelector = format => isSelectorFormat(format) && format.expand !== false && !isInlineFormat(format);\n\n const isBookmarkNode = isBookmarkNode$1;\n const getParents$1 = getParents$2;\n const isWhiteSpaceNode = isWhiteSpaceNode$1;\n const isTextBlock = isTextBlock$1;\n const isBogusBr = node => {\n return isBr$6(node) && node.getAttribute('data-mce-bogus') && !node.nextSibling;\n };\n const findParentContentEditable = (dom, node) => {\n let parent = node;\n while (parent) {\n if (isElement$6(parent) && dom.getContentEditable(parent)) {\n return dom.getContentEditable(parent) === 'false' ? parent : node;\n }\n parent = parent.parentNode;\n }\n return node;\n };\n const walkText = (start, node, offset, predicate) => {\n const str = node.data;\n if (start) {\n for (let i = offset; i > 0; i--) {\n if (predicate(str.charAt(i - 1))) {\n return i;\n }\n }\n } else {\n for (let i = offset; i < str.length; i++) {\n if (predicate(str.charAt(i))) {\n return i;\n }\n }\n }\n return -1;\n };\n const findSpace = (start, node, offset) => walkText(start, node, offset, c => isNbsp(c) || isWhiteSpace(c));\n const findContent = (start, node, offset) => walkText(start, node, offset, isContent);\n const findWordEndPoint = (dom, body, container, offset, start, includeTrailingSpaces) => {\n let lastTextNode;\n const rootNode = dom.getParent(container, dom.isBlock) || body;\n const walk = (container, offset, pred) => {\n const textSeeker = TextSeeker(dom);\n const walker = start ? textSeeker.backwards : textSeeker.forwards;\n return Optional.from(walker(container, offset, (text, textOffset) => {\n if (isBookmarkNode(text.parentNode)) {\n return -1;\n } else {\n lastTextNode = text;\n return pred(start, text, textOffset);\n }\n }, rootNode));\n };\n const spaceResult = walk(container, offset, findSpace);\n return spaceResult.bind(result => includeTrailingSpaces ? walk(result.container, result.offset + (start ? -1 : 0), findContent) : Optional.some(result)).orThunk(() => lastTextNode ? Optional.some({\n container: lastTextNode,\n offset: start ? 0 : lastTextNode.length\n }) : Optional.none());\n };\n const findSelectorEndPoint = (dom, formatList, rng, container, siblingName) => {\n const sibling = container[siblingName];\n if (isText$a(container) && isEmpty$3(container.data) && sibling) {\n container = sibling;\n }\n const parents = getParents$1(dom, container);\n for (let i = 0; i < parents.length; i++) {\n for (let y = 0; y < formatList.length; y++) {\n const curFormat = formatList[y];\n if (isNonNullable(curFormat.collapsed) && curFormat.collapsed !== rng.collapsed) {\n continue;\n }\n if (isSelectorFormat(curFormat) && dom.is(parents[i], curFormat.selector)) {\n return parents[i];\n }\n }\n }\n return container;\n };\n const findBlockEndPoint = (dom, formatList, container, siblingName) => {\n var _a;\n let node = container;\n const root = dom.getRoot();\n const format = formatList[0];\n if (isBlockFormat(format)) {\n node = format.wrapper ? null : dom.getParent(container, format.block, root);\n }\n if (!node) {\n const scopeRoot = (_a = dom.getParent(container, 'LI,TD,TH')) !== null && _a !== void 0 ? _a : root;\n node = dom.getParent(isText$a(container) ? container.parentNode : container, node => node !== root && isTextBlock(dom.schema, node), scopeRoot);\n }\n if (node && isBlockFormat(format) && format.wrapper) {\n node = getParents$1(dom, node, 'ul,ol').reverse()[0] || node;\n }\n if (!node) {\n node = container;\n while (node && node[siblingName] && !dom.isBlock(node[siblingName])) {\n node = node[siblingName];\n if (isEq$5(node, 'br')) {\n break;\n }\n }\n }\n return node || container;\n };\n const isAtBlockBoundary$1 = (dom, root, container, siblingName) => {\n const parent = container.parentNode;\n if (isNonNullable(container[siblingName])) {\n return false;\n } else if (parent === root || isNullable(parent) || dom.isBlock(parent)) {\n return true;\n } else {\n return isAtBlockBoundary$1(dom, root, parent, siblingName);\n }\n };\n const findParentContainer = (dom, formatList, container, offset, start) => {\n let parent = container;\n const siblingName = start ? 'previousSibling' : 'nextSibling';\n const root = dom.getRoot();\n if (isText$a(container) && !isWhiteSpaceNode(container)) {\n if (start ? offset > 0 : offset < container.data.length) {\n return container;\n }\n }\n while (parent) {\n if (!formatList[0].block_expand && dom.isBlock(parent)) {\n return parent;\n }\n for (let sibling = parent[siblingName]; sibling; sibling = sibling[siblingName]) {\n const allowSpaces = isText$a(sibling) && !isAtBlockBoundary$1(dom, root, sibling, siblingName);\n if (!isBookmarkNode(sibling) && !isBogusBr(sibling) && !isWhiteSpaceNode(sibling, allowSpaces)) {\n return parent;\n }\n }\n if (parent === root || parent.parentNode === root) {\n container = parent;\n break;\n }\n parent = parent.parentNode;\n }\n return container;\n };\n const isSelfOrParentBookmark = container => isBookmarkNode(container.parentNode) || isBookmarkNode(container);\n const expandRng = (dom, rng, formatList, includeTrailingSpace = false) => {\n let {startContainer, startOffset, endContainer, endOffset} = rng;\n const format = formatList[0];\n if (isElement$6(startContainer) && startContainer.hasChildNodes()) {\n startContainer = getNode$1(startContainer, startOffset);\n if (isText$a(startContainer)) {\n startOffset = 0;\n }\n }\n if (isElement$6(endContainer) && endContainer.hasChildNodes()) {\n endContainer = getNode$1(endContainer, rng.collapsed ? endOffset : endOffset - 1);\n if (isText$a(endContainer)) {\n endOffset = endContainer.data.length;\n }\n }\n startContainer = findParentContentEditable(dom, startContainer);\n endContainer = findParentContentEditable(dom, endContainer);\n if (isSelfOrParentBookmark(startContainer)) {\n startContainer = isBookmarkNode(startContainer) ? startContainer : startContainer.parentNode;\n if (rng.collapsed) {\n startContainer = startContainer.previousSibling || startContainer;\n } else {\n startContainer = startContainer.nextSibling || startContainer;\n }\n if (isText$a(startContainer)) {\n startOffset = rng.collapsed ? startContainer.length : 0;\n }\n }\n if (isSelfOrParentBookmark(endContainer)) {\n endContainer = isBookmarkNode(endContainer) ? endContainer : endContainer.parentNode;\n if (rng.collapsed) {\n endContainer = endContainer.nextSibling || endContainer;\n } else {\n endContainer = endContainer.previousSibling || endContainer;\n }\n if (isText$a(endContainer)) {\n endOffset = rng.collapsed ? 0 : endContainer.length;\n }\n }\n if (rng.collapsed) {\n const startPoint = findWordEndPoint(dom, dom.getRoot(), startContainer, startOffset, true, includeTrailingSpace);\n startPoint.each(({container, offset}) => {\n startContainer = container;\n startOffset = offset;\n });\n const endPoint = findWordEndPoint(dom, dom.getRoot(), endContainer, endOffset, false, includeTrailingSpace);\n endPoint.each(({container, offset}) => {\n endContainer = container;\n endOffset = offset;\n });\n }\n if (isInlineFormat(format) || format.block_expand) {\n if (!isInlineFormat(format) || (!isText$a(startContainer) || startOffset === 0)) {\n startContainer = findParentContainer(dom, formatList, startContainer, startOffset, true);\n }\n if (!isInlineFormat(format) || (!isText$a(endContainer) || endOffset === endContainer.data.length)) {\n endContainer = findParentContainer(dom, formatList, endContainer, endOffset, false);\n }\n }\n if (shouldExpandToSelector(format)) {\n startContainer = findSelectorEndPoint(dom, formatList, rng, startContainer, 'previousSibling');\n endContainer = findSelectorEndPoint(dom, formatList, rng, endContainer, 'nextSibling');\n }\n if (isBlockFormat(format) || isSelectorFormat(format)) {\n startContainer = findBlockEndPoint(dom, formatList, startContainer, 'previousSibling');\n endContainer = findBlockEndPoint(dom, formatList, endContainer, 'nextSibling');\n if (isBlockFormat(format)) {\n if (!dom.isBlock(startContainer)) {\n startContainer = findParentContainer(dom, formatList, startContainer, startOffset, true);\n }\n if (!dom.isBlock(endContainer)) {\n endContainer = findParentContainer(dom, formatList, endContainer, endOffset, false);\n }\n }\n }\n if (isElement$6(startContainer) && startContainer.parentNode) {\n startOffset = dom.nodeIndex(startContainer);\n startContainer = startContainer.parentNode;\n }\n if (isElement$6(endContainer) && endContainer.parentNode) {\n endOffset = dom.nodeIndex(endContainer) + 1;\n endContainer = endContainer.parentNode;\n }\n return {\n startContainer,\n startOffset,\n endContainer,\n endOffset\n };\n };\n\n const walk$3 = (dom, rng, callback) => {\n var _a;\n const startOffset = rng.startOffset;\n const startContainer = getNode$1(rng.startContainer, startOffset);\n const endOffset = rng.endOffset;\n const endContainer = getNode$1(rng.endContainer, endOffset - 1);\n const exclude = nodes => {\n const firstNode = nodes[0];\n if (isText$a(firstNode) && firstNode === startContainer && startOffset >= firstNode.data.length) {\n nodes.splice(0, 1);\n }\n const lastNode = nodes[nodes.length - 1];\n if (endOffset === 0 && nodes.length > 0 && lastNode === endContainer && isText$a(lastNode)) {\n nodes.splice(nodes.length - 1, 1);\n }\n return nodes;\n };\n const collectSiblings = (node, name, endNode) => {\n const siblings = [];\n for (; node && node !== endNode; node = node[name]) {\n siblings.push(node);\n }\n return siblings;\n };\n const findEndPoint = (node, root) => dom.getParent(node, node => node.parentNode === root, root);\n const walkBoundary = (startNode, endNode, next) => {\n const siblingName = next ? 'nextSibling' : 'previousSibling';\n for (let node = startNode, parent = node.parentNode; node && node !== endNode; node = parent) {\n parent = node.parentNode;\n const siblings = collectSiblings(node === startNode ? node : node[siblingName], siblingName);\n if (siblings.length) {\n if (!next) {\n siblings.reverse();\n }\n callback(exclude(siblings));\n }\n }\n };\n if (startContainer === endContainer) {\n return callback(exclude([startContainer]));\n }\n const ancestor = (_a = dom.findCommonAncestor(startContainer, endContainer)) !== null && _a !== void 0 ? _a : dom.getRoot();\n if (dom.isChildOf(startContainer, endContainer)) {\n return walkBoundary(startContainer, ancestor, true);\n }\n if (dom.isChildOf(endContainer, startContainer)) {\n return walkBoundary(endContainer, ancestor);\n }\n const startPoint = findEndPoint(startContainer, ancestor) || startContainer;\n const endPoint = findEndPoint(endContainer, ancestor) || endContainer;\n walkBoundary(startContainer, startPoint, true);\n const siblings = collectSiblings(startPoint === startContainer ? startPoint : startPoint.nextSibling, 'nextSibling', endPoint === endContainer ? endPoint.nextSibling : endPoint);\n if (siblings.length) {\n callback(exclude(siblings));\n }\n walkBoundary(endContainer, endPoint);\n };\n\n const validBlocks = [\n 'pre[class*=language-][contenteditable=\"false\"]',\n 'figure.image',\n 'div[data-ephox-embed-iri]',\n 'div.tiny-pageembed',\n 'div.mce-toc',\n 'div[data-mce-toc]'\n ];\n const isZeroWidth = elem => isText$b(elem) && get$3(elem) === ZWSP$1;\n const context = (editor, elem, wrapName, nodeName) => parent(elem).fold(() => 'skipping', parent => {\n if (nodeName === 'br' || isZeroWidth(elem)) {\n return 'valid';\n } else if (isAnnotation(elem)) {\n return 'existing';\n } else if (isCaretNode(elem.dom)) {\n return 'caret';\n } else if (exists(validBlocks, selector => is$1(elem, selector))) {\n return 'valid-block';\n } else if (!isValid(editor, wrapName, nodeName) || !isValid(editor, name(parent), wrapName)) {\n return 'invalid-child';\n } else {\n return 'valid';\n }\n });\n\n const applyWordGrab = (editor, rng) => {\n const r = expandRng(editor.dom, rng, [{ inline: 'span' }]);\n rng.setStart(r.startContainer, r.startOffset);\n rng.setEnd(r.endContainer, r.endOffset);\n editor.selection.setRng(rng);\n };\n const applyAnnotation = (elem, masterUId, data, annotationName, decorate, directAnnotation) => {\n const {uid = masterUId, ...otherData} = data;\n add$2(elem, annotation());\n set$2(elem, `${ dataAnnotationId() }`, uid);\n set$2(elem, `${ dataAnnotation() }`, annotationName);\n const {attributes = {}, classes = []} = decorate(uid, otherData);\n setAll$1(elem, attributes);\n add(elem, classes);\n if (directAnnotation) {\n if (classes.length > 0) {\n set$2(elem, `${ dataAnnotationClasses() }`, classes.join(','));\n }\n const attributeNames = keys(attributes);\n if (attributeNames.length > 0) {\n set$2(elem, `${ dataAnnotationAttributes() }`, attributeNames.join(','));\n }\n }\n };\n const removeDirectAnnotation = elem => {\n remove$8(elem, annotation());\n remove$b(elem, `${ dataAnnotationId() }`);\n remove$b(elem, `${ dataAnnotation() }`);\n remove$b(elem, `${ dataAnnotationActive() }`);\n const customAttrNames = getOpt(elem, `${ dataAnnotationAttributes() }`).map(names => names.split(',')).getOr([]);\n const customClasses = getOpt(elem, `${ dataAnnotationClasses() }`).map(names => names.split(',')).getOr([]);\n each$e(customAttrNames, name => remove$b(elem, name));\n remove$5(elem, customClasses);\n remove$b(elem, `${ dataAnnotationClasses() }`);\n remove$b(elem, `${ dataAnnotationAttributes() }`);\n };\n const makeAnnotation = (eDoc, uid, data, annotationName, decorate) => {\n const master = SugarElement.fromTag('span', eDoc);\n applyAnnotation(master, uid, data, annotationName, decorate, false);\n return master;\n };\n const annotate = (editor, rng, uid, annotationName, decorate, data) => {\n const newWrappers = [];\n const master = makeAnnotation(editor.getDoc(), uid, data, annotationName, decorate);\n const wrapper = value$2();\n const finishWrapper = () => {\n wrapper.clear();\n };\n const getOrOpenWrapper = () => wrapper.get().getOrThunk(() => {\n const nu = shallow$1(master);\n newWrappers.push(nu);\n wrapper.set(nu);\n return nu;\n });\n const processElements = elems => {\n each$e(elems, processElement);\n };\n const processElement = elem => {\n const ctx = context(editor, elem, 'span', name(elem));\n switch (ctx) {\n case 'invalid-child': {\n finishWrapper();\n const children = children$1(elem);\n processElements(children);\n finishWrapper();\n break;\n }\n case 'valid-block': {\n finishWrapper();\n applyAnnotation(elem, uid, data, annotationName, decorate, true);\n break;\n }\n case 'valid': {\n const w = getOrOpenWrapper();\n wrap$2(elem, w);\n break;\n }\n }\n };\n const processNodes = nodes => {\n const elems = map$3(nodes, SugarElement.fromDom);\n processElements(elems);\n };\n walk$3(editor.dom, rng, nodes => {\n finishWrapper();\n processNodes(nodes);\n });\n return newWrappers;\n };\n const annotateWithBookmark = (editor, name, settings, data) => {\n editor.undoManager.transact(() => {\n const selection = editor.selection;\n const initialRng = selection.getRng();\n const hasFakeSelection = getCellsFromEditor(editor).length > 0;\n const masterUid = generate$1('mce-annotation');\n if (initialRng.collapsed && !hasFakeSelection) {\n applyWordGrab(editor, initialRng);\n }\n if (selection.getRng().collapsed && !hasFakeSelection) {\n const wrapper = makeAnnotation(editor.getDoc(), masterUid, data, name, settings.decorate);\n set(wrapper, nbsp);\n selection.getRng().insertNode(wrapper.dom);\n selection.select(wrapper.dom);\n } else {\n preserve(selection, false, () => {\n runOnRanges(editor, selectionRng => {\n annotate(editor, selectionRng, masterUid, name, settings.decorate, data);\n });\n });\n }\n });\n };\n\n const Annotator = editor => {\n const registry = create$c();\n setup$w(editor, registry);\n const changes = setup$x(editor, registry);\n const isSpan = isTag('span');\n const removeAnnotations = elements => {\n each$e(elements, element => {\n if (isSpan(element)) {\n unwrap(element);\n } else {\n removeDirectAnnotation(element);\n }\n });\n };\n return {\n register: (name, settings) => {\n registry.register(name, settings);\n },\n annotate: (name, data) => {\n registry.lookup(name).each(settings => {\n annotateWithBookmark(editor, name, settings, data);\n });\n },\n annotationChanged: (name, callback) => {\n changes.addListener(name, callback);\n },\n remove: name => {\n const bookmark = editor.selection.getBookmark();\n identify(editor, Optional.some(name)).each(({elements}) => {\n removeAnnotations(elements);\n });\n editor.selection.moveToBookmark(bookmark);\n },\n removeAll: name => {\n const bookmark = editor.selection.getBookmark();\n each$d(findAll(editor, name), (elements, _) => {\n removeAnnotations(elements);\n });\n editor.selection.moveToBookmark(bookmark);\n },\n getAll: name => {\n const directory = findAll(editor, name);\n return map$2(directory, elems => map$3(elems, elem => elem.dom));\n }\n };\n };\n\n const BookmarkManager = selection => {\n return {\n getBookmark: curry(getBookmark$1, selection),\n moveToBookmark: curry(moveToBookmark, selection)\n };\n };\n BookmarkManager.isBookmarkNode = isBookmarkNode$1;\n\n const isXYWithinRange = (clientX, clientY, range) => {\n if (range.collapsed) {\n return false;\n } else {\n return exists(range.getClientRects(), rect => containsXY(rect, clientX, clientY));\n }\n };\n\n const firePreProcess = (editor, args) => editor.dispatch('PreProcess', args);\n const firePostProcess = (editor, args) => editor.dispatch('PostProcess', args);\n const fireRemove = editor => {\n editor.dispatch('remove');\n };\n const fireDetach = editor => {\n editor.dispatch('detach');\n };\n const fireSwitchMode = (editor, mode) => {\n editor.dispatch('SwitchMode', { mode });\n };\n const fireObjectResizeStart = (editor, target, width, height, origin) => {\n editor.dispatch('ObjectResizeStart', {\n target,\n width,\n height,\n origin\n });\n };\n const fireObjectResized = (editor, target, width, height, origin) => {\n editor.dispatch('ObjectResized', {\n target,\n width,\n height,\n origin\n });\n };\n const firePreInit = editor => {\n editor.dispatch('PreInit');\n };\n const firePostRender = editor => {\n editor.dispatch('PostRender');\n };\n const fireInit = editor => {\n editor.dispatch('Init');\n };\n const firePlaceholderToggle = (editor, state) => {\n editor.dispatch('PlaceholderToggle', { state });\n };\n const fireError = (editor, errorType, error) => {\n editor.dispatch(errorType, error);\n };\n const fireFormatApply = (editor, format, node, vars) => {\n editor.dispatch('FormatApply', {\n format,\n node,\n vars\n });\n };\n const fireFormatRemove = (editor, format, node, vars) => {\n editor.dispatch('FormatRemove', {\n format,\n node,\n vars\n });\n };\n const fireBeforeSetContent = (editor, args) => editor.dispatch('BeforeSetContent', args);\n const fireSetContent = (editor, args) => editor.dispatch('SetContent', args);\n const fireBeforeGetContent = (editor, args) => editor.dispatch('BeforeGetContent', args);\n const fireGetContent = (editor, args) => editor.dispatch('GetContent', args);\n const fireAutocompleterStart = (editor, args) => {\n editor.dispatch('AutocompleterStart', args);\n };\n const fireAutocompleterUpdate = (editor, args) => {\n editor.dispatch('AutocompleterUpdate', args);\n };\n const fireAutocompleterEnd = editor => {\n editor.dispatch('AutocompleterEnd');\n };\n const firePastePreProcess = (editor, html, internal) => editor.dispatch('PastePreProcess', {\n content: html,\n internal\n });\n const firePastePostProcess = (editor, node, internal) => editor.dispatch('PastePostProcess', {\n node,\n internal\n });\n const firePastePlainTextToggle = (editor, state) => editor.dispatch('PastePlainTextToggle', { state });\n\n const VK = {\n BACKSPACE: 8,\n DELETE: 46,\n DOWN: 40,\n ENTER: 13,\n ESC: 27,\n LEFT: 37,\n RIGHT: 39,\n SPACEBAR: 32,\n TAB: 9,\n UP: 38,\n PAGE_UP: 33,\n PAGE_DOWN: 34,\n END: 35,\n HOME: 36,\n modifierPressed: e => {\n return e.shiftKey || e.ctrlKey || e.altKey || VK.metaKeyPressed(e);\n },\n metaKeyPressed: e => {\n return Env.os.isMacOS() || Env.os.isiOS() ? e.metaKey : e.ctrlKey && !e.altKey;\n }\n };\n\n const elementSelectionAttr = 'data-mce-selected';\n const controlElmSelector = 'table,img,figure.image,hr,video,span.mce-preview-object';\n const abs = Math.abs;\n const round$1 = Math.round;\n const resizeHandles = {\n nw: [\n 0,\n 0,\n -1,\n -1\n ],\n ne: [\n 1,\n 0,\n 1,\n -1\n ],\n se: [\n 1,\n 1,\n 1,\n 1\n ],\n sw: [\n 0,\n 1,\n -1,\n 1\n ]\n };\n const isTouchEvent = evt => evt.type === 'longpress' || evt.type.indexOf('touch') === 0;\n const ControlSelection = (selection, editor) => {\n const dom = editor.dom;\n const editableDoc = editor.getDoc();\n const rootDocument = document;\n const rootElement = editor.getBody();\n let selectedElm, selectedElmGhost, resizeHelper, selectedHandle, resizeBackdrop;\n let startX, startY, selectedElmX, selectedElmY, startW, startH, ratio, resizeStarted;\n let width;\n let height;\n let startScrollWidth;\n let startScrollHeight;\n const isImage = elm => isNonNullable(elm) && (isImg(elm) || dom.is(elm, 'figure.image'));\n const isMedia = elm => isMedia$2(elm) || dom.hasClass(elm, 'mce-preview-object');\n const isEventOnImageOutsideRange = (evt, range) => {\n if (isTouchEvent(evt)) {\n const touch = evt.touches[0];\n return isImage(evt.target) && !isXYWithinRange(touch.clientX, touch.clientY, range);\n } else {\n return isImage(evt.target) && !isXYWithinRange(evt.clientX, evt.clientY, range);\n }\n };\n const contextMenuSelectImage = evt => {\n const target = evt.target;\n if (isEventOnImageOutsideRange(evt, editor.selection.getRng()) && !evt.isDefaultPrevented()) {\n editor.selection.select(target);\n }\n };\n const getResizeTargets = elm => {\n if (dom.hasClass(elm, 'mce-preview-object') && isNonNullable(elm.firstElementChild)) {\n return [\n elm,\n elm.firstElementChild\n ];\n } else if (dom.is(elm, 'figure.image')) {\n return [elm.querySelector('img')];\n } else {\n return [elm];\n }\n };\n const isResizable = elm => {\n const selector = getObjectResizing(editor);\n if (!selector) {\n return false;\n }\n if (elm.getAttribute('data-mce-resize') === 'false') {\n return false;\n }\n if (elm === editor.getBody()) {\n return false;\n }\n if (dom.hasClass(elm, 'mce-preview-object') && isNonNullable(elm.firstElementChild)) {\n return is$1(SugarElement.fromDom(elm.firstElementChild), selector);\n } else {\n return is$1(SugarElement.fromDom(elm), selector);\n }\n };\n const createGhostElement = elm => {\n if (isMedia(elm)) {\n return dom.create('img', { src: Env.transparentSrc });\n } else {\n return elm.cloneNode(true);\n }\n };\n const setSizeProp = (element, name, value) => {\n if (isNonNullable(value)) {\n const targets = getResizeTargets(element);\n each$e(targets, target => {\n if (target.style[name] || !editor.schema.isValid(target.nodeName.toLowerCase(), name)) {\n dom.setStyle(target, name, value);\n } else {\n dom.setAttrib(target, name, '' + value);\n }\n });\n }\n };\n const setGhostElmSize = (ghostElm, width, height) => {\n setSizeProp(ghostElm, 'width', width);\n setSizeProp(ghostElm, 'height', height);\n };\n const resizeGhostElement = e => {\n let deltaX, deltaY, proportional;\n let resizeHelperX, resizeHelperY;\n deltaX = e.screenX - startX;\n deltaY = e.screenY - startY;\n width = deltaX * selectedHandle[2] + startW;\n height = deltaY * selectedHandle[3] + startH;\n width = width < 5 ? 5 : width;\n height = height < 5 ? 5 : height;\n if ((isImage(selectedElm) || isMedia(selectedElm)) && getResizeImgProportional(editor) !== false) {\n proportional = !VK.modifierPressed(e);\n } else {\n proportional = VK.modifierPressed(e);\n }\n if (proportional) {\n if (abs(deltaX) > abs(deltaY)) {\n height = round$1(width * ratio);\n width = round$1(height / ratio);\n } else {\n width = round$1(height / ratio);\n height = round$1(width * ratio);\n }\n }\n setGhostElmSize(selectedElmGhost, width, height);\n resizeHelperX = selectedHandle.startPos.x + deltaX;\n resizeHelperY = selectedHandle.startPos.y + deltaY;\n resizeHelperX = resizeHelperX > 0 ? resizeHelperX : 0;\n resizeHelperY = resizeHelperY > 0 ? resizeHelperY : 0;\n dom.setStyles(resizeHelper, {\n left: resizeHelperX,\n top: resizeHelperY,\n display: 'block'\n });\n resizeHelper.innerHTML = width + ' × ' + height;\n if (selectedHandle[2] < 0 && selectedElmGhost.clientWidth <= width) {\n dom.setStyle(selectedElmGhost, 'left', selectedElmX + (startW - width));\n }\n if (selectedHandle[3] < 0 && selectedElmGhost.clientHeight <= height) {\n dom.setStyle(selectedElmGhost, 'top', selectedElmY + (startH - height));\n }\n deltaX = rootElement.scrollWidth - startScrollWidth;\n deltaY = rootElement.scrollHeight - startScrollHeight;\n if (deltaX + deltaY !== 0) {\n dom.setStyles(resizeHelper, {\n left: resizeHelperX - deltaX,\n top: resizeHelperY - deltaY\n });\n }\n if (!resizeStarted) {\n fireObjectResizeStart(editor, selectedElm, startW, startH, 'corner-' + selectedHandle.name);\n resizeStarted = true;\n }\n };\n const endGhostResize = () => {\n const wasResizeStarted = resizeStarted;\n resizeStarted = false;\n if (wasResizeStarted) {\n setSizeProp(selectedElm, 'width', width);\n setSizeProp(selectedElm, 'height', height);\n }\n dom.unbind(editableDoc, 'mousemove', resizeGhostElement);\n dom.unbind(editableDoc, 'mouseup', endGhostResize);\n if (rootDocument !== editableDoc) {\n dom.unbind(rootDocument, 'mousemove', resizeGhostElement);\n dom.unbind(rootDocument, 'mouseup', endGhostResize);\n }\n dom.remove(selectedElmGhost);\n dom.remove(resizeHelper);\n dom.remove(resizeBackdrop);\n showResizeRect(selectedElm);\n if (wasResizeStarted) {\n fireObjectResized(editor, selectedElm, width, height, 'corner-' + selectedHandle.name);\n dom.setAttrib(selectedElm, 'style', dom.getAttrib(selectedElm, 'style'));\n }\n editor.nodeChanged();\n };\n const showResizeRect = targetElm => {\n unbindResizeHandleEvents();\n const position = dom.getPos(targetElm, rootElement);\n const selectedElmX = position.x;\n const selectedElmY = position.y;\n const rect = targetElm.getBoundingClientRect();\n const targetWidth = rect.width || rect.right - rect.left;\n const targetHeight = rect.height || rect.bottom - rect.top;\n if (selectedElm !== targetElm) {\n hideResizeRect();\n selectedElm = targetElm;\n width = height = 0;\n }\n const e = editor.dispatch('ObjectSelected', { target: targetElm });\n if (isResizable(targetElm) && !e.isDefaultPrevented()) {\n each$d(resizeHandles, (handle, name) => {\n const startDrag = e => {\n const target = getResizeTargets(selectedElm)[0];\n startX = e.screenX;\n startY = e.screenY;\n startW = target.clientWidth;\n startH = target.clientHeight;\n ratio = startH / startW;\n selectedHandle = handle;\n selectedHandle.name = name;\n selectedHandle.startPos = {\n x: targetWidth * handle[0] + selectedElmX,\n y: targetHeight * handle[1] + selectedElmY\n };\n startScrollWidth = rootElement.scrollWidth;\n startScrollHeight = rootElement.scrollHeight;\n resizeBackdrop = dom.add(rootElement, 'div', {\n 'class': 'mce-resize-backdrop',\n 'data-mce-bogus': 'all'\n });\n dom.setStyles(resizeBackdrop, {\n position: 'fixed',\n left: '0',\n top: '0',\n width: '100%',\n height: '100%'\n });\n selectedElmGhost = createGhostElement(selectedElm);\n dom.addClass(selectedElmGhost, 'mce-clonedresizable');\n dom.setAttrib(selectedElmGhost, 'data-mce-bogus', 'all');\n selectedElmGhost.contentEditable = 'false';\n dom.setStyles(selectedElmGhost, {\n left: selectedElmX,\n top: selectedElmY,\n margin: 0\n });\n setGhostElmSize(selectedElmGhost, targetWidth, targetHeight);\n selectedElmGhost.removeAttribute(elementSelectionAttr);\n rootElement.appendChild(selectedElmGhost);\n dom.bind(editableDoc, 'mousemove', resizeGhostElement);\n dom.bind(editableDoc, 'mouseup', endGhostResize);\n if (rootDocument !== editableDoc) {\n dom.bind(rootDocument, 'mousemove', resizeGhostElement);\n dom.bind(rootDocument, 'mouseup', endGhostResize);\n }\n resizeHelper = dom.add(rootElement, 'div', {\n 'class': 'mce-resize-helper',\n 'data-mce-bogus': 'all'\n }, startW + ' × ' + startH);\n };\n let handleElm = dom.get('mceResizeHandle' + name);\n if (handleElm) {\n dom.remove(handleElm);\n }\n handleElm = dom.add(rootElement, 'div', {\n 'id': 'mceResizeHandle' + name,\n 'data-mce-bogus': 'all',\n 'class': 'mce-resizehandle',\n 'unselectable': true,\n 'style': 'cursor:' + name + '-resize; margin:0; padding:0'\n });\n dom.bind(handleElm, 'mousedown', e => {\n e.stopImmediatePropagation();\n e.preventDefault();\n startDrag(e);\n });\n handle.elm = handleElm;\n dom.setStyles(handleElm, {\n left: targetWidth * handle[0] + selectedElmX - handleElm.offsetWidth / 2,\n top: targetHeight * handle[1] + selectedElmY - handleElm.offsetHeight / 2\n });\n });\n } else {\n hideResizeRect(false);\n }\n };\n const throttledShowResizeRect = first$1(showResizeRect, 0);\n const hideResizeRect = (removeSelected = true) => {\n throttledShowResizeRect.cancel();\n unbindResizeHandleEvents();\n if (selectedElm && removeSelected) {\n selectedElm.removeAttribute(elementSelectionAttr);\n }\n each$d(resizeHandles, (value, name) => {\n const handleElm = dom.get('mceResizeHandle' + name);\n if (handleElm) {\n dom.unbind(handleElm);\n dom.remove(handleElm);\n }\n });\n };\n const isChildOrEqual = (node, parent) => dom.isChildOf(node, parent);\n const updateResizeRect = e => {\n if (resizeStarted || editor.removed || editor.composing) {\n return;\n }\n const targetElm = e.type === 'mousedown' ? e.target : selection.getNode();\n const controlElm = closest$3(SugarElement.fromDom(targetElm), controlElmSelector).map(e => e.dom).getOrUndefined();\n const selectedValue = isNonNullable(controlElm) ? dom.getAttrib(controlElm, elementSelectionAttr, '1') : '1';\n each$e(dom.select(`img[${ elementSelectionAttr }],hr[${ elementSelectionAttr }]`), img => {\n img.removeAttribute(elementSelectionAttr);\n });\n if (isNonNullable(controlElm) && isChildOrEqual(controlElm, rootElement)) {\n disableGeckoResize();\n const startElm = selection.getStart(true);\n if (isChildOrEqual(startElm, controlElm) && isChildOrEqual(selection.getEnd(true), controlElm)) {\n dom.setAttrib(controlElm, elementSelectionAttr, selectedValue);\n throttledShowResizeRect.throttle(controlElm);\n return;\n }\n }\n hideResizeRect();\n };\n const unbindResizeHandleEvents = () => {\n each$d(resizeHandles, handle => {\n if (handle.elm) {\n dom.unbind(handle.elm);\n delete handle.elm;\n }\n });\n };\n const disableGeckoResize = () => {\n try {\n editor.getDoc().execCommand('enableObjectResizing', false, 'false');\n } catch (ex) {\n }\n };\n editor.on('init', () => {\n disableGeckoResize();\n editor.on('NodeChange ResizeEditor ResizeWindow ResizeContent drop', updateResizeRect);\n editor.on('keyup compositionend', e => {\n if (selectedElm && selectedElm.nodeName === 'TABLE') {\n updateResizeRect(e);\n }\n });\n editor.on('hide blur', hideResizeRect);\n editor.on('contextmenu longpress', contextMenuSelectImage, true);\n });\n editor.on('remove', unbindResizeHandleEvents);\n const destroy = () => {\n throttledShowResizeRect.cancel();\n selectedElm = selectedElmGhost = resizeBackdrop = null;\n };\n return {\n isResizable,\n showResizeRect,\n hideResizeRect,\n updateResizeRect,\n destroy\n };\n };\n\n const setStart = (rng, situ) => {\n situ.fold(e => {\n rng.setStartBefore(e.dom);\n }, (e, o) => {\n rng.setStart(e.dom, o);\n }, e => {\n rng.setStartAfter(e.dom);\n });\n };\n const setFinish = (rng, situ) => {\n situ.fold(e => {\n rng.setEndBefore(e.dom);\n }, (e, o) => {\n rng.setEnd(e.dom, o);\n }, e => {\n rng.setEndAfter(e.dom);\n });\n };\n const relativeToNative = (win, startSitu, finishSitu) => {\n const range = win.document.createRange();\n setStart(range, startSitu);\n setFinish(range, finishSitu);\n return range;\n };\n const exactToNative = (win, start, soffset, finish, foffset) => {\n const rng = win.document.createRange();\n rng.setStart(start.dom, soffset);\n rng.setEnd(finish.dom, foffset);\n return rng;\n };\n\n const adt$3 = Adt.generate([\n {\n ltr: [\n 'start',\n 'soffset',\n 'finish',\n 'foffset'\n ]\n },\n {\n rtl: [\n 'start',\n 'soffset',\n 'finish',\n 'foffset'\n ]\n }\n ]);\n const fromRange = (win, type, range) => type(SugarElement.fromDom(range.startContainer), range.startOffset, SugarElement.fromDom(range.endContainer), range.endOffset);\n const getRanges = (win, selection) => selection.match({\n domRange: rng => {\n return {\n ltr: constant(rng),\n rtl: Optional.none\n };\n },\n relative: (startSitu, finishSitu) => {\n return {\n ltr: cached(() => relativeToNative(win, startSitu, finishSitu)),\n rtl: cached(() => Optional.some(relativeToNative(win, finishSitu, startSitu)))\n };\n },\n exact: (start, soffset, finish, foffset) => {\n return {\n ltr: cached(() => exactToNative(win, start, soffset, finish, foffset)),\n rtl: cached(() => Optional.some(exactToNative(win, finish, foffset, start, soffset)))\n };\n }\n });\n const doDiagnose = (win, ranges) => {\n const rng = ranges.ltr();\n if (rng.collapsed) {\n const reversed = ranges.rtl().filter(rev => rev.collapsed === false);\n return reversed.map(rev => adt$3.rtl(SugarElement.fromDom(rev.endContainer), rev.endOffset, SugarElement.fromDom(rev.startContainer), rev.startOffset)).getOrThunk(() => fromRange(win, adt$3.ltr, rng));\n } else {\n return fromRange(win, adt$3.ltr, rng);\n }\n };\n const diagnose = (win, selection) => {\n const ranges = getRanges(win, selection);\n return doDiagnose(win, ranges);\n };\n adt$3.ltr;\n adt$3.rtl;\n\n const create$a = (start, soffset, finish, foffset) => ({\n start,\n soffset,\n finish,\n foffset\n });\n const SimRange = { create: create$a };\n\n const caretPositionFromPoint = (doc, x, y) => {\n var _a, _b;\n return Optional.from((_b = (_a = doc.dom).caretPositionFromPoint) === null || _b === void 0 ? void 0 : _b.call(_a, x, y)).bind(pos => {\n if (pos.offsetNode === null) {\n return Optional.none();\n }\n const r = doc.dom.createRange();\n r.setStart(pos.offsetNode, pos.offset);\n r.collapse();\n return Optional.some(r);\n });\n };\n const caretRangeFromPoint = (doc, x, y) => {\n var _a, _b;\n return Optional.from((_b = (_a = doc.dom).caretRangeFromPoint) === null || _b === void 0 ? void 0 : _b.call(_a, x, y));\n };\n const availableSearch = (() => {\n if (document.caretPositionFromPoint) {\n return caretPositionFromPoint;\n } else if (document.caretRangeFromPoint) {\n return caretRangeFromPoint;\n } else {\n return Optional.none;\n }\n })();\n const fromPoint$1 = (win, x, y) => {\n const doc = SugarElement.fromDom(win.document);\n return availableSearch(doc, x, y).map(rng => SimRange.create(SugarElement.fromDom(rng.startContainer), rng.startOffset, SugarElement.fromDom(rng.endContainer), rng.endOffset));\n };\n\n const adt$2 = Adt.generate([\n { before: ['element'] },\n {\n on: [\n 'element',\n 'offset'\n ]\n },\n { after: ['element'] }\n ]);\n const cata = (subject, onBefore, onOn, onAfter) => subject.fold(onBefore, onOn, onAfter);\n const getStart$2 = situ => situ.fold(identity, identity, identity);\n const before$1 = adt$2.before;\n const on = adt$2.on;\n const after$1 = adt$2.after;\n const Situ = {\n before: before$1,\n on,\n after: after$1,\n cata,\n getStart: getStart$2\n };\n\n const adt$1 = Adt.generate([\n { domRange: ['rng'] },\n {\n relative: [\n 'startSitu',\n 'finishSitu'\n ]\n },\n {\n exact: [\n 'start',\n 'soffset',\n 'finish',\n 'foffset'\n ]\n }\n ]);\n const exactFromRange = simRange => adt$1.exact(simRange.start, simRange.soffset, simRange.finish, simRange.foffset);\n const getStart$1 = selection => selection.match({\n domRange: rng => SugarElement.fromDom(rng.startContainer),\n relative: (startSitu, _finishSitu) => Situ.getStart(startSitu),\n exact: (start, _soffset, _finish, _foffset) => start\n });\n const domRange = adt$1.domRange;\n const relative = adt$1.relative;\n const exact = adt$1.exact;\n const getWin = selection => {\n const start = getStart$1(selection);\n return defaultView(start);\n };\n const range = SimRange.create;\n const SimSelection = {\n domRange,\n relative,\n exact,\n exactFromRange,\n getWin,\n range\n };\n\n const beforeSpecial = (element, offset) => {\n const name$1 = name(element);\n if ('input' === name$1) {\n return Situ.after(element);\n } else if (!contains$2([\n 'br',\n 'img'\n ], name$1)) {\n return Situ.on(element, offset);\n } else {\n return offset === 0 ? Situ.before(element) : Situ.after(element);\n }\n };\n const preprocessRelative = (startSitu, finishSitu) => {\n const start = startSitu.fold(Situ.before, beforeSpecial, Situ.after);\n const finish = finishSitu.fold(Situ.before, beforeSpecial, Situ.after);\n return SimSelection.relative(start, finish);\n };\n const preprocessExact = (start, soffset, finish, foffset) => {\n const startSitu = beforeSpecial(start, soffset);\n const finishSitu = beforeSpecial(finish, foffset);\n return SimSelection.relative(startSitu, finishSitu);\n };\n const preprocess = selection => selection.match({\n domRange: rng => {\n const start = SugarElement.fromDom(rng.startContainer);\n const finish = SugarElement.fromDom(rng.endContainer);\n return preprocessExact(start, rng.startOffset, finish, rng.endOffset);\n },\n relative: preprocessRelative,\n exact: preprocessExact\n });\n\n const fromElements = (elements, scope) => {\n const doc = scope || document;\n const fragment = doc.createDocumentFragment();\n each$e(elements, element => {\n fragment.appendChild(element.dom);\n });\n return SugarElement.fromDom(fragment);\n };\n\n const toNative = selection => {\n const win = SimSelection.getWin(selection).dom;\n const getDomRange = (start, soffset, finish, foffset) => exactToNative(win, start, soffset, finish, foffset);\n const filtered = preprocess(selection);\n return diagnose(win, filtered).match({\n ltr: getDomRange,\n rtl: getDomRange\n });\n };\n const getAtPoint = (win, x, y) => fromPoint$1(win, x, y);\n\n const fromPoint = (clientX, clientY, doc) => {\n const win = defaultView(SugarElement.fromDom(doc));\n return getAtPoint(win.dom, clientX, clientY).map(simRange => {\n const rng = doc.createRange();\n rng.setStart(simRange.start.dom, simRange.soffset);\n rng.setEnd(simRange.finish.dom, simRange.foffset);\n return rng;\n }).getOrUndefined();\n };\n\n const isEq$4 = (rng1, rng2) => {\n return isNonNullable(rng1) && isNonNullable(rng2) && (rng1.startContainer === rng2.startContainer && rng1.startOffset === rng2.startOffset) && (rng1.endContainer === rng2.endContainer && rng1.endOffset === rng2.endOffset);\n };\n\n const findParent = (node, rootNode, predicate) => {\n let currentNode = node;\n while (currentNode && currentNode !== rootNode) {\n if (predicate(currentNode)) {\n return currentNode;\n }\n currentNode = currentNode.parentNode;\n }\n return null;\n };\n const hasParent$1 = (node, rootNode, predicate) => findParent(node, rootNode, predicate) !== null;\n const hasParentWithName = (node, rootNode, name) => hasParent$1(node, rootNode, node => node.nodeName === name);\n const isCeFalseCaretContainer = (node, rootNode) => isCaretContainer$2(node) && !hasParent$1(node, rootNode, isCaretNode);\n const hasBrBeforeAfter = (dom, node, left) => {\n const parentNode = node.parentNode;\n if (parentNode) {\n const walker = new DomTreeWalker(node, dom.getParent(parentNode, dom.isBlock) || dom.getRoot());\n let currentNode;\n while (currentNode = walker[left ? 'prev' : 'next']()) {\n if (isBr$6(currentNode)) {\n return true;\n }\n }\n }\n return false;\n };\n const isPrevNode = (node, name) => {\n var _a;\n return ((_a = node.previousSibling) === null || _a === void 0 ? void 0 : _a.nodeName) === name;\n };\n const hasContentEditableFalseParent = (root, node) => {\n let currentNode = node;\n while (currentNode && currentNode !== root) {\n if (isContentEditableFalse$a(currentNode)) {\n return true;\n }\n currentNode = currentNode.parentNode;\n }\n return false;\n };\n const findTextNodeRelative = (dom, isAfterNode, collapsed, left, startNode) => {\n const body = dom.getRoot();\n const nonEmptyElementsMap = dom.schema.getNonEmptyElements();\n const parentNode = startNode.parentNode;\n let lastInlineElement;\n let node;\n if (!parentNode) {\n return Optional.none();\n }\n const parentBlockContainer = dom.getParent(parentNode, dom.isBlock) || body;\n if (left && isBr$6(startNode) && isAfterNode && dom.isEmpty(parentBlockContainer)) {\n return Optional.some(CaretPosition(parentNode, dom.nodeIndex(startNode)));\n }\n const walker = new DomTreeWalker(startNode, parentBlockContainer);\n while (node = walker[left ? 'prev' : 'next']()) {\n if (dom.getContentEditableParent(node) === 'false' || isCeFalseCaretContainer(node, body)) {\n return Optional.none();\n }\n if (isText$a(node) && node.data.length > 0) {\n if (!hasParentWithName(node, body, 'A')) {\n return Optional.some(CaretPosition(node, left ? node.data.length : 0));\n }\n return Optional.none();\n }\n if (dom.isBlock(node) || nonEmptyElementsMap[node.nodeName.toLowerCase()]) {\n return Optional.none();\n }\n lastInlineElement = node;\n }\n if (isComment(lastInlineElement)) {\n return Optional.none();\n }\n if (collapsed && lastInlineElement) {\n return Optional.some(CaretPosition(lastInlineElement, 0));\n }\n return Optional.none();\n };\n const normalizeEndPoint = (dom, collapsed, start, rng) => {\n const body = dom.getRoot();\n let node;\n let normalized = false;\n let container = start ? rng.startContainer : rng.endContainer;\n let offset = start ? rng.startOffset : rng.endOffset;\n const isAfterNode = isElement$6(container) && offset === container.childNodes.length;\n const nonEmptyElementsMap = dom.schema.getNonEmptyElements();\n let directionLeft = start;\n if (isCaretContainer$2(container)) {\n return Optional.none();\n }\n if (isElement$6(container) && offset > container.childNodes.length - 1) {\n directionLeft = false;\n }\n if (isDocument$1(container)) {\n container = body;\n offset = 0;\n }\n if (container === body) {\n if (directionLeft) {\n node = container.childNodes[offset > 0 ? offset - 1 : 0];\n if (node) {\n if (isCaretContainer$2(node)) {\n return Optional.none();\n }\n if (nonEmptyElementsMap[node.nodeName] || isTable$2(node)) {\n return Optional.none();\n }\n }\n }\n if (container.hasChildNodes()) {\n offset = Math.min(!directionLeft && offset > 0 ? offset - 1 : offset, container.childNodes.length - 1);\n container = container.childNodes[offset];\n offset = isText$a(container) && isAfterNode ? container.data.length : 0;\n if (!collapsed && container === body.lastChild && isTable$2(container)) {\n return Optional.none();\n }\n if (hasContentEditableFalseParent(body, container) || isCaretContainer$2(container)) {\n return Optional.none();\n }\n if (container.hasChildNodes() && !isTable$2(container)) {\n node = container;\n const walker = new DomTreeWalker(container, body);\n do {\n if (isContentEditableFalse$a(node) || isCaretContainer$2(node)) {\n normalized = false;\n break;\n }\n if (isText$a(node) && node.data.length > 0) {\n offset = directionLeft ? 0 : node.data.length;\n container = node;\n normalized = true;\n break;\n }\n if (nonEmptyElementsMap[node.nodeName.toLowerCase()] && !isTableCellOrCaption(node)) {\n offset = dom.nodeIndex(node);\n container = node.parentNode;\n if (!directionLeft) {\n offset++;\n }\n normalized = true;\n break;\n }\n } while (node = directionLeft ? walker.next() : walker.prev());\n }\n }\n }\n if (collapsed) {\n if (isText$a(container) && offset === 0) {\n findTextNodeRelative(dom, isAfterNode, collapsed, true, container).each(pos => {\n container = pos.container();\n offset = pos.offset();\n normalized = true;\n });\n }\n if (isElement$6(container)) {\n node = container.childNodes[offset];\n if (!node) {\n node = container.childNodes[offset - 1];\n }\n if (node && isBr$6(node) && !isPrevNode(node, 'A') && !hasBrBeforeAfter(dom, node, false) && !hasBrBeforeAfter(dom, node, true)) {\n findTextNodeRelative(dom, isAfterNode, collapsed, true, node).each(pos => {\n container = pos.container();\n offset = pos.offset();\n normalized = true;\n });\n }\n }\n }\n if (directionLeft && !collapsed && isText$a(container) && offset === container.data.length) {\n findTextNodeRelative(dom, isAfterNode, collapsed, false, container).each(pos => {\n container = pos.container();\n offset = pos.offset();\n normalized = true;\n });\n }\n return normalized && container ? Optional.some(CaretPosition(container, offset)) : Optional.none();\n };\n const normalize$2 = (dom, rng) => {\n const collapsed = rng.collapsed, normRng = rng.cloneRange();\n const startPos = CaretPosition.fromRangeStart(rng);\n normalizeEndPoint(dom, collapsed, true, normRng).each(pos => {\n if (!collapsed || !CaretPosition.isAbove(startPos, pos)) {\n normRng.setStart(pos.container(), pos.offset());\n }\n });\n if (!collapsed) {\n normalizeEndPoint(dom, collapsed, false, normRng).each(pos => {\n normRng.setEnd(pos.container(), pos.offset());\n });\n }\n if (collapsed) {\n normRng.collapse(true);\n }\n return isEq$4(rng, normRng) ? Optional.none() : Optional.some(normRng);\n };\n\n const splitText = (node, offset) => {\n return node.splitText(offset);\n };\n const split = rng => {\n let startContainer = rng.startContainer, startOffset = rng.startOffset, endContainer = rng.endContainer, endOffset = rng.endOffset;\n if (startContainer === endContainer && isText$a(startContainer)) {\n if (startOffset > 0 && startOffset < startContainer.data.length) {\n endContainer = splitText(startContainer, startOffset);\n startContainer = endContainer.previousSibling;\n if (endOffset > startOffset) {\n endOffset = endOffset - startOffset;\n const newContainer = splitText(endContainer, endOffset).previousSibling;\n startContainer = endContainer = newContainer;\n endOffset = newContainer.data.length;\n startOffset = 0;\n } else {\n endOffset = 0;\n }\n }\n } else {\n if (isText$a(startContainer) && startOffset > 0 && startOffset < startContainer.data.length) {\n startContainer = splitText(startContainer, startOffset);\n startOffset = 0;\n }\n if (isText$a(endContainer) && endOffset > 0 && endOffset < endContainer.data.length) {\n const newContainer = splitText(endContainer, endOffset).previousSibling;\n endContainer = newContainer;\n endOffset = newContainer.data.length;\n }\n }\n return {\n startContainer,\n startOffset,\n endContainer,\n endOffset\n };\n };\n\n const RangeUtils = dom => {\n const walk = (rng, callback) => {\n return walk$3(dom, rng, callback);\n };\n const split$1 = split;\n const normalize = rng => {\n return normalize$2(dom, rng).fold(never, normalizedRng => {\n rng.setStart(normalizedRng.startContainer, normalizedRng.startOffset);\n rng.setEnd(normalizedRng.endContainer, normalizedRng.endOffset);\n return true;\n });\n };\n const expand = (rng, options = { type: 'word' }) => {\n if (options.type === 'word') {\n const rangeLike = expandRng(dom, rng, [{ inline: 'span' }]);\n const newRange = dom.createRng();\n newRange.setStart(rangeLike.startContainer, rangeLike.startOffset);\n newRange.setEnd(rangeLike.endContainer, rangeLike.endOffset);\n return newRange;\n }\n return rng;\n };\n return {\n walk,\n split: split$1,\n expand,\n normalize\n };\n };\n RangeUtils.compareRanges = isEq$4;\n RangeUtils.getCaretRangeFromPoint = fromPoint;\n RangeUtils.getSelectedNode = getSelectedNode;\n RangeUtils.getNode = getNode$1;\n\n const Dimension = (name, getOffset) => {\n const set = (element, h) => {\n if (!isNumber(h) && !h.match(/^[0-9]+$/)) {\n throw new Error(name + '.set accepts only positive integer values. Value was ' + h);\n }\n const dom = element.dom;\n if (isSupported$1(dom)) {\n dom.style[name] = h + 'px';\n }\n };\n const get = element => {\n const r = getOffset(element);\n if (r <= 0 || r === null) {\n const css = get$7(element, name);\n return parseFloat(css) || 0;\n }\n return r;\n };\n const getOuter = get;\n const aggregate = (element, properties) => foldl(properties, (acc, property) => {\n const val = get$7(element, property);\n const value = val === undefined ? 0 : parseInt(val, 10);\n return isNaN(value) ? acc : acc + value;\n }, 0);\n const max = (element, value, properties) => {\n const cumulativeInclusions = aggregate(element, properties);\n const absoluteMax = value > cumulativeInclusions ? value - cumulativeInclusions : 0;\n return absoluteMax;\n };\n return {\n set,\n get,\n getOuter,\n aggregate,\n max\n };\n };\n\n const api = Dimension('height', element => {\n const dom = element.dom;\n return inBody(element) ? dom.getBoundingClientRect().height : dom.offsetHeight;\n });\n const get$2 = element => api.get(element);\n\n const getDocument = () => SugarElement.fromDom(document);\n\n const walkUp = (navigation, doc) => {\n const frame = navigation.view(doc);\n return frame.fold(constant([]), f => {\n const parent = navigation.owner(f);\n const rest = walkUp(navigation, parent);\n return [f].concat(rest);\n });\n };\n const pathTo = (element, navigation) => {\n const d = navigation.owner(element);\n return walkUp(navigation, d);\n };\n\n const view = doc => {\n var _a;\n const element = doc.dom === document ? Optional.none() : Optional.from((_a = doc.dom.defaultView) === null || _a === void 0 ? void 0 : _a.frameElement);\n return element.map(SugarElement.fromDom);\n };\n const owner = element => documentOrOwner(element);\n\n var Navigation = /*#__PURE__*/Object.freeze({\n __proto__: null,\n view: view,\n owner: owner\n });\n\n const find = element => {\n const doc = getDocument();\n const scroll = get$5(doc);\n const frames = pathTo(element, Navigation);\n const offset = viewport(element);\n const r = foldr(frames, (b, a) => {\n const loc = viewport(a);\n return {\n left: b.left + loc.left,\n top: b.top + loc.top\n };\n }, {\n left: 0,\n top: 0\n });\n return SugarPosition(r.left + offset.left + scroll.left, r.top + offset.top + scroll.top);\n };\n\n const excludeFromDescend = element => name(element) === 'textarea';\n const fireScrollIntoViewEvent = (editor, data) => {\n const scrollEvent = editor.dispatch('ScrollIntoView', data);\n return scrollEvent.isDefaultPrevented();\n };\n const fireAfterScrollIntoViewEvent = (editor, data) => {\n editor.dispatch('AfterScrollIntoView', data);\n };\n const descend = (element, offset) => {\n const children = children$1(element);\n if (children.length === 0 || excludeFromDescend(element)) {\n return {\n element,\n offset\n };\n } else if (offset < children.length && !excludeFromDescend(children[offset])) {\n return {\n element: children[offset],\n offset: 0\n };\n } else {\n const last = children[children.length - 1];\n if (excludeFromDescend(last)) {\n return {\n element,\n offset\n };\n } else {\n if (name(last) === 'img') {\n return {\n element: last,\n offset: 1\n };\n } else if (isText$b(last)) {\n return {\n element: last,\n offset: get$3(last).length\n };\n } else {\n return {\n element: last,\n offset: children$1(last).length\n };\n }\n }\n }\n };\n const markerInfo = (element, cleanupFun) => {\n const pos = absolute(element);\n const height = get$2(element);\n return {\n element,\n bottom: pos.top + height,\n height,\n pos,\n cleanup: cleanupFun\n };\n };\n const createMarker$1 = (element, offset) => {\n const startPoint = descend(element, offset);\n const span = SugarElement.fromHtml('' + ZWSP$1 + '');\n before$3(startPoint.element, span);\n return markerInfo(span, () => remove$6(span));\n };\n const elementMarker = element => markerInfo(SugarElement.fromDom(element), noop);\n const withMarker = (editor, f, rng, alignToTop) => {\n preserveWith(editor, (_s, _e) => applyWithMarker(editor, f, rng, alignToTop), rng);\n };\n const withScrollEvents = (editor, doc, f, marker, alignToTop) => {\n const data = {\n elm: marker.element.dom,\n alignToTop\n };\n if (fireScrollIntoViewEvent(editor, data)) {\n return;\n }\n const scrollTop = get$5(doc).top;\n f(doc, scrollTop, marker, alignToTop);\n fireAfterScrollIntoViewEvent(editor, data);\n };\n const applyWithMarker = (editor, f, rng, alignToTop) => {\n const body = SugarElement.fromDom(editor.getBody());\n const doc = SugarElement.fromDom(editor.getDoc());\n reflow(body);\n const marker = createMarker$1(SugarElement.fromDom(rng.startContainer), rng.startOffset);\n withScrollEvents(editor, doc, f, marker, alignToTop);\n marker.cleanup();\n };\n const withElement = (editor, element, f, alignToTop) => {\n const doc = SugarElement.fromDom(editor.getDoc());\n withScrollEvents(editor, doc, f, elementMarker(element), alignToTop);\n };\n const preserveWith = (editor, f, rng) => {\n const startElement = rng.startContainer;\n const startOffset = rng.startOffset;\n const endElement = rng.endContainer;\n const endOffset = rng.endOffset;\n f(SugarElement.fromDom(startElement), SugarElement.fromDom(endElement));\n const newRng = editor.dom.createRng();\n newRng.setStart(startElement, startOffset);\n newRng.setEnd(endElement, endOffset);\n editor.selection.setRng(rng);\n };\n const scrollToMarker = (marker, viewHeight, alignToTop, doc) => {\n const pos = marker.pos;\n if (alignToTop) {\n to(pos.left, pos.top, doc);\n } else {\n const y = pos.top - viewHeight + marker.height;\n to(pos.left, y, doc);\n }\n };\n const intoWindowIfNeeded = (doc, scrollTop, viewHeight, marker, alignToTop) => {\n const viewportBottom = viewHeight + scrollTop;\n const markerTop = marker.pos.top;\n const markerBottom = marker.bottom;\n const largerThanViewport = markerBottom - markerTop >= viewHeight;\n if (markerTop < scrollTop) {\n scrollToMarker(marker, viewHeight, alignToTop !== false, doc);\n } else if (markerTop > viewportBottom) {\n const align = largerThanViewport ? alignToTop !== false : alignToTop === true;\n scrollToMarker(marker, viewHeight, align, doc);\n } else if (markerBottom > viewportBottom && !largerThanViewport) {\n scrollToMarker(marker, viewHeight, alignToTop === true, doc);\n }\n };\n const intoWindow = (doc, scrollTop, marker, alignToTop) => {\n const viewHeight = defaultView(doc).dom.innerHeight;\n intoWindowIfNeeded(doc, scrollTop, viewHeight, marker, alignToTop);\n };\n const intoFrame = (doc, scrollTop, marker, alignToTop) => {\n const frameViewHeight = defaultView(doc).dom.innerHeight;\n intoWindowIfNeeded(doc, scrollTop, frameViewHeight, marker, alignToTop);\n const op = find(marker.element);\n const viewportBounds = getBounds(window);\n if (op.top < viewportBounds.y) {\n intoView(marker.element, alignToTop !== false);\n } else if (op.top > viewportBounds.bottom) {\n intoView(marker.element, alignToTop === true);\n }\n };\n const rangeIntoWindow = (editor, rng, alignToTop) => withMarker(editor, intoWindow, rng, alignToTop);\n const elementIntoWindow = (editor, element, alignToTop) => withElement(editor, element, intoWindow, alignToTop);\n const rangeIntoFrame = (editor, rng, alignToTop) => withMarker(editor, intoFrame, rng, alignToTop);\n const elementIntoFrame = (editor, element, alignToTop) => withElement(editor, element, intoFrame, alignToTop);\n const scrollElementIntoView = (editor, element, alignToTop) => {\n const scroller = editor.inline ? elementIntoWindow : elementIntoFrame;\n scroller(editor, element, alignToTop);\n };\n const scrollRangeIntoView = (editor, rng, alignToTop) => {\n const scroller = editor.inline ? rangeIntoWindow : rangeIntoFrame;\n scroller(editor, rng, alignToTop);\n };\n\n const focus$1 = element => element.dom.focus();\n const hasFocus$1 = element => {\n const root = getRootNode(element).dom;\n return element.dom === root.activeElement;\n };\n const active$1 = (root = getDocument()) => Optional.from(root.dom.activeElement).map(SugarElement.fromDom);\n const search = element => active$1(getRootNode(element)).filter(e => element.dom.contains(e.dom));\n\n const clamp$1 = (offset, element) => {\n const max = isText$b(element) ? get$3(element).length : children$1(element).length + 1;\n if (offset > max) {\n return max;\n } else if (offset < 0) {\n return 0;\n }\n return offset;\n };\n const normalizeRng = rng => SimSelection.range(rng.start, clamp$1(rng.soffset, rng.start), rng.finish, clamp$1(rng.foffset, rng.finish));\n const isOrContains = (root, elm) => !isRestrictedNode(elm.dom) && (contains(root, elm) || eq(root, elm));\n const isRngInRoot = root => rng => isOrContains(root, rng.start) && isOrContains(root, rng.finish);\n const shouldStore = editor => editor.inline || Env.browser.isFirefox();\n const nativeRangeToSelectionRange = r => SimSelection.range(SugarElement.fromDom(r.startContainer), r.startOffset, SugarElement.fromDom(r.endContainer), r.endOffset);\n const readRange = win => {\n const selection = win.getSelection();\n const rng = !selection || selection.rangeCount === 0 ? Optional.none() : Optional.from(selection.getRangeAt(0));\n return rng.map(nativeRangeToSelectionRange);\n };\n const getBookmark = root => {\n const win = defaultView(root);\n return readRange(win.dom).filter(isRngInRoot(root));\n };\n const validate = (root, bookmark) => Optional.from(bookmark).filter(isRngInRoot(root)).map(normalizeRng);\n const bookmarkToNativeRng = bookmark => {\n const rng = document.createRange();\n try {\n rng.setStart(bookmark.start.dom, bookmark.soffset);\n rng.setEnd(bookmark.finish.dom, bookmark.foffset);\n return Optional.some(rng);\n } catch (_) {\n return Optional.none();\n }\n };\n const store = editor => {\n const newBookmark = shouldStore(editor) ? getBookmark(SugarElement.fromDom(editor.getBody())) : Optional.none();\n editor.bookmark = newBookmark.isSome() ? newBookmark : editor.bookmark;\n };\n const getRng = editor => {\n const bookmark = editor.bookmark ? editor.bookmark : Optional.none();\n return bookmark.bind(x => validate(SugarElement.fromDom(editor.getBody()), x)).bind(bookmarkToNativeRng);\n };\n const restore = editor => {\n getRng(editor).each(rng => editor.selection.setRng(rng));\n };\n\n const isEditorUIElement$1 = elm => {\n const className = elm.className.toString();\n return className.indexOf('tox-') !== -1 || className.indexOf('mce-') !== -1;\n };\n const FocusManager = { isEditorUIElement: isEditorUIElement$1 };\n\n const wrappedSetTimeout = (callback, time) => {\n if (!isNumber(time)) {\n time = 0;\n }\n return setTimeout(callback, time);\n };\n const wrappedSetInterval = (callback, time) => {\n if (!isNumber(time)) {\n time = 0;\n }\n return setInterval(callback, time);\n };\n const Delay = {\n setEditorTimeout: (editor, callback, time) => {\n return wrappedSetTimeout(() => {\n if (!editor.removed) {\n callback();\n }\n }, time);\n },\n setEditorInterval: (editor, callback, time) => {\n const timer = wrappedSetInterval(() => {\n if (!editor.removed) {\n callback();\n } else {\n clearInterval(timer);\n }\n }, time);\n return timer;\n }\n };\n\n const isManualNodeChange = e => {\n return e.type === 'nodechange' && e.selectionChange;\n };\n const registerPageMouseUp = (editor, throttledStore) => {\n const mouseUpPage = () => {\n throttledStore.throttle();\n };\n DOMUtils.DOM.bind(document, 'mouseup', mouseUpPage);\n editor.on('remove', () => {\n DOMUtils.DOM.unbind(document, 'mouseup', mouseUpPage);\n });\n };\n const registerMouseUp = (editor, throttledStore) => {\n editor.on('mouseup touchend', _e => {\n throttledStore.throttle();\n });\n };\n const registerEditorEvents = (editor, throttledStore) => {\n registerMouseUp(editor, throttledStore);\n editor.on('keyup NodeChange AfterSetSelectionRange', e => {\n if (!isManualNodeChange(e)) {\n store(editor);\n }\n });\n };\n const register$6 = editor => {\n const throttledStore = first$1(() => {\n store(editor);\n }, 0);\n editor.on('init', () => {\n if (editor.inline) {\n registerPageMouseUp(editor, throttledStore);\n }\n registerEditorEvents(editor, throttledStore);\n });\n editor.on('remove', () => {\n throttledStore.cancel();\n });\n };\n\n let documentFocusInHandler;\n const DOM$9 = DOMUtils.DOM;\n const isEditorUIElement = elm => {\n return isElement$6(elm) && FocusManager.isEditorUIElement(elm);\n };\n const isEditorContentAreaElement = elm => {\n const classList = elm.classList;\n if (classList !== undefined) {\n return classList.contains('tox-edit-area') || classList.contains('tox-edit-area__iframe') || classList.contains('mce-content-body');\n } else {\n return false;\n }\n };\n const isUIElement = (editor, elm) => {\n const customSelector = getCustomUiSelector(editor);\n const parent = DOM$9.getParent(elm, elm => {\n return isEditorUIElement(elm) || (customSelector ? editor.dom.is(elm, customSelector) : false);\n });\n return parent !== null;\n };\n const getActiveElement = editor => {\n try {\n const root = getRootNode(SugarElement.fromDom(editor.getElement()));\n return active$1(root).fold(() => document.body, x => x.dom);\n } catch (ex) {\n return document.body;\n }\n };\n const registerEvents$1 = (editorManager, e) => {\n const editor = e.editor;\n register$6(editor);\n editor.on('focusin', () => {\n const focusedEditor = editorManager.focusedEditor;\n if (focusedEditor !== editor) {\n if (focusedEditor) {\n focusedEditor.dispatch('blur', { focusedEditor: editor });\n }\n editorManager.setActive(editor);\n editorManager.focusedEditor = editor;\n editor.dispatch('focus', { blurredEditor: focusedEditor });\n editor.focus(true);\n }\n });\n editor.on('focusout', () => {\n Delay.setEditorTimeout(editor, () => {\n const focusedEditor = editorManager.focusedEditor;\n if (!isUIElement(editor, getActiveElement(editor)) && focusedEditor === editor) {\n editor.dispatch('blur', { focusedEditor: null });\n editorManager.focusedEditor = null;\n }\n });\n });\n if (!documentFocusInHandler) {\n documentFocusInHandler = e => {\n const activeEditor = editorManager.activeEditor;\n if (activeEditor) {\n getOriginalEventTarget(e).each(target => {\n const elem = target;\n if (elem.ownerDocument === document) {\n if (elem !== document.body && !isUIElement(activeEditor, elem) && editorManager.focusedEditor === activeEditor) {\n activeEditor.dispatch('blur', { focusedEditor: null });\n editorManager.focusedEditor = null;\n }\n }\n });\n }\n };\n DOM$9.bind(document, 'focusin', documentFocusInHandler);\n }\n };\n const unregisterDocumentEvents = (editorManager, e) => {\n if (editorManager.focusedEditor === e.editor) {\n editorManager.focusedEditor = null;\n }\n if (!editorManager.activeEditor && documentFocusInHandler) {\n DOM$9.unbind(document, 'focusin', documentFocusInHandler);\n documentFocusInHandler = null;\n }\n };\n const setup$v = editorManager => {\n editorManager.on('AddEditor', curry(registerEvents$1, editorManager));\n editorManager.on('RemoveEditor', curry(unregisterDocumentEvents, editorManager));\n };\n\n const getContentEditableHost = (editor, node) => editor.dom.getParent(node, node => editor.dom.getContentEditable(node) === 'true');\n const getCollapsedNode = rng => rng.collapsed ? Optional.from(getNode$1(rng.startContainer, rng.startOffset)).map(SugarElement.fromDom) : Optional.none();\n const getFocusInElement = (root, rng) => getCollapsedNode(rng).bind(node => {\n if (isTableSection(node)) {\n return Optional.some(node);\n } else if (!contains(root, node)) {\n return Optional.some(root);\n } else {\n return Optional.none();\n }\n });\n const normalizeSelection = (editor, rng) => {\n getFocusInElement(SugarElement.fromDom(editor.getBody()), rng).bind(elm => {\n return firstPositionIn(elm.dom);\n }).fold(() => {\n editor.selection.normalize();\n }, caretPos => editor.selection.setRng(caretPos.toRange()));\n };\n const focusBody = body => {\n if (body.setActive) {\n try {\n body.setActive();\n } catch (ex) {\n body.focus();\n }\n } else {\n body.focus();\n }\n };\n const hasElementFocus = elm => hasFocus$1(elm) || search(elm).isSome();\n const hasIframeFocus = editor => isNonNullable(editor.iframeElement) && hasFocus$1(SugarElement.fromDom(editor.iframeElement));\n const hasInlineFocus = editor => {\n const rawBody = editor.getBody();\n return rawBody && hasElementFocus(SugarElement.fromDom(rawBody));\n };\n const hasUiFocus = editor => {\n const dos = getRootNode(SugarElement.fromDom(editor.getElement()));\n return active$1(dos).filter(elem => !isEditorContentAreaElement(elem.dom) && isUIElement(editor, elem.dom)).isSome();\n };\n const hasFocus = editor => editor.inline ? hasInlineFocus(editor) : hasIframeFocus(editor);\n const hasEditorOrUiFocus = editor => hasFocus(editor) || hasUiFocus(editor);\n const focusEditor = editor => {\n const selection = editor.selection;\n const body = editor.getBody();\n let rng = selection.getRng();\n editor.quirks.refreshContentEditable();\n if (isNonNullable(editor.bookmark) && !hasFocus(editor)) {\n getRng(editor).each(bookmarkRng => {\n editor.selection.setRng(bookmarkRng);\n rng = bookmarkRng;\n });\n }\n const contentEditableHost = getContentEditableHost(editor, selection.getNode());\n if (contentEditableHost && editor.dom.isChildOf(contentEditableHost, body)) {\n focusBody(contentEditableHost);\n normalizeSelection(editor, rng);\n activateEditor(editor);\n return;\n }\n if (!editor.inline) {\n if (!Env.browser.isOpera()) {\n focusBody(body);\n }\n editor.getWin().focus();\n }\n if (Env.browser.isFirefox() || editor.inline) {\n focusBody(body);\n normalizeSelection(editor, rng);\n }\n activateEditor(editor);\n };\n const activateEditor = editor => editor.editorManager.setActive(editor);\n const focus = (editor, skipFocus) => {\n if (editor.removed) {\n return;\n }\n if (skipFocus) {\n activateEditor(editor);\n } else {\n focusEditor(editor);\n }\n };\n\n const getEndpointElement = (root, rng, start, real, resolve) => {\n const container = start ? rng.startContainer : rng.endContainer;\n const offset = start ? rng.startOffset : rng.endOffset;\n return Optional.from(container).map(SugarElement.fromDom).map(elm => !real || !rng.collapsed ? child$1(elm, resolve(elm, offset)).getOr(elm) : elm).bind(elm => isElement$7(elm) ? Optional.some(elm) : parent(elm).filter(isElement$7)).map(elm => elm.dom).getOr(root);\n };\n const getStart = (root, rng, real = false) => getEndpointElement(root, rng, true, real, (elm, offset) => Math.min(childNodesCount(elm), offset));\n const getEnd$1 = (root, rng, real = false) => getEndpointElement(root, rng, false, real, (elm, offset) => offset > 0 ? offset - 1 : offset);\n const skipEmptyTextNodes = (node, forwards) => {\n const orig = node;\n while (node && isText$a(node) && node.length === 0) {\n node = forwards ? node.nextSibling : node.previousSibling;\n }\n return node || orig;\n };\n const getNode = (root, rng) => {\n if (!rng) {\n return root;\n }\n let startContainer = rng.startContainer;\n let endContainer = rng.endContainer;\n const startOffset = rng.startOffset;\n const endOffset = rng.endOffset;\n let node = rng.commonAncestorContainer;\n if (!rng.collapsed) {\n if (startContainer === endContainer) {\n if (endOffset - startOffset < 2) {\n if (startContainer.hasChildNodes()) {\n node = startContainer.childNodes[startOffset];\n }\n }\n }\n if (isText$a(startContainer) && isText$a(endContainer)) {\n if (startContainer.length === startOffset) {\n startContainer = skipEmptyTextNodes(startContainer.nextSibling, true);\n } else {\n startContainer = startContainer.parentNode;\n }\n if (endOffset === 0) {\n endContainer = skipEmptyTextNodes(endContainer.previousSibling, false);\n } else {\n endContainer = endContainer.parentNode;\n }\n if (startContainer && startContainer === endContainer) {\n node = startContainer;\n }\n }\n }\n const elm = isText$a(node) ? node.parentNode : node;\n return isElement$6(elm) ? elm : root;\n };\n const getSelectedBlocks = (dom, rng, startElm, endElm) => {\n const selectedBlocks = [];\n const root = dom.getRoot();\n const start = dom.getParent(startElm || getStart(root, rng, rng.collapsed), dom.isBlock);\n const end = dom.getParent(endElm || getEnd$1(root, rng, rng.collapsed), dom.isBlock);\n if (start && start !== root) {\n selectedBlocks.push(start);\n }\n if (start && end && start !== end) {\n let node = start;\n const walker = new DomTreeWalker(start, root);\n while ((node = walker.next()) && node !== end) {\n if (dom.isBlock(node)) {\n selectedBlocks.push(node);\n }\n }\n }\n if (end && start !== end && end !== root) {\n selectedBlocks.push(end);\n }\n return selectedBlocks;\n };\n const select = (dom, node, content) => Optional.from(node).bind(node => Optional.from(node.parentNode).map(parent => {\n const idx = dom.nodeIndex(node);\n const rng = dom.createRng();\n rng.setStart(parent, idx);\n rng.setEnd(parent, idx + 1);\n if (content) {\n moveEndPoint(dom, rng, node, true);\n moveEndPoint(dom, rng, node, false);\n }\n return rng;\n }));\n\n const processRanges = (editor, ranges) => map$3(ranges, range => {\n const evt = editor.dispatch('GetSelectionRange', { range });\n return evt.range !== range ? evt.range : range;\n });\n\n const getEnd = element => name(element) === 'img' ? 1 : getOption(element).fold(() => children$1(element).length, v => v.length);\n const isTextNodeWithCursorPosition = el => getOption(el).filter(text => text.trim().length !== 0 || text.indexOf(nbsp) > -1).isSome();\n const elementsWithCursorPosition = [\n 'img',\n 'br'\n ];\n const isCursorPosition = elem => {\n const hasCursorPosition = isTextNodeWithCursorPosition(elem);\n return hasCursorPosition || contains$2(elementsWithCursorPosition, name(elem));\n };\n\n const first = element => descendant$1(element, isCursorPosition);\n const last = element => descendantRtl(element, isCursorPosition);\n const descendantRtl = (scope, predicate) => {\n const descend = element => {\n const children = children$1(element);\n for (let i = children.length - 1; i >= 0; i--) {\n const child = children[i];\n if (predicate(child)) {\n return Optional.some(child);\n }\n const res = descend(child);\n if (res.isSome()) {\n return res;\n }\n }\n return Optional.none();\n };\n return descend(scope);\n };\n\n const autocompleteSelector = '[data-mce-autocompleter]';\n const create$9 = (editor, range) => {\n if (findIn(SugarElement.fromDom(editor.getBody())).isNone()) {\n const wrapper = SugarElement.fromHtml('', editor.getDoc());\n append$1(wrapper, SugarElement.fromDom(range.extractContents()));\n range.insertNode(wrapper.dom);\n parent(wrapper).each(elm => elm.dom.normalize());\n last(wrapper).map(last => {\n editor.selection.setCursorLocation(last.dom, getEnd(last));\n });\n }\n };\n const detect$1 = elm => closest$3(elm, autocompleteSelector);\n const findIn = elm => descendant(elm, autocompleteSelector);\n const remove$3 = (editor, elm) => findIn(elm).each(wrapper => {\n const bookmark = editor.selection.getBookmark();\n unwrap(wrapper);\n editor.selection.moveToBookmark(bookmark);\n });\n\n const typeLookup = {\n '#text': 3,\n '#comment': 8,\n '#cdata': 4,\n '#pi': 7,\n '#doctype': 10,\n '#document-fragment': 11\n };\n const walk$2 = (node, root, prev) => {\n const startName = prev ? 'lastChild' : 'firstChild';\n const siblingName = prev ? 'prev' : 'next';\n if (node[startName]) {\n return node[startName];\n }\n if (node !== root) {\n let sibling = node[siblingName];\n if (sibling) {\n return sibling;\n }\n for (let parent = node.parent; parent && parent !== root; parent = parent.parent) {\n sibling = parent[siblingName];\n if (sibling) {\n return sibling;\n }\n }\n }\n return undefined;\n };\n const isEmptyTextNode = node => {\n var _a;\n const text = (_a = node.value) !== null && _a !== void 0 ? _a : '';\n if (!isWhitespaceText(text)) {\n return false;\n }\n const parentNode = node.parent;\n if (parentNode && (parentNode.name !== 'span' || parentNode.attr('style')) && /^[ ]+$/.test(text)) {\n return false;\n }\n return true;\n };\n const isNonEmptyElement = node => {\n const isNamedAnchor = node.name === 'a' && !node.attr('href') && node.attr('id');\n return node.attr('name') || node.attr('id') && !node.firstChild || node.attr('data-mce-bookmark') || isNamedAnchor;\n };\n class AstNode {\n constructor(name, type) {\n this.name = name;\n this.type = type;\n if (type === 1) {\n this.attributes = [];\n this.attributes.map = {};\n }\n }\n static create(name, attrs) {\n const node = new AstNode(name, typeLookup[name] || 1);\n if (attrs) {\n each$d(attrs, (value, attrName) => {\n node.attr(attrName, value);\n });\n }\n return node;\n }\n replace(node) {\n const self = this;\n if (node.parent) {\n node.remove();\n }\n self.insert(node, self);\n self.remove();\n return self;\n }\n attr(name, value) {\n const self = this;\n if (!isString(name)) {\n if (isNonNullable(name)) {\n each$d(name, (value, key) => {\n self.attr(key, value);\n });\n }\n return self;\n }\n const attrs = self.attributes;\n if (attrs) {\n if (value !== undefined) {\n if (value === null) {\n if (name in attrs.map) {\n delete attrs.map[name];\n let i = attrs.length;\n while (i--) {\n if (attrs[i].name === name) {\n attrs.splice(i, 1);\n return self;\n }\n }\n }\n return self;\n }\n if (name in attrs.map) {\n let i = attrs.length;\n while (i--) {\n if (attrs[i].name === name) {\n attrs[i].value = value;\n break;\n }\n }\n } else {\n attrs.push({\n name,\n value\n });\n }\n attrs.map[name] = value;\n return self;\n }\n return attrs.map[name];\n }\n return undefined;\n }\n clone() {\n const self = this;\n const clone = new AstNode(self.name, self.type);\n const selfAttrs = self.attributes;\n if (selfAttrs) {\n const cloneAttrs = [];\n cloneAttrs.map = {};\n for (let i = 0, l = selfAttrs.length; i < l; i++) {\n const selfAttr = selfAttrs[i];\n if (selfAttr.name !== 'id') {\n cloneAttrs[cloneAttrs.length] = {\n name: selfAttr.name,\n value: selfAttr.value\n };\n cloneAttrs.map[selfAttr.name] = selfAttr.value;\n }\n }\n clone.attributes = cloneAttrs;\n }\n clone.value = self.value;\n return clone;\n }\n wrap(wrapper) {\n const self = this;\n if (self.parent) {\n self.parent.insert(wrapper, self);\n wrapper.append(self);\n }\n return self;\n }\n unwrap() {\n const self = this;\n for (let node = self.firstChild; node;) {\n const next = node.next;\n self.insert(node, self, true);\n node = next;\n }\n self.remove();\n }\n remove() {\n const self = this, parent = self.parent, next = self.next, prev = self.prev;\n if (parent) {\n if (parent.firstChild === self) {\n parent.firstChild = next;\n if (next) {\n next.prev = null;\n }\n } else if (prev) {\n prev.next = next;\n }\n if (parent.lastChild === self) {\n parent.lastChild = prev;\n if (prev) {\n prev.next = null;\n }\n } else if (next) {\n next.prev = prev;\n }\n self.parent = self.next = self.prev = null;\n }\n return self;\n }\n append(node) {\n const self = this;\n if (node.parent) {\n node.remove();\n }\n const last = self.lastChild;\n if (last) {\n last.next = node;\n node.prev = last;\n self.lastChild = node;\n } else {\n self.lastChild = self.firstChild = node;\n }\n node.parent = self;\n return node;\n }\n insert(node, refNode, before) {\n if (node.parent) {\n node.remove();\n }\n const parent = refNode.parent || this;\n if (before) {\n if (refNode === parent.firstChild) {\n parent.firstChild = node;\n } else if (refNode.prev) {\n refNode.prev.next = node;\n }\n node.prev = refNode.prev;\n node.next = refNode;\n refNode.prev = node;\n } else {\n if (refNode === parent.lastChild) {\n parent.lastChild = node;\n } else if (refNode.next) {\n refNode.next.prev = node;\n }\n node.next = refNode.next;\n node.prev = refNode;\n refNode.next = node;\n }\n node.parent = parent;\n return node;\n }\n getAll(name) {\n const self = this;\n const collection = [];\n for (let node = self.firstChild; node; node = walk$2(node, self)) {\n if (node.name === name) {\n collection.push(node);\n }\n }\n return collection;\n }\n children() {\n const self = this;\n const collection = [];\n for (let node = self.firstChild; node; node = node.next) {\n collection.push(node);\n }\n return collection;\n }\n empty() {\n const self = this;\n if (self.firstChild) {\n const nodes = [];\n for (let node = self.firstChild; node; node = walk$2(node, self)) {\n nodes.push(node);\n }\n let i = nodes.length;\n while (i--) {\n const node = nodes[i];\n node.parent = node.firstChild = node.lastChild = node.next = node.prev = null;\n }\n }\n self.firstChild = self.lastChild = null;\n return self;\n }\n isEmpty(elements, whitespace = {}, predicate) {\n var _a;\n const self = this;\n let node = self.firstChild;\n if (isNonEmptyElement(self)) {\n return false;\n }\n if (node) {\n do {\n if (node.type === 1) {\n if (node.attr('data-mce-bogus')) {\n continue;\n }\n if (elements[node.name]) {\n return false;\n }\n if (isNonEmptyElement(node)) {\n return false;\n }\n }\n if (node.type === 8) {\n return false;\n }\n if (node.type === 3 && !isEmptyTextNode(node)) {\n return false;\n }\n if (node.type === 3 && node.parent && whitespace[node.parent.name] && isWhitespaceText((_a = node.value) !== null && _a !== void 0 ? _a : '')) {\n return false;\n }\n if (predicate && predicate(node)) {\n return false;\n }\n } while (node = walk$2(node, self));\n }\n return true;\n }\n walk(prev) {\n return walk$2(this, null, prev);\n }\n }\n\n const isConditionalComment = (html, startIndex) => /^\\s*\\[if [\\w\\W]+\\]>.*/.test(html.substr(startIndex));\n const findCommentEndIndex = (html, isBogus, startIndex = 0) => {\n const lcHtml = html.toLowerCase();\n if (lcHtml.indexOf('[if ', startIndex) !== -1 && isConditionalComment(lcHtml, startIndex)) {\n const endIfIndex = lcHtml.indexOf('[endif]', startIndex);\n return lcHtml.indexOf('>', endIfIndex);\n } else {\n if (isBogus) {\n const endIndex = lcHtml.indexOf('>', startIndex);\n return endIndex !== -1 ? endIndex : lcHtml.length;\n } else {\n const endCommentRegexp = /--!?>/g;\n endCommentRegexp.lastIndex = startIndex;\n const match = endCommentRegexp.exec(html);\n return match ? match.index + match[0].length : lcHtml.length;\n }\n }\n };\n const findMatchingEndTagIndex = (schema, html, startIndex) => {\n const startTagRegExp = /<([!?\\/])?([A-Za-z0-9\\-_:.]+)/g;\n const endTagRegExp = /(?:\\s(?:[^'\">]+(?:\"[^\"]*\"|'[^']*'))*[^\"'>]*(?:\"[^\">]*|'[^'>]*)?|\\s*|\\/)>/g;\n const voidElements = schema.getVoidElements();\n let count = 1, index = startIndex;\n while (count !== 0) {\n startTagRegExp.lastIndex = index;\n while (true) {\n const startMatch = startTagRegExp.exec(html);\n if (startMatch === null) {\n return index;\n } else if (startMatch[1] === '!') {\n if (startsWith(startMatch[2], '--')) {\n index = findCommentEndIndex(html, false, startMatch.index + '!--'.length);\n } else {\n index = findCommentEndIndex(html, true, startMatch.index + 1);\n }\n break;\n } else {\n endTagRegExp.lastIndex = startTagRegExp.lastIndex;\n const endMatch = endTagRegExp.exec(html);\n if (isNull(endMatch) || endMatch.index !== startTagRegExp.lastIndex) {\n continue;\n }\n if (startMatch[1] === '/') {\n count -= 1;\n } else if (!has$2(voidElements, startMatch[2])) {\n count += 1;\n }\n index = startTagRegExp.lastIndex + endMatch[0].length;\n break;\n }\n }\n }\n return index;\n };\n const trimHtml$1 = (tempAttrs, html) => {\n const trimContentRegExp = new RegExp(['\\\\s?(' + tempAttrs.join('|') + ')=\"[^\"]+\"'].join('|'), 'gi');\n return html.replace(trimContentRegExp, '');\n };\n const trimInternal = (serializer, html) => {\n const bogusAllRegExp = /<(\\w+) [^>]*data-mce-bogus=\"all\"[^>]*>/g;\n const schema = serializer.schema;\n let content = trimHtml$1(serializer.getTempAttrs(), html);\n const voidElements = schema.getVoidElements();\n let matches;\n while (matches = bogusAllRegExp.exec(content)) {\n const index = bogusAllRegExp.lastIndex;\n const matchLength = matches[0].length;\n let endTagIndex;\n if (voidElements[matches[1]]) {\n endTagIndex = index;\n } else {\n endTagIndex = findMatchingEndTagIndex(schema, content, index);\n }\n content = content.substring(0, index - matchLength) + content.substring(endTagIndex);\n bogusAllRegExp.lastIndex = index - matchLength;\n }\n return trim$1(content);\n };\n const trimExternal = trimInternal;\n\n const cleanupBogusElements = parent => {\n const bogusElements = descendants(parent, '[data-mce-bogus]');\n each$e(bogusElements, elem => {\n const bogusValue = get$9(elem, 'data-mce-bogus');\n if (bogusValue === 'all') {\n remove$6(elem);\n } else if (isBr$5(elem)) {\n before$3(elem, SugarElement.fromText(zeroWidth));\n remove$6(elem);\n } else {\n unwrap(elem);\n }\n });\n };\n const cleanupInputNames = parent => {\n const inputs = descendants(parent, 'input');\n each$e(inputs, input => {\n remove$b(input, 'name');\n });\n };\n\n const trimEmptyContents = (editor, html) => {\n const blockName = getForcedRootBlock(editor);\n const emptyRegExp = new RegExp(`^(<${ blockName }[^>]*>( | |\\\\s|\\u00a0|
|)<\\\\/${ blockName }>[\\r\\n]*|
[\\r\\n]*)$`);\n return html.replace(emptyRegExp, '');\n };\n const getPlainTextContent = (editor, body) => {\n const doc = editor.getDoc();\n const dos = getRootNode(SugarElement.fromDom(editor.getBody()));\n const offscreenDiv = SugarElement.fromTag('div', doc);\n set$2(offscreenDiv, 'data-mce-bogus', 'all');\n setAll(offscreenDiv, {\n position: 'fixed',\n left: '-9999999px',\n top: '0'\n });\n set(offscreenDiv, body.innerHTML);\n cleanupBogusElements(offscreenDiv);\n cleanupInputNames(offscreenDiv);\n const root = getContentContainer(dos);\n append$1(root, offscreenDiv);\n const content = trim$1(offscreenDiv.dom.innerText);\n remove$6(offscreenDiv);\n return content;\n };\n const getContentFromBody = (editor, args, body) => {\n let content;\n if (args.format === 'raw') {\n content = Tools.trim(trimExternal(editor.serializer, body.innerHTML));\n } else if (args.format === 'text') {\n content = getPlainTextContent(editor, body);\n } else if (args.format === 'tree') {\n content = editor.serializer.serialize(body, args);\n } else {\n content = trimEmptyContents(editor, editor.serializer.serialize(body, args));\n }\n const shouldTrim = args.format !== 'text' && !isWsPreserveElement(SugarElement.fromDom(body));\n return shouldTrim && isString(content) ? Tools.trim(content) : content;\n };\n const getContentInternal = (editor, args) => Optional.from(editor.getBody()).fold(constant(args.format === 'tree' ? new AstNode('body', 11) : ''), body => getContentFromBody(editor, args, body));\n\n const makeMap$1 = Tools.makeMap;\n const Writer = settings => {\n const html = [];\n settings = settings || {};\n const indent = settings.indent;\n const indentBefore = makeMap$1(settings.indent_before || '');\n const indentAfter = makeMap$1(settings.indent_after || '');\n const encode = Entities.getEncodeFunc(settings.entity_encoding || 'raw', settings.entities);\n const htmlOutput = settings.element_format !== 'xhtml';\n return {\n start: (name, attrs, empty) => {\n if (indent && indentBefore[name] && html.length > 0) {\n const value = html[html.length - 1];\n if (value.length > 0 && value !== '\\n') {\n html.push('\\n');\n }\n }\n html.push('<', name);\n if (attrs) {\n for (let i = 0, l = attrs.length; i < l; i++) {\n const attr = attrs[i];\n html.push(' ', attr.name, '=\"', encode(attr.value, true), '\"');\n }\n }\n if (!empty || htmlOutput) {\n html[html.length] = '>';\n } else {\n html[html.length] = ' />';\n }\n if (empty && indent && indentAfter[name] && html.length > 0) {\n const value = html[html.length - 1];\n if (value.length > 0 && value !== '\\n') {\n html.push('\\n');\n }\n }\n },\n end: name => {\n let value;\n html.push('');\n if (indent && indentAfter[name] && html.length > 0) {\n value = html[html.length - 1];\n if (value.length > 0 && value !== '\\n') {\n html.push('\\n');\n }\n }\n },\n text: (text, raw) => {\n if (text.length > 0) {\n html[html.length] = raw ? text : encode(text);\n }\n },\n cdata: text => {\n html.push('');\n },\n comment: text => {\n html.push('');\n },\n pi: (name, text) => {\n if (text) {\n html.push('');\n } else {\n html.push('');\n }\n if (indent) {\n html.push('\\n');\n }\n },\n doctype: text => {\n html.push('', indent ? '\\n' : '');\n },\n reset: () => {\n html.length = 0;\n },\n getContent: () => {\n return html.join('').replace(/\\n$/, '');\n }\n };\n };\n\n const HtmlSerializer = (settings = {}, schema = Schema()) => {\n const writer = Writer(settings);\n settings.validate = 'validate' in settings ? settings.validate : true;\n const serialize = node => {\n const validate = settings.validate;\n const handlers = {\n 3: node => {\n var _a;\n writer.text((_a = node.value) !== null && _a !== void 0 ? _a : '', node.raw);\n },\n 8: node => {\n var _a;\n writer.comment((_a = node.value) !== null && _a !== void 0 ? _a : '');\n },\n 7: node => {\n writer.pi(node.name, node.value);\n },\n 10: node => {\n var _a;\n writer.doctype((_a = node.value) !== null && _a !== void 0 ? _a : '');\n },\n 4: node => {\n var _a;\n writer.cdata((_a = node.value) !== null && _a !== void 0 ? _a : '');\n },\n 11: node => {\n let tempNode = node;\n if (tempNode = tempNode.firstChild) {\n do {\n walk(tempNode);\n } while (tempNode = tempNode.next);\n }\n }\n };\n writer.reset();\n const walk = node => {\n var _a;\n const handler = handlers[node.type];\n if (!handler) {\n const name = node.name;\n const isEmpty = name in schema.getVoidElements();\n let attrs = node.attributes;\n if (validate && attrs && attrs.length > 1) {\n const sortedAttrs = [];\n sortedAttrs.map = {};\n const elementRule = schema.getElementRule(node.name);\n if (elementRule) {\n for (let i = 0, l = elementRule.attributesOrder.length; i < l; i++) {\n const attrName = elementRule.attributesOrder[i];\n if (attrName in attrs.map) {\n const attrValue = attrs.map[attrName];\n sortedAttrs.map[attrName] = attrValue;\n sortedAttrs.push({\n name: attrName,\n value: attrValue\n });\n }\n }\n for (let i = 0, l = attrs.length; i < l; i++) {\n const attrName = attrs[i].name;\n if (!(attrName in sortedAttrs.map)) {\n const attrValue = attrs.map[attrName];\n sortedAttrs.map[attrName] = attrValue;\n sortedAttrs.push({\n name: attrName,\n value: attrValue\n });\n }\n }\n attrs = sortedAttrs;\n }\n }\n writer.start(name, attrs, isEmpty);\n if (!isEmpty) {\n let child = node.firstChild;\n if (child) {\n if ((name === 'pre' || name === 'textarea') && child.type === 3 && ((_a = child.value) === null || _a === void 0 ? void 0 : _a[0]) === '\\n') {\n writer.text('\\n', true);\n }\n do {\n walk(child);\n } while (child = child.next);\n }\n writer.end(name);\n }\n } else {\n handler(node);\n }\n };\n if (node.type === 1 && !settings.inner) {\n walk(node);\n } else if (node.type === 3) {\n handlers[3](node);\n } else {\n handlers[11](node);\n }\n return writer.getContent();\n };\n return { serialize };\n };\n\n const nonInheritableStyles = new Set();\n (() => {\n const nonInheritableStylesArr = [\n 'margin',\n 'margin-left',\n 'margin-right',\n 'margin-top',\n 'margin-bottom',\n 'padding',\n 'padding-left',\n 'padding-right',\n 'padding-top',\n 'padding-bottom',\n 'border',\n 'border-width',\n 'border-style',\n 'border-color',\n 'background',\n 'background-attachment',\n 'background-clip',\n 'background-color',\n 'background-image',\n 'background-origin',\n 'background-position',\n 'background-repeat',\n 'background-size',\n 'float',\n 'position',\n 'left',\n 'right',\n 'top',\n 'bottom',\n 'z-index',\n 'display',\n 'transform',\n 'width',\n 'max-width',\n 'min-width',\n 'height',\n 'max-height',\n 'min-height',\n 'overflow',\n 'overflow-x',\n 'overflow-y',\n 'text-overflow',\n 'vertical-align',\n 'transition',\n 'transition-delay',\n 'transition-duration',\n 'transition-property',\n 'transition-timing-function'\n ];\n each$e(nonInheritableStylesArr, style => {\n nonInheritableStyles.add(style);\n });\n })();\n const shorthandStyleProps = [\n 'font',\n 'text-decoration',\n 'text-emphasis'\n ];\n const getStyleProps = (dom, node) => keys(dom.parseStyle(dom.getAttrib(node, 'style')));\n const isNonInheritableStyle = style => nonInheritableStyles.has(style);\n const hasInheritableStyles = (dom, node) => forall(getStyleProps(dom, node), style => !isNonInheritableStyle(style));\n const getLonghandStyleProps = styles => filter$5(styles, style => exists(shorthandStyleProps, prop => startsWith(style, prop)));\n const hasStyleConflict = (dom, node, parentNode) => {\n const nodeStyleProps = getStyleProps(dom, node);\n const parentNodeStyleProps = getStyleProps(dom, parentNode);\n const valueMismatch = prop => {\n var _a, _b;\n const nodeValue = (_a = dom.getStyle(node, prop)) !== null && _a !== void 0 ? _a : '';\n const parentValue = (_b = dom.getStyle(parentNode, prop)) !== null && _b !== void 0 ? _b : '';\n return isNotEmpty(nodeValue) && isNotEmpty(parentValue) && nodeValue !== parentValue;\n };\n return exists(nodeStyleProps, nodeStyleProp => {\n const propExists = props => exists(props, prop => prop === nodeStyleProp);\n if (!propExists(parentNodeStyleProps) && propExists(shorthandStyleProps)) {\n const longhandProps = getLonghandStyleProps(parentNodeStyleProps);\n return exists(longhandProps, valueMismatch);\n } else {\n return valueMismatch(nodeStyleProp);\n }\n });\n };\n\n const isChar = (forward, predicate, pos) => Optional.from(pos.container()).filter(isText$a).exists(text => {\n const delta = forward ? 0 : -1;\n return predicate(text.data.charAt(pos.offset() + delta));\n });\n const isBeforeSpace = curry(isChar, true, isWhiteSpace);\n const isAfterSpace = curry(isChar, false, isWhiteSpace);\n const isEmptyText = pos => {\n const container = pos.container();\n return isText$a(container) && (container.data.length === 0 || isZwsp(container.data) && BookmarkManager.isBookmarkNode(container.parentNode));\n };\n const matchesElementPosition = (before, predicate) => pos => getChildNodeAtRelativeOffset(before ? 0 : -1, pos).filter(predicate).isSome();\n const isImageBlock = node => isImg(node) && get$7(SugarElement.fromDom(node), 'display') === 'block';\n const isCefNode = node => isContentEditableFalse$a(node) && !isBogusAll$1(node);\n const isBeforeImageBlock = matchesElementPosition(true, isImageBlock);\n const isAfterImageBlock = matchesElementPosition(false, isImageBlock);\n const isBeforeMedia = matchesElementPosition(true, isMedia$2);\n const isAfterMedia = matchesElementPosition(false, isMedia$2);\n const isBeforeTable = matchesElementPosition(true, isTable$2);\n const isAfterTable = matchesElementPosition(false, isTable$2);\n const isBeforeContentEditableFalse = matchesElementPosition(true, isCefNode);\n const isAfterContentEditableFalse = matchesElementPosition(false, isCefNode);\n\n const dropLast = xs => xs.slice(0, -1);\n const parentsUntil = (start, root, predicate) => {\n if (contains(root, start)) {\n return dropLast(parents$1(start, elm => {\n return predicate(elm) || eq(elm, root);\n }));\n } else {\n return [];\n }\n };\n const parents = (start, root) => parentsUntil(start, root, never);\n const parentsAndSelf = (start, root) => [start].concat(parents(start, root));\n\n const navigateIgnoreEmptyTextNodes = (forward, root, from) => navigateIgnore(forward, root, from, isEmptyText);\n const getClosestBlock$1 = (root, pos) => find$2(parentsAndSelf(SugarElement.fromDom(pos.container()), root), isBlock$2);\n const isAtBeforeAfterBlockBoundary = (forward, root, pos) => navigateIgnoreEmptyTextNodes(forward, root.dom, pos).forall(newPos => getClosestBlock$1(root, pos).fold(() => !isInSameBlock(newPos, pos, root.dom), fromBlock => !isInSameBlock(newPos, pos, root.dom) && contains(fromBlock, SugarElement.fromDom(newPos.container()))));\n const isAtBlockBoundary = (forward, root, pos) => getClosestBlock$1(root, pos).fold(() => navigateIgnoreEmptyTextNodes(forward, root.dom, pos).forall(newPos => !isInSameBlock(newPos, pos, root.dom)), parent => navigateIgnoreEmptyTextNodes(forward, parent.dom, pos).isNone());\n const isAtStartOfBlock = curry(isAtBlockBoundary, false);\n const isAtEndOfBlock = curry(isAtBlockBoundary, true);\n const isBeforeBlock = curry(isAtBeforeAfterBlockBoundary, false);\n const isAfterBlock = curry(isAtBeforeAfterBlockBoundary, true);\n\n const isBr$1 = pos => getElementFromPosition(pos).exists(isBr$5);\n const findBr = (forward, root, pos) => {\n const parentBlocks = filter$5(parentsAndSelf(SugarElement.fromDom(pos.container()), root), isBlock$2);\n const scope = head(parentBlocks).getOr(root);\n return fromPosition(forward, scope.dom, pos).filter(isBr$1);\n };\n const isBeforeBr$1 = (root, pos) => getElementFromPosition(pos).exists(isBr$5) || findBr(true, root, pos).isSome();\n const isAfterBr = (root, pos) => getElementFromPrevPosition(pos).exists(isBr$5) || findBr(false, root, pos).isSome();\n const findPreviousBr = curry(findBr, false);\n const findNextBr = curry(findBr, true);\n\n const isInMiddleOfText = pos => CaretPosition.isTextPosition(pos) && !pos.isAtStart() && !pos.isAtEnd();\n const getClosestBlock = (root, pos) => {\n const parentBlocks = filter$5(parentsAndSelf(SugarElement.fromDom(pos.container()), root), isBlock$2);\n return head(parentBlocks).getOr(root);\n };\n const hasSpaceBefore = (root, pos) => {\n if (isInMiddleOfText(pos)) {\n return isAfterSpace(pos);\n } else {\n return isAfterSpace(pos) || prevPosition(getClosestBlock(root, pos).dom, pos).exists(isAfterSpace);\n }\n };\n const hasSpaceAfter = (root, pos) => {\n if (isInMiddleOfText(pos)) {\n return isBeforeSpace(pos);\n } else {\n return isBeforeSpace(pos) || nextPosition(getClosestBlock(root, pos).dom, pos).exists(isBeforeSpace);\n }\n };\n const isPreValue = value => contains$2([\n 'pre',\n 'pre-wrap'\n ], value);\n const isInPre = pos => getElementFromPosition(pos).bind(elm => closest$4(elm, isElement$7)).exists(elm => isPreValue(get$7(elm, 'white-space')));\n const isAtBeginningOfBody = (root, pos) => prevPosition(root.dom, pos).isNone();\n const isAtEndOfBody = (root, pos) => nextPosition(root.dom, pos).isNone();\n const isAtLineBoundary = (root, pos) => isAtBeginningOfBody(root, pos) || isAtEndOfBody(root, pos) || isAtStartOfBlock(root, pos) || isAtEndOfBlock(root, pos) || isAfterBr(root, pos) || isBeforeBr$1(root, pos);\n const isCefBlock = node => isNonNullable(node) && isContentEditableFalse$a(node) && isBlockLike(node);\n const isSiblingCefBlock = (root, direction) => container => {\n return isCefBlock(new DomTreeWalker(container, root)[direction]());\n };\n const isBeforeCefBlock = (root, pos) => {\n const nextPos = nextPosition(root.dom, pos).getOr(pos);\n const isNextCefBlock = isSiblingCefBlock(root.dom, 'next');\n return pos.isAtEnd() && (isNextCefBlock(pos.container()) || isNextCefBlock(nextPos.container()));\n };\n const isAfterCefBlock = (root, pos) => {\n const prevPos = prevPosition(root.dom, pos).getOr(pos);\n const isPrevCefBlock = isSiblingCefBlock(root.dom, 'prev');\n return pos.isAtStart() && (isPrevCefBlock(pos.container()) || isPrevCefBlock(prevPos.container()));\n };\n const needsToHaveNbsp = (root, pos) => {\n if (isInPre(pos)) {\n return false;\n } else {\n return isAtLineBoundary(root, pos) || hasSpaceBefore(root, pos) || hasSpaceAfter(root, pos);\n }\n };\n const needsToBeNbspLeft = (root, pos) => {\n if (isInPre(pos)) {\n return false;\n } else {\n return isAtStartOfBlock(root, pos) || isBeforeBlock(root, pos) || isAfterBr(root, pos) || hasSpaceBefore(root, pos) || isAfterCefBlock(root, pos);\n }\n };\n const leanRight = pos => {\n const container = pos.container();\n const offset = pos.offset();\n if (isText$a(container) && offset < container.data.length) {\n return CaretPosition(container, offset + 1);\n } else {\n return pos;\n }\n };\n const needsToBeNbspRight = (root, pos) => {\n if (isInPre(pos)) {\n return false;\n } else {\n return isAtEndOfBlock(root, pos) || isAfterBlock(root, pos) || isBeforeBr$1(root, pos) || hasSpaceAfter(root, pos) || isBeforeCefBlock(root, pos);\n }\n };\n const needsToBeNbsp = (root, pos) => needsToBeNbspLeft(root, pos) || needsToBeNbspRight(root, leanRight(pos));\n const isNbspAt = (text, offset) => isNbsp(text.charAt(offset));\n const isWhiteSpaceAt = (text, offset) => isWhiteSpace(text.charAt(offset));\n const hasNbsp = pos => {\n const container = pos.container();\n return isText$a(container) && contains$1(container.data, nbsp);\n };\n const normalizeNbspMiddle = text => {\n const chars = text.split('');\n return map$3(chars, (chr, i) => {\n if (isNbsp(chr) && i > 0 && i < chars.length - 1 && isContent(chars[i - 1]) && isContent(chars[i + 1])) {\n return ' ';\n } else {\n return chr;\n }\n }).join('');\n };\n const normalizeNbspAtStart = (root, node, makeNbsp) => {\n const text = node.data;\n const firstPos = CaretPosition(node, 0);\n if (!makeNbsp && isNbspAt(text, 0) && !needsToBeNbsp(root, firstPos)) {\n node.data = ' ' + text.slice(1);\n return true;\n } else if (makeNbsp && isWhiteSpaceAt(text, 0) && needsToBeNbspLeft(root, firstPos)) {\n node.data = nbsp + text.slice(1);\n return true;\n } else {\n return false;\n }\n };\n const normalizeNbspInMiddleOfTextNode = node => {\n const text = node.data;\n const newText = normalizeNbspMiddle(text);\n if (newText !== text) {\n node.data = newText;\n return true;\n } else {\n return false;\n }\n };\n const normalizeNbspAtEnd = (root, node, makeNbsp) => {\n const text = node.data;\n const lastPos = CaretPosition(node, text.length - 1);\n if (!makeNbsp && isNbspAt(text, text.length - 1) && !needsToBeNbsp(root, lastPos)) {\n node.data = text.slice(0, -1) + ' ';\n return true;\n } else if (makeNbsp && isWhiteSpaceAt(text, text.length - 1) && needsToBeNbspRight(root, lastPos)) {\n node.data = text.slice(0, -1) + nbsp;\n return true;\n } else {\n return false;\n }\n };\n const normalizeNbsps = (root, pos) => {\n const container = pos.container();\n if (!isText$a(container)) {\n return Optional.none();\n }\n if (hasNbsp(pos)) {\n const normalized = normalizeNbspAtStart(root, container, false) || normalizeNbspInMiddleOfTextNode(container) || normalizeNbspAtEnd(root, container, false);\n return someIf(normalized, pos);\n } else if (needsToBeNbsp(root, pos)) {\n const normalized = normalizeNbspAtStart(root, container, true) || normalizeNbspAtEnd(root, container, true);\n return someIf(normalized, pos);\n } else {\n return Optional.none();\n }\n };\n const normalizeNbspsInEditor = editor => {\n const root = SugarElement.fromDom(editor.getBody());\n if (editor.selection.isCollapsed()) {\n normalizeNbsps(root, CaretPosition.fromRangeStart(editor.selection.getRng())).each(pos => {\n editor.selection.setRng(pos.toRange());\n });\n }\n };\n\n const normalize$1 = (node, offset, count) => {\n if (count === 0) {\n return;\n }\n const elm = SugarElement.fromDom(node);\n const root = ancestor$3(elm, isBlock$2).getOr(elm);\n const whitespace = node.data.slice(offset, offset + count);\n const isEndOfContent = offset + count >= node.data.length && needsToBeNbspRight(root, CaretPosition(node, node.data.length));\n const isStartOfContent = offset === 0 && needsToBeNbspLeft(root, CaretPosition(node, 0));\n node.replaceData(offset, count, normalize$4(whitespace, 4, isStartOfContent, isEndOfContent));\n };\n const normalizeWhitespaceAfter = (node, offset) => {\n const content = node.data.slice(offset);\n const whitespaceCount = content.length - lTrim(content).length;\n normalize$1(node, offset, whitespaceCount);\n };\n const normalizeWhitespaceBefore = (node, offset) => {\n const content = node.data.slice(0, offset);\n const whitespaceCount = content.length - rTrim(content).length;\n normalize$1(node, offset - whitespaceCount, whitespaceCount);\n };\n const mergeTextNodes = (prevNode, nextNode, normalizeWhitespace, mergeToPrev = true) => {\n const whitespaceOffset = rTrim(prevNode.data).length;\n const newNode = mergeToPrev ? prevNode : nextNode;\n const removeNode = mergeToPrev ? nextNode : prevNode;\n if (mergeToPrev) {\n newNode.appendData(removeNode.data);\n } else {\n newNode.insertData(0, removeNode.data);\n }\n remove$6(SugarElement.fromDom(removeNode));\n if (normalizeWhitespace) {\n normalizeWhitespaceAfter(newNode, whitespaceOffset);\n }\n return newNode;\n };\n\n const needsReposition = (pos, elm) => {\n const container = pos.container();\n const offset = pos.offset();\n return !CaretPosition.isTextPosition(pos) && container === elm.parentNode && offset > CaretPosition.before(elm).offset();\n };\n const reposition = (elm, pos) => needsReposition(pos, elm) ? CaretPosition(pos.container(), pos.offset() - 1) : pos;\n const beforeOrStartOf = node => isText$a(node) ? CaretPosition(node, 0) : CaretPosition.before(node);\n const afterOrEndOf = node => isText$a(node) ? CaretPosition(node, node.data.length) : CaretPosition.after(node);\n const getPreviousSiblingCaretPosition = elm => {\n if (isCaretCandidate$3(elm.previousSibling)) {\n return Optional.some(afterOrEndOf(elm.previousSibling));\n } else {\n return elm.previousSibling ? lastPositionIn(elm.previousSibling) : Optional.none();\n }\n };\n const getNextSiblingCaretPosition = elm => {\n if (isCaretCandidate$3(elm.nextSibling)) {\n return Optional.some(beforeOrStartOf(elm.nextSibling));\n } else {\n return elm.nextSibling ? firstPositionIn(elm.nextSibling) : Optional.none();\n }\n };\n const findCaretPositionBackwardsFromElm = (rootElement, elm) => {\n return Optional.from(elm.previousSibling ? elm.previousSibling : elm.parentNode).bind(node => prevPosition(rootElement, CaretPosition.before(node))).orThunk(() => nextPosition(rootElement, CaretPosition.after(elm)));\n };\n const findCaretPositionForwardsFromElm = (rootElement, elm) => nextPosition(rootElement, CaretPosition.after(elm)).orThunk(() => prevPosition(rootElement, CaretPosition.before(elm)));\n const findCaretPositionBackwards = (rootElement, elm) => getPreviousSiblingCaretPosition(elm).orThunk(() => getNextSiblingCaretPosition(elm)).orThunk(() => findCaretPositionBackwardsFromElm(rootElement, elm));\n const findCaretPositionForward = (rootElement, elm) => getNextSiblingCaretPosition(elm).orThunk(() => getPreviousSiblingCaretPosition(elm)).orThunk(() => findCaretPositionForwardsFromElm(rootElement, elm));\n const findCaretPosition = (forward, rootElement, elm) => forward ? findCaretPositionForward(rootElement, elm) : findCaretPositionBackwards(rootElement, elm);\n const findCaretPosOutsideElmAfterDelete = (forward, rootElement, elm) => findCaretPosition(forward, rootElement, elm).map(curry(reposition, elm));\n const setSelection$1 = (editor, forward, pos) => {\n pos.fold(() => {\n editor.focus();\n }, pos => {\n editor.selection.setRng(pos.toRange(), forward);\n });\n };\n const eqRawNode = rawNode => elm => elm.dom === rawNode;\n const isBlock = (editor, elm) => elm && has$2(editor.schema.getBlockElements(), name(elm));\n const paddEmptyBlock = elm => {\n if (isEmpty$2(elm)) {\n const br = SugarElement.fromHtml('
');\n empty(elm);\n append$1(elm, br);\n return Optional.some(CaretPosition.before(br.dom));\n } else {\n return Optional.none();\n }\n };\n const deleteNormalized = (elm, afterDeletePosOpt, normalizeWhitespace) => {\n const prevTextOpt = prevSibling(elm).filter(isText$b);\n const nextTextOpt = nextSibling(elm).filter(isText$b);\n remove$6(elm);\n return lift3(prevTextOpt, nextTextOpt, afterDeletePosOpt, (prev, next, pos) => {\n const prevNode = prev.dom, nextNode = next.dom;\n const offset = prevNode.data.length;\n mergeTextNodes(prevNode, nextNode, normalizeWhitespace);\n return pos.container() === nextNode ? CaretPosition(prevNode, offset) : pos;\n }).orThunk(() => {\n if (normalizeWhitespace) {\n prevTextOpt.each(elm => normalizeWhitespaceBefore(elm.dom, elm.dom.length));\n nextTextOpt.each(elm => normalizeWhitespaceAfter(elm.dom, 0));\n }\n return afterDeletePosOpt;\n });\n };\n const isInlineElement = (editor, element) => has$2(editor.schema.getTextInlineElements(), name(element));\n const deleteElement$2 = (editor, forward, elm, moveCaret = true) => {\n const afterDeletePos = findCaretPosOutsideElmAfterDelete(forward, editor.getBody(), elm.dom);\n const parentBlock = ancestor$3(elm, curry(isBlock, editor), eqRawNode(editor.getBody()));\n const normalizedAfterDeletePos = deleteNormalized(elm, afterDeletePos, isInlineElement(editor, elm));\n if (editor.dom.isEmpty(editor.getBody())) {\n editor.setContent('');\n editor.selection.setCursorLocation();\n } else {\n parentBlock.bind(paddEmptyBlock).fold(() => {\n if (moveCaret) {\n setSelection$1(editor, forward, normalizedAfterDeletePos);\n }\n }, paddPos => {\n if (moveCaret) {\n setSelection$1(editor, forward, Optional.some(paddPos));\n }\n });\n }\n };\n\n const strongRtl = /[\\u0591-\\u07FF\\uFB1D-\\uFDFF\\uFE70-\\uFEFC]/;\n const hasStrongRtl = text => strongRtl.test(text);\n\n const isInlineTarget = (editor, elm) => is$1(SugarElement.fromDom(elm), getInlineBoundarySelector(editor)) && !isTransparentBlock(editor.schema, elm);\n const isRtl = element => {\n var _a;\n return DOMUtils.DOM.getStyle(element, 'direction', true) === 'rtl' || hasStrongRtl((_a = element.textContent) !== null && _a !== void 0 ? _a : '');\n };\n const findInlineParents = (isInlineTarget, rootNode, pos) => filter$5(DOMUtils.DOM.getParents(pos.container(), '*', rootNode), isInlineTarget);\n const findRootInline = (isInlineTarget, rootNode, pos) => {\n const parents = findInlineParents(isInlineTarget, rootNode, pos);\n return Optional.from(parents[parents.length - 1]);\n };\n const hasSameParentBlock = (rootNode, node1, node2) => {\n const block1 = getParentBlock$3(node1, rootNode);\n const block2 = getParentBlock$3(node2, rootNode);\n return isNonNullable(block1) && block1 === block2;\n };\n const isAtZwsp = pos => isBeforeInline(pos) || isAfterInline(pos);\n const normalizePosition = (forward, pos) => {\n const container = pos.container(), offset = pos.offset();\n if (forward) {\n if (isCaretContainerInline(container)) {\n if (isText$a(container.nextSibling)) {\n return CaretPosition(container.nextSibling, 0);\n } else {\n return CaretPosition.after(container);\n }\n } else {\n return isBeforeInline(pos) ? CaretPosition(container, offset + 1) : pos;\n }\n } else {\n if (isCaretContainerInline(container)) {\n if (isText$a(container.previousSibling)) {\n return CaretPosition(container.previousSibling, container.previousSibling.data.length);\n } else {\n return CaretPosition.before(container);\n }\n } else {\n return isAfterInline(pos) ? CaretPosition(container, offset - 1) : pos;\n }\n }\n };\n const normalizeForwards = curry(normalizePosition, true);\n const normalizeBackwards = curry(normalizePosition, false);\n\n const execCommandIgnoreInputEvents = (editor, command) => {\n const inputBlocker = e => e.stopImmediatePropagation();\n editor.on('beforeinput input', inputBlocker, true);\n editor.getDoc().execCommand(command);\n editor.off('beforeinput input', inputBlocker);\n };\n const execEditorDeleteCommand = editor => {\n editor.execCommand('delete');\n };\n const execNativeDeleteCommand = editor => execCommandIgnoreInputEvents(editor, 'Delete');\n const execNativeForwardDeleteCommand = editor => execCommandIgnoreInputEvents(editor, 'ForwardDelete');\n const isBeforeRoot = rootNode => elm => is$2(parent(elm), rootNode, eq);\n const isTextBlockOrListItem = element => isTextBlock$2(element) || isListItem$1(element);\n const getParentBlock$2 = (rootNode, elm) => {\n if (contains(rootNode, elm)) {\n return closest$4(elm, isTextBlockOrListItem, isBeforeRoot(rootNode));\n } else {\n return Optional.none();\n }\n };\n const paddEmptyBody = (editor, moveSelection = true) => {\n if (editor.dom.isEmpty(editor.getBody())) {\n editor.setContent('', { no_selection: !moveSelection });\n }\n };\n const willDeleteLastPositionInElement = (forward, fromPos, elm) => lift2(firstPositionIn(elm), lastPositionIn(elm), (firstPos, lastPos) => {\n const normalizedFirstPos = normalizePosition(true, firstPos);\n const normalizedLastPos = normalizePosition(false, lastPos);\n const normalizedFromPos = normalizePosition(false, fromPos);\n if (forward) {\n return nextPosition(elm, normalizedFromPos).exists(nextPos => nextPos.isEqual(normalizedLastPos) && fromPos.isEqual(normalizedFirstPos));\n } else {\n return prevPosition(elm, normalizedFromPos).exists(prevPos => prevPos.isEqual(normalizedFirstPos) && fromPos.isEqual(normalizedLastPos));\n }\n }).getOr(true);\n const freefallRtl = root => {\n const child = isComment$1(root) ? prevSibling(root) : lastChild(root);\n return child.bind(freefallRtl).orThunk(() => Optional.some(root));\n };\n const deleteRangeContents = (editor, rng, root, moveSelection = true) => {\n var _a;\n rng.deleteContents();\n const lastNode = freefallRtl(root).getOr(root);\n const lastBlock = SugarElement.fromDom((_a = editor.dom.getParent(lastNode.dom, editor.dom.isBlock)) !== null && _a !== void 0 ? _a : root.dom);\n if (lastBlock.dom === editor.getBody()) {\n paddEmptyBody(editor, moveSelection);\n } else if (isEmpty$2(lastBlock)) {\n fillWithPaddingBr(lastBlock);\n if (moveSelection) {\n editor.selection.setCursorLocation(lastBlock.dom, 0);\n }\n }\n if (!eq(root, lastBlock)) {\n const additionalCleanupNodes = is$2(parent(lastBlock), root) ? [] : siblings(lastBlock);\n each$e(additionalCleanupNodes.concat(children$1(root)), node => {\n if (!eq(node, lastBlock) && !contains(node, lastBlock) && isEmpty$2(node)) {\n remove$6(node);\n }\n });\n }\n };\n\n const isRootFromElement = root => cur => eq(root, cur);\n const getTableCells = table => descendants(table, 'td,th');\n const getTableDetailsFromRange = (rng, isRoot) => {\n const getTable = node => getClosestTable(SugarElement.fromDom(node), isRoot);\n const startTable = getTable(rng.startContainer);\n const endTable = getTable(rng.endContainer);\n const isStartInTable = startTable.isSome();\n const isEndInTable = endTable.isSome();\n const isSameTable = lift2(startTable, endTable, eq).getOr(false);\n const isMultiTable = !isSameTable && isStartInTable && isEndInTable;\n return {\n startTable,\n endTable,\n isStartInTable,\n isEndInTable,\n isSameTable,\n isMultiTable\n };\n };\n\n const tableCellRng = (start, end) => ({\n start,\n end\n });\n const tableSelection = (rng, table, cells) => ({\n rng,\n table,\n cells\n });\n const deleteAction = Adt.generate([\n {\n singleCellTable: [\n 'rng',\n 'cell'\n ]\n },\n { fullTable: ['table'] },\n {\n partialTable: [\n 'cells',\n 'outsideDetails'\n ]\n },\n {\n multiTable: [\n 'startTableCells',\n 'endTableCells',\n 'betweenRng'\n ]\n }\n ]);\n const getClosestCell$1 = (container, isRoot) => closest$3(SugarElement.fromDom(container), 'td,th', isRoot);\n const isExpandedCellRng = cellRng => !eq(cellRng.start, cellRng.end);\n const getTableFromCellRng = (cellRng, isRoot) => getClosestTable(cellRng.start, isRoot).bind(startParentTable => getClosestTable(cellRng.end, isRoot).bind(endParentTable => someIf(eq(startParentTable, endParentTable), startParentTable)));\n const isSingleCellTable = (cellRng, isRoot) => !isExpandedCellRng(cellRng) && getTableFromCellRng(cellRng, isRoot).exists(table => {\n const rows = table.dom.rows;\n return rows.length === 1 && rows[0].cells.length === 1;\n });\n const getCellRng = (rng, isRoot) => {\n const startCell = getClosestCell$1(rng.startContainer, isRoot);\n const endCell = getClosestCell$1(rng.endContainer, isRoot);\n return lift2(startCell, endCell, tableCellRng);\n };\n const getCellRangeFromStartTable = isRoot => startCell => getClosestTable(startCell, isRoot).bind(table => last$3(getTableCells(table)).map(endCell => tableCellRng(startCell, endCell)));\n const getCellRangeFromEndTable = isRoot => endCell => getClosestTable(endCell, isRoot).bind(table => head(getTableCells(table)).map(startCell => tableCellRng(startCell, endCell)));\n const getTableSelectionFromCellRng = isRoot => cellRng => getTableFromCellRng(cellRng, isRoot).map(table => tableSelection(cellRng, table, getTableCells(table)));\n const getTableSelections = (cellRng, selectionDetails, rng, isRoot) => {\n if (rng.collapsed || !cellRng.forall(isExpandedCellRng)) {\n return Optional.none();\n } else if (selectionDetails.isSameTable) {\n const sameTableSelection = cellRng.bind(getTableSelectionFromCellRng(isRoot));\n return Optional.some({\n start: sameTableSelection,\n end: sameTableSelection\n });\n } else {\n const startCell = getClosestCell$1(rng.startContainer, isRoot);\n const endCell = getClosestCell$1(rng.endContainer, isRoot);\n const startTableSelection = startCell.bind(getCellRangeFromStartTable(isRoot)).bind(getTableSelectionFromCellRng(isRoot));\n const endTableSelection = endCell.bind(getCellRangeFromEndTable(isRoot)).bind(getTableSelectionFromCellRng(isRoot));\n return Optional.some({\n start: startTableSelection,\n end: endTableSelection\n });\n }\n };\n const getCellIndex = (cells, cell) => findIndex$2(cells, x => eq(x, cell));\n const getSelectedCells = tableSelection => lift2(getCellIndex(tableSelection.cells, tableSelection.rng.start), getCellIndex(tableSelection.cells, tableSelection.rng.end), (startIndex, endIndex) => tableSelection.cells.slice(startIndex, endIndex + 1));\n const isSingleCellTableContentSelected = (optCellRng, rng, isRoot) => optCellRng.exists(cellRng => isSingleCellTable(cellRng, isRoot) && hasAllContentsSelected(cellRng.start, rng));\n const unselectCells = (rng, selectionDetails) => {\n const {startTable, endTable} = selectionDetails;\n const otherContentRng = rng.cloneRange();\n startTable.each(table => otherContentRng.setStartAfter(table.dom));\n endTable.each(table => otherContentRng.setEndBefore(table.dom));\n return otherContentRng;\n };\n const handleSingleTable = (cellRng, selectionDetails, rng, isRoot) => getTableSelections(cellRng, selectionDetails, rng, isRoot).bind(({start, end}) => start.or(end)).bind(tableSelection => {\n const {isSameTable} = selectionDetails;\n const selectedCells = getSelectedCells(tableSelection).getOr([]);\n if (isSameTable && tableSelection.cells.length === selectedCells.length) {\n return Optional.some(deleteAction.fullTable(tableSelection.table));\n } else if (selectedCells.length > 0) {\n if (isSameTable) {\n return Optional.some(deleteAction.partialTable(selectedCells, Optional.none()));\n } else {\n const otherContentRng = unselectCells(rng, selectionDetails);\n return Optional.some(deleteAction.partialTable(selectedCells, Optional.some({\n ...selectionDetails,\n rng: otherContentRng\n })));\n }\n } else {\n return Optional.none();\n }\n });\n const handleMultiTable = (cellRng, selectionDetails, rng, isRoot) => getTableSelections(cellRng, selectionDetails, rng, isRoot).bind(({start, end}) => {\n const startTableSelectedCells = start.bind(getSelectedCells).getOr([]);\n const endTableSelectedCells = end.bind(getSelectedCells).getOr([]);\n if (startTableSelectedCells.length > 0 && endTableSelectedCells.length > 0) {\n const otherContentRng = unselectCells(rng, selectionDetails);\n return Optional.some(deleteAction.multiTable(startTableSelectedCells, endTableSelectedCells, otherContentRng));\n } else {\n return Optional.none();\n }\n });\n const getActionFromRange = (root, rng) => {\n const isRoot = isRootFromElement(root);\n const optCellRng = getCellRng(rng, isRoot);\n const selectionDetails = getTableDetailsFromRange(rng, isRoot);\n if (isSingleCellTableContentSelected(optCellRng, rng, isRoot)) {\n return optCellRng.map(cellRng => deleteAction.singleCellTable(rng, cellRng.start));\n } else if (selectionDetails.isMultiTable) {\n return handleMultiTable(optCellRng, selectionDetails, rng, isRoot);\n } else {\n return handleSingleTable(optCellRng, selectionDetails, rng, isRoot);\n }\n };\n\n const cleanCells = cells => each$e(cells, cell => {\n remove$b(cell, 'contenteditable');\n fillWithPaddingBr(cell);\n });\n const getOutsideBlock = (editor, container) => Optional.from(editor.dom.getParent(container, editor.dom.isBlock)).map(SugarElement.fromDom);\n const handleEmptyBlock = (editor, startInTable, emptyBlock) => {\n emptyBlock.each(block => {\n if (startInTable) {\n remove$6(block);\n } else {\n fillWithPaddingBr(block);\n editor.selection.setCursorLocation(block.dom, 0);\n }\n });\n };\n const deleteContentInsideCell = (editor, cell, rng, isFirstCellInSelection) => {\n const insideTableRng = rng.cloneRange();\n if (isFirstCellInSelection) {\n insideTableRng.setStart(rng.startContainer, rng.startOffset);\n insideTableRng.setEndAfter(cell.dom.lastChild);\n } else {\n insideTableRng.setStartBefore(cell.dom.firstChild);\n insideTableRng.setEnd(rng.endContainer, rng.endOffset);\n }\n deleteCellContents(editor, insideTableRng, cell, false).each(action => action());\n };\n const collapseAndRestoreCellSelection = editor => {\n const selectedCells = getCellsFromEditor(editor);\n const selectedNode = SugarElement.fromDom(editor.selection.getNode());\n if (isTableCell$3(selectedNode.dom) && isEmpty$2(selectedNode)) {\n editor.selection.setCursorLocation(selectedNode.dom, 0);\n } else {\n editor.selection.collapse(true);\n }\n if (selectedCells.length > 1 && exists(selectedCells, cell => eq(cell, selectedNode))) {\n set$2(selectedNode, 'data-mce-selected', '1');\n }\n };\n const emptySingleTableCells = (editor, cells, outsideDetails) => Optional.some(() => {\n const editorRng = editor.selection.getRng();\n const cellsToClean = outsideDetails.bind(({rng, isStartInTable}) => {\n const outsideBlock = getOutsideBlock(editor, isStartInTable ? rng.endContainer : rng.startContainer);\n rng.deleteContents();\n handleEmptyBlock(editor, isStartInTable, outsideBlock.filter(isEmpty$2));\n const endPointCell = isStartInTable ? cells[0] : cells[cells.length - 1];\n deleteContentInsideCell(editor, endPointCell, editorRng, isStartInTable);\n if (!isEmpty$2(endPointCell)) {\n return Optional.some(isStartInTable ? cells.slice(1) : cells.slice(0, -1));\n } else {\n return Optional.none();\n }\n }).getOr(cells);\n cleanCells(cellsToClean);\n collapseAndRestoreCellSelection(editor);\n });\n const emptyMultiTableCells = (editor, startTableCells, endTableCells, betweenRng) => Optional.some(() => {\n const rng = editor.selection.getRng();\n const startCell = startTableCells[0];\n const endCell = endTableCells[endTableCells.length - 1];\n deleteContentInsideCell(editor, startCell, rng, true);\n deleteContentInsideCell(editor, endCell, rng, false);\n const startTableCellsToClean = isEmpty$2(startCell) ? startTableCells : startTableCells.slice(1);\n const endTableCellsToClean = isEmpty$2(endCell) ? endTableCells : endTableCells.slice(0, -1);\n cleanCells(startTableCellsToClean.concat(endTableCellsToClean));\n betweenRng.deleteContents();\n collapseAndRestoreCellSelection(editor);\n });\n const deleteCellContents = (editor, rng, cell, moveSelection = true) => Optional.some(() => {\n deleteRangeContents(editor, rng, cell, moveSelection);\n });\n const deleteTableElement = (editor, table) => Optional.some(() => deleteElement$2(editor, false, table));\n const deleteCellRange = (editor, rootElm, rng) => getActionFromRange(rootElm, rng).bind(action => action.fold(curry(deleteCellContents, editor), curry(deleteTableElement, editor), curry(emptySingleTableCells, editor), curry(emptyMultiTableCells, editor)));\n const deleteCaptionRange = (editor, caption) => emptyElement(editor, caption);\n const deleteTableRange = (editor, rootElm, rng, startElm) => getParentCaption(rootElm, startElm).fold(() => deleteCellRange(editor, rootElm, rng), caption => deleteCaptionRange(editor, caption));\n const deleteRange$2 = (editor, startElm, selectedCells) => {\n const rootNode = SugarElement.fromDom(editor.getBody());\n const rng = editor.selection.getRng();\n return selectedCells.length !== 0 ? emptySingleTableCells(editor, selectedCells, Optional.none()) : deleteTableRange(editor, rootNode, rng, startElm);\n };\n const getParentCell = (rootElm, elm) => find$2(parentsAndSelf(elm, rootElm), isTableCell$2);\n const getParentCaption = (rootElm, elm) => find$2(parentsAndSelf(elm, rootElm), isTag('caption'));\n const deleteBetweenCells = (editor, rootElm, forward, fromCell, from) => navigate(forward, editor.getBody(), from).bind(to => getParentCell(rootElm, SugarElement.fromDom(to.getNode())).bind(toCell => eq(toCell, fromCell) ? Optional.none() : Optional.some(noop)));\n const emptyElement = (editor, elm) => Optional.some(() => {\n fillWithPaddingBr(elm);\n editor.selection.setCursorLocation(elm.dom, 0);\n });\n const isDeleteOfLastCharPos = (fromCaption, forward, from, to) => firstPositionIn(fromCaption.dom).bind(first => lastPositionIn(fromCaption.dom).map(last => forward ? from.isEqual(first) && to.isEqual(last) : from.isEqual(last) && to.isEqual(first))).getOr(true);\n const emptyCaretCaption = (editor, elm) => emptyElement(editor, elm);\n const validateCaretCaption = (rootElm, fromCaption, to) => getParentCaption(rootElm, SugarElement.fromDom(to.getNode())).fold(() => Optional.some(noop), toCaption => someIf(!eq(toCaption, fromCaption), noop));\n const deleteCaretInsideCaption = (editor, rootElm, forward, fromCaption, from) => navigate(forward, editor.getBody(), from).fold(() => Optional.some(noop), to => isDeleteOfLastCharPos(fromCaption, forward, from, to) ? emptyCaretCaption(editor, fromCaption) : validateCaretCaption(rootElm, fromCaption, to));\n const deleteCaretCells = (editor, forward, rootElm, startElm) => {\n const from = CaretPosition.fromRangeStart(editor.selection.getRng());\n return getParentCell(rootElm, startElm).bind(fromCell => isEmpty$2(fromCell) ? emptyElement(editor, fromCell) : deleteBetweenCells(editor, rootElm, forward, fromCell, from));\n };\n const deleteCaretCaption = (editor, forward, rootElm, fromCaption) => {\n const from = CaretPosition.fromRangeStart(editor.selection.getRng());\n return isEmpty$2(fromCaption) ? emptyElement(editor, fromCaption) : deleteCaretInsideCaption(editor, rootElm, forward, fromCaption, from);\n };\n const isNearTable = (forward, pos) => forward ? isBeforeTable(pos) : isAfterTable(pos);\n const isBeforeOrAfterTable = (editor, forward) => {\n const fromPos = CaretPosition.fromRangeStart(editor.selection.getRng());\n return isNearTable(forward, fromPos) || fromPosition(forward, editor.getBody(), fromPos).exists(pos => isNearTable(forward, pos));\n };\n const deleteCaret$3 = (editor, forward, startElm) => {\n const rootElm = SugarElement.fromDom(editor.getBody());\n return getParentCaption(rootElm, startElm).fold(() => deleteCaretCells(editor, forward, rootElm, startElm).orThunk(() => someIf(isBeforeOrAfterTable(editor, forward), noop)), fromCaption => deleteCaretCaption(editor, forward, rootElm, fromCaption));\n };\n const backspaceDelete$9 = (editor, forward) => {\n const startElm = SugarElement.fromDom(editor.selection.getStart(true));\n const cells = getCellsFromEditor(editor);\n return editor.selection.isCollapsed() && cells.length === 0 ? deleteCaret$3(editor, forward, startElm) : deleteRange$2(editor, startElm, cells);\n };\n\n const getContentEditableRoot$1 = (root, node) => {\n let tempNode = node;\n while (tempNode && tempNode !== root) {\n if (isContentEditableTrue$3(tempNode) || isContentEditableFalse$a(tempNode)) {\n return tempNode;\n }\n tempNode = tempNode.parentNode;\n }\n return null;\n };\n\n const internalAttributesPrefixes = [\n 'data-ephox-',\n 'data-mce-',\n 'data-alloy-',\n 'data-snooker-',\n '_'\n ];\n const each$9 = Tools.each;\n const ElementUtils = editor => {\n const dom = editor.dom;\n const internalAttributes = new Set(editor.serializer.getTempAttrs());\n const compare = (node1, node2) => {\n if (node1.nodeName !== node2.nodeName || node1.nodeType !== node2.nodeType) {\n return false;\n }\n const getAttribs = node => {\n const attribs = {};\n each$9(dom.getAttribs(node), attr => {\n const name = attr.nodeName.toLowerCase();\n if (name !== 'style' && !isAttributeInternal(name)) {\n attribs[name] = dom.getAttrib(node, name);\n }\n });\n return attribs;\n };\n const compareObjects = (obj1, obj2) => {\n for (const name in obj1) {\n if (has$2(obj1, name)) {\n const value = obj2[name];\n if (isUndefined(value)) {\n return false;\n }\n if (obj1[name] !== value) {\n return false;\n }\n delete obj2[name];\n }\n }\n for (const name in obj2) {\n if (has$2(obj2, name)) {\n return false;\n }\n }\n return true;\n };\n if (isElement$6(node1) && isElement$6(node2)) {\n if (!compareObjects(getAttribs(node1), getAttribs(node2))) {\n return false;\n }\n if (!compareObjects(dom.parseStyle(dom.getAttrib(node1, 'style')), dom.parseStyle(dom.getAttrib(node2, 'style')))) {\n return false;\n }\n }\n return !isBookmarkNode$1(node1) && !isBookmarkNode$1(node2);\n };\n const isAttributeInternal = attributeName => exists(internalAttributesPrefixes, value => startsWith(attributeName, value)) || internalAttributes.has(attributeName);\n return {\n compare,\n isAttributeInternal\n };\n };\n\n const traverse = (root, fn) => {\n let node = root;\n while (node = node.walk()) {\n fn(node);\n }\n };\n const matchNode$1 = (nodeFilters, attributeFilters, node, matches) => {\n const name = node.name;\n for (let ni = 0, nl = nodeFilters.length; ni < nl; ni++) {\n const filter = nodeFilters[ni];\n if (filter.name === name) {\n const match = matches.nodes[name];\n if (match) {\n match.nodes.push(node);\n } else {\n matches.nodes[name] = {\n filter,\n nodes: [node]\n };\n }\n }\n }\n if (node.attributes) {\n for (let ai = 0, al = attributeFilters.length; ai < al; ai++) {\n const filter = attributeFilters[ai];\n const attrName = filter.name;\n if (attrName in node.attributes.map) {\n const match = matches.attributes[attrName];\n if (match) {\n match.nodes.push(node);\n } else {\n matches.attributes[attrName] = {\n filter,\n nodes: [node]\n };\n }\n }\n }\n }\n };\n const findMatchingNodes = (nodeFilters, attributeFilters, node) => {\n const matches = {\n nodes: {},\n attributes: {}\n };\n if (node.firstChild) {\n traverse(node, childNode => {\n matchNode$1(nodeFilters, attributeFilters, childNode, matches);\n });\n }\n return matches;\n };\n const runFilters = (matches, args) => {\n const run = (matchRecord, filteringAttributes) => {\n each$d(matchRecord, match => {\n const nodes = from(match.nodes);\n each$e(match.filter.callbacks, callback => {\n for (let i = nodes.length - 1; i >= 0; i--) {\n const node = nodes[i];\n const valueMatches = filteringAttributes ? node.attr(match.filter.name) !== undefined : node.name === match.filter.name;\n if (!valueMatches || isNullable(node.parent)) {\n nodes.splice(i, 1);\n }\n }\n if (nodes.length > 0) {\n callback(nodes, match.filter.name, args);\n }\n });\n });\n };\n run(matches.nodes, false);\n run(matches.attributes, true);\n };\n const filter$2 = (nodeFilters, attributeFilters, node, args = {}) => {\n const matches = findMatchingNodes(nodeFilters, attributeFilters, node);\n runFilters(matches, args);\n };\n\n const paddEmptyNode = (args, isBlock, node) => {\n if (args.insert && isBlock(node)) {\n const astNode = new AstNode('br', 1);\n astNode.attr('data-mce-bogus', '1');\n node.empty().append(astNode);\n } else {\n node.empty().append(new AstNode('#text', 3)).value = nbsp;\n }\n };\n const isPaddedWithNbsp = node => {\n var _a;\n return hasOnlyChild(node, '#text') && ((_a = node === null || node === void 0 ? void 0 : node.firstChild) === null || _a === void 0 ? void 0 : _a.value) === nbsp;\n };\n const hasOnlyChild = (node, name) => {\n const firstChild = node === null || node === void 0 ? void 0 : node.firstChild;\n return isNonNullable(firstChild) && firstChild === node.lastChild && firstChild.name === name;\n };\n const isPadded = (schema, node) => {\n const rule = schema.getElementRule(node.name);\n return (rule === null || rule === void 0 ? void 0 : rule.paddEmpty) === true;\n };\n const isEmpty = (schema, nonEmptyElements, whitespaceElements, node) => node.isEmpty(nonEmptyElements, whitespaceElements, node => isPadded(schema, node));\n const isLineBreakNode = (node, isBlock) => isNonNullable(node) && (isBlock(node) || node.name === 'br');\n\n const removeOrUnwrapInvalidNode = (node, schema, originalNodeParent = node.parent) => {\n if (schema.getSpecialElements()[node.name]) {\n node.empty().remove();\n } else {\n const children = node.children();\n for (const childNode of children) {\n if (originalNodeParent && !schema.isValidChild(originalNodeParent.name, childNode.name)) {\n removeOrUnwrapInvalidNode(childNode, schema, originalNodeParent);\n }\n }\n node.unwrap();\n }\n };\n const cleanInvalidNodes = (nodes, schema, onCreate = noop) => {\n const textBlockElements = schema.getTextBlockElements();\n const nonEmptyElements = schema.getNonEmptyElements();\n const whitespaceElements = schema.getWhitespaceElements();\n const nonSplittableElements = Tools.makeMap('tr,td,th,tbody,thead,tfoot,table');\n const fixed = new Set();\n for (let ni = 0; ni < nodes.length; ni++) {\n const node = nodes[ni];\n let parent;\n let newParent;\n let tempNode;\n if (!node.parent || fixed.has(node)) {\n continue;\n }\n if (textBlockElements[node.name] && node.parent.name === 'li') {\n let sibling = node.next;\n while (sibling) {\n if (textBlockElements[sibling.name]) {\n sibling.name = 'li';\n fixed.add(sibling);\n node.parent.insert(sibling, node.parent);\n } else {\n break;\n }\n sibling = sibling.next;\n }\n node.unwrap();\n continue;\n }\n const parents = [node];\n for (parent = node.parent; parent && !schema.isValidChild(parent.name, node.name) && !nonSplittableElements[parent.name]; parent = parent.parent) {\n parents.push(parent);\n }\n if (parent && parents.length > 1) {\n if (schema.isValidChild(parent.name, node.name)) {\n parents.reverse();\n newParent = parents[0].clone();\n onCreate(newParent);\n let currentNode = newParent;\n for (let i = 0; i < parents.length - 1; i++) {\n if (schema.isValidChild(currentNode.name, parents[i].name)) {\n tempNode = parents[i].clone();\n onCreate(tempNode);\n currentNode.append(tempNode);\n } else {\n tempNode = currentNode;\n }\n for (let childNode = parents[i].firstChild; childNode && childNode !== parents[i + 1];) {\n const nextNode = childNode.next;\n tempNode.append(childNode);\n childNode = nextNode;\n }\n currentNode = tempNode;\n }\n if (!isEmpty(schema, nonEmptyElements, whitespaceElements, newParent)) {\n parent.insert(newParent, parents[0], true);\n parent.insert(node, newParent);\n } else {\n parent.insert(node, parents[0], true);\n }\n parent = parents[0];\n if (isEmpty(schema, nonEmptyElements, whitespaceElements, parent) || hasOnlyChild(parent, 'br')) {\n parent.empty().remove();\n }\n } else {\n removeOrUnwrapInvalidNode(node, schema);\n }\n } else if (node.parent) {\n if (node.name === 'li') {\n let sibling = node.prev;\n if (sibling && (sibling.name === 'ul' || sibling.name === 'ol')) {\n sibling.append(node);\n continue;\n }\n sibling = node.next;\n if (sibling && (sibling.name === 'ul' || sibling.name === 'ol') && sibling.firstChild) {\n sibling.insert(node, sibling.firstChild, true);\n continue;\n }\n const wrapper = new AstNode('ul', 1);\n onCreate(wrapper);\n node.wrap(wrapper);\n continue;\n }\n if (schema.isValidChild(node.parent.name, 'div') && schema.isValidChild('div', node.name)) {\n const wrapper = new AstNode('div', 1);\n onCreate(wrapper);\n node.wrap(wrapper);\n } else {\n removeOrUnwrapInvalidNode(node, schema);\n }\n }\n }\n };\n const hasClosest = (node, parentName) => {\n let tempNode = node;\n while (tempNode) {\n if (tempNode.name === parentName) {\n return true;\n }\n tempNode = tempNode.parent;\n }\n return false;\n };\n const isInvalid = (schema, node, parent = node.parent) => {\n if (parent && schema.children[node.name] && !schema.isValidChild(parent.name, node.name)) {\n return true;\n } else if (parent && node.name === 'a' && hasClosest(parent, 'a')) {\n return true;\n } else {\n return false;\n }\n };\n\n const createRange = (sc, so, ec, eo) => {\n const rng = document.createRange();\n rng.setStart(sc, so);\n rng.setEnd(ec, eo);\n return rng;\n };\n const normalizeBlockSelectionRange = rng => {\n const startPos = CaretPosition.fromRangeStart(rng);\n const endPos = CaretPosition.fromRangeEnd(rng);\n const rootNode = rng.commonAncestorContainer;\n return fromPosition(false, rootNode, endPos).map(newEndPos => {\n if (!isInSameBlock(startPos, endPos, rootNode) && isInSameBlock(startPos, newEndPos, rootNode)) {\n return createRange(startPos.container(), startPos.offset(), newEndPos.container(), newEndPos.offset());\n } else {\n return rng;\n }\n }).getOr(rng);\n };\n const normalize = rng => rng.collapsed ? rng : normalizeBlockSelectionRange(rng);\n\n const hasOnlyOneChild$1 = node => {\n return isNonNullable(node.firstChild) && node.firstChild === node.lastChild;\n };\n const isPaddingNode = node => {\n return node.name === 'br' || node.value === nbsp;\n };\n const isPaddedEmptyBlock = (schema, node) => {\n const blockElements = schema.getBlockElements();\n return blockElements[node.name] && hasOnlyOneChild$1(node) && isPaddingNode(node.firstChild);\n };\n const isEmptyFragmentElement = (schema, node) => {\n const nonEmptyElements = schema.getNonEmptyElements();\n return isNonNullable(node) && (node.isEmpty(nonEmptyElements) || isPaddedEmptyBlock(schema, node));\n };\n const isListFragment = (schema, fragment) => {\n let firstChild = fragment.firstChild;\n let lastChild = fragment.lastChild;\n if (firstChild && firstChild.name === 'meta') {\n firstChild = firstChild.next;\n }\n if (lastChild && lastChild.attr('id') === 'mce_marker') {\n lastChild = lastChild.prev;\n }\n if (isEmptyFragmentElement(schema, lastChild)) {\n lastChild = lastChild === null || lastChild === void 0 ? void 0 : lastChild.prev;\n }\n if (!firstChild || firstChild !== lastChild) {\n return false;\n }\n return firstChild.name === 'ul' || firstChild.name === 'ol';\n };\n const cleanupDomFragment = domFragment => {\n var _a, _b;\n const firstChild = domFragment.firstChild;\n const lastChild = domFragment.lastChild;\n if (firstChild && firstChild.nodeName === 'META') {\n (_a = firstChild.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(firstChild);\n }\n if (lastChild && lastChild.id === 'mce_marker') {\n (_b = lastChild.parentNode) === null || _b === void 0 ? void 0 : _b.removeChild(lastChild);\n }\n return domFragment;\n };\n const toDomFragment = (dom, serializer, fragment) => {\n const html = serializer.serialize(fragment);\n const domFragment = dom.createFragment(html);\n return cleanupDomFragment(domFragment);\n };\n const listItems = elm => {\n var _a;\n return filter$5((_a = elm === null || elm === void 0 ? void 0 : elm.childNodes) !== null && _a !== void 0 ? _a : [], child => {\n return child.nodeName === 'LI';\n });\n };\n const isPadding = node => {\n return node.data === nbsp || isBr$6(node);\n };\n const isListItemPadded = node => {\n return isNonNullable(node === null || node === void 0 ? void 0 : node.firstChild) && node.firstChild === node.lastChild && isPadding(node.firstChild);\n };\n const isEmptyOrPadded = elm => {\n return !elm.firstChild || isListItemPadded(elm);\n };\n const trimListItems = elms => {\n return elms.length > 0 && isEmptyOrPadded(elms[elms.length - 1]) ? elms.slice(0, -1) : elms;\n };\n const getParentLi = (dom, node) => {\n const parentBlock = dom.getParent(node, dom.isBlock);\n return parentBlock && parentBlock.nodeName === 'LI' ? parentBlock : null;\n };\n const isParentBlockLi = (dom, node) => {\n return !!getParentLi(dom, node);\n };\n const getSplit = (parentNode, rng) => {\n const beforeRng = rng.cloneRange();\n const afterRng = rng.cloneRange();\n beforeRng.setStartBefore(parentNode);\n afterRng.setEndAfter(parentNode);\n return [\n beforeRng.cloneContents(),\n afterRng.cloneContents()\n ];\n };\n const findFirstIn = (node, rootNode) => {\n const caretPos = CaretPosition.before(node);\n const caretWalker = CaretWalker(rootNode);\n const newCaretPos = caretWalker.next(caretPos);\n return newCaretPos ? newCaretPos.toRange() : null;\n };\n const findLastOf = (node, rootNode) => {\n const caretPos = CaretPosition.after(node);\n const caretWalker = CaretWalker(rootNode);\n const newCaretPos = caretWalker.prev(caretPos);\n return newCaretPos ? newCaretPos.toRange() : null;\n };\n const insertMiddle = (target, elms, rootNode, rng) => {\n const parts = getSplit(target, rng);\n const parentElm = target.parentNode;\n if (parentElm) {\n parentElm.insertBefore(parts[0], target);\n Tools.each(elms, li => {\n parentElm.insertBefore(li, target);\n });\n parentElm.insertBefore(parts[1], target);\n parentElm.removeChild(target);\n }\n return findLastOf(elms[elms.length - 1], rootNode);\n };\n const insertBefore$1 = (target, elms, rootNode) => {\n const parentElm = target.parentNode;\n if (parentElm) {\n Tools.each(elms, elm => {\n parentElm.insertBefore(elm, target);\n });\n }\n return findFirstIn(target, rootNode);\n };\n const insertAfter$1 = (target, elms, rootNode, dom) => {\n dom.insertAfter(elms.reverse(), target);\n return findLastOf(elms[0], rootNode);\n };\n const insertAtCaret$1 = (serializer, dom, rng, fragment) => {\n const domFragment = toDomFragment(dom, serializer, fragment);\n const liTarget = getParentLi(dom, rng.startContainer);\n const liElms = trimListItems(listItems(domFragment.firstChild));\n const BEGINNING = 1, END = 2;\n const rootNode = dom.getRoot();\n const isAt = location => {\n const caretPos = CaretPosition.fromRangeStart(rng);\n const caretWalker = CaretWalker(dom.getRoot());\n const newPos = location === BEGINNING ? caretWalker.prev(caretPos) : caretWalker.next(caretPos);\n const newPosNode = newPos === null || newPos === void 0 ? void 0 : newPos.getNode();\n return newPosNode ? getParentLi(dom, newPosNode) !== liTarget : true;\n };\n if (!liTarget) {\n return null;\n } else if (isAt(BEGINNING)) {\n return insertBefore$1(liTarget, liElms, rootNode);\n } else if (isAt(END)) {\n return insertAfter$1(liTarget, liElms, rootNode, dom);\n } else {\n return insertMiddle(liTarget, liElms, rootNode, rng);\n }\n };\n\n const mergeableWrappedElements = ['pre'];\n const shouldPasteContentOnly = (dom, fragment, parentNode, root) => {\n var _a;\n const firstNode = fragment.firstChild;\n const lastNode = fragment.lastChild;\n const last = lastNode.attr('data-mce-type') === 'bookmark' ? lastNode.prev : lastNode;\n const isPastingSingleElement = firstNode === last;\n const isWrappedElement = contains$2(mergeableWrappedElements, firstNode.name);\n if (isPastingSingleElement && isWrappedElement) {\n const isContentEditable = firstNode.attr('contenteditable') !== 'false';\n const isPastingInTheSameBlockTag = ((_a = dom.getParent(parentNode, dom.isBlock)) === null || _a === void 0 ? void 0 : _a.nodeName.toLowerCase()) === firstNode.name;\n const isPastingInContentEditable = Optional.from(getContentEditableRoot$1(root, parentNode)).forall(isContentEditableTrue$3);\n return isContentEditable && isPastingInTheSameBlockTag && isPastingInContentEditable;\n } else {\n return false;\n }\n };\n const isTableCell = isTableCell$3;\n const isTableCellContentSelected = (dom, rng, cell) => {\n if (isNonNullable(cell)) {\n const endCell = dom.getParent(rng.endContainer, isTableCell);\n return cell === endCell && hasAllContentsSelected(SugarElement.fromDom(cell), rng);\n } else {\n return false;\n }\n };\n const validInsertion = (editor, value, parentNode) => {\n var _a;\n if (parentNode.getAttribute('data-mce-bogus') === 'all') {\n (_a = parentNode.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(editor.dom.createFragment(value), parentNode);\n } else {\n const node = parentNode.firstChild;\n const node2 = parentNode.lastChild;\n if (!node || node === node2 && node.nodeName === 'BR') {\n editor.dom.setHTML(parentNode, value);\n } else {\n editor.selection.setContent(value, { no_events: true });\n }\n }\n };\n const trimBrsFromTableCell = (dom, elm) => {\n Optional.from(dom.getParent(elm, 'td,th')).map(SugarElement.fromDom).each(trimBlockTrailingBr);\n };\n const reduceInlineTextElements = (editor, merge) => {\n const textInlineElements = editor.schema.getTextInlineElements();\n const dom = editor.dom;\n if (merge) {\n const root = editor.getBody();\n const elementUtils = ElementUtils(editor);\n Tools.each(dom.select('*[data-mce-fragment]'), node => {\n const isInline = isNonNullable(textInlineElements[node.nodeName.toLowerCase()]);\n if (isInline && hasInheritableStyles(dom, node)) {\n for (let parentNode = node.parentElement; isNonNullable(parentNode) && parentNode !== root; parentNode = parentNode.parentElement) {\n const styleConflict = hasStyleConflict(dom, node, parentNode);\n if (styleConflict) {\n break;\n }\n if (elementUtils.compare(parentNode, node)) {\n dom.remove(node, true);\n break;\n }\n }\n }\n });\n }\n };\n const markFragmentElements = fragment => {\n let node = fragment;\n while (node = node.walk()) {\n if (node.type === 1) {\n node.attr('data-mce-fragment', '1');\n }\n }\n };\n const unmarkFragmentElements = elm => {\n Tools.each(elm.getElementsByTagName('*'), elm => {\n elm.removeAttribute('data-mce-fragment');\n });\n };\n const isPartOfFragment = node => {\n return !!node.getAttribute('data-mce-fragment');\n };\n const canHaveChildren = (editor, node) => {\n return isNonNullable(node) && !editor.schema.getVoidElements()[node.nodeName];\n };\n const moveSelectionToMarker = (editor, marker) => {\n var _a, _b, _c;\n let nextRng;\n const dom = editor.dom;\n const selection = editor.selection;\n if (!marker) {\n return;\n }\n selection.scrollIntoView(marker);\n const parentEditableElm = getContentEditableRoot$1(editor.getBody(), marker);\n if (parentEditableElm && dom.getContentEditable(parentEditableElm) === 'false') {\n dom.remove(marker);\n selection.select(parentEditableElm);\n return;\n }\n let rng = dom.createRng();\n const node = marker.previousSibling;\n if (isText$a(node)) {\n rng.setStart(node, (_b = (_a = node.nodeValue) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0);\n const node2 = marker.nextSibling;\n if (isText$a(node2)) {\n node.appendData(node2.data);\n (_c = node2.parentNode) === null || _c === void 0 ? void 0 : _c.removeChild(node2);\n }\n } else {\n rng.setStartBefore(marker);\n rng.setEndBefore(marker);\n }\n const findNextCaretRng = rng => {\n let caretPos = CaretPosition.fromRangeStart(rng);\n const caretWalker = CaretWalker(editor.getBody());\n caretPos = caretWalker.next(caretPos);\n return caretPos === null || caretPos === void 0 ? void 0 : caretPos.toRange();\n };\n const parentBlock = dom.getParent(marker, dom.isBlock);\n dom.remove(marker);\n if (parentBlock && dom.isEmpty(parentBlock)) {\n empty(SugarElement.fromDom(parentBlock));\n rng.setStart(parentBlock, 0);\n rng.setEnd(parentBlock, 0);\n if (!isTableCell(parentBlock) && !isPartOfFragment(parentBlock) && (nextRng = findNextCaretRng(rng))) {\n rng = nextRng;\n dom.remove(parentBlock);\n } else {\n dom.add(parentBlock, dom.create('br', { 'data-mce-bogus': '1' }));\n }\n }\n selection.setRng(rng);\n };\n const deleteSelectedContent = editor => {\n const dom = editor.dom;\n const rng = normalize(editor.selection.getRng());\n editor.selection.setRng(rng);\n const startCell = dom.getParent(rng.startContainer, isTableCell);\n if (isTableCellContentSelected(dom, rng, startCell)) {\n deleteCellContents(editor, rng, SugarElement.fromDom(startCell));\n } else if (rng.startContainer === rng.endContainer && rng.endOffset - rng.startOffset === 1 && isText$a(rng.startContainer.childNodes[rng.startOffset])) {\n rng.deleteContents();\n } else {\n editor.getDoc().execCommand('Delete', false);\n }\n };\n const insertHtmlAtCaret = (editor, value, details) => {\n var _a, _b;\n const selection = editor.selection;\n const dom = editor.dom;\n const parser = editor.parser;\n const merge = details.merge;\n const serializer = HtmlSerializer({ validate: true }, editor.schema);\n const bookmarkHtml = '';\n if (value.indexOf('{$caret}') === -1) {\n value += '{$caret}';\n }\n value = value.replace(/\\{\\$caret\\}/, bookmarkHtml);\n let rng = selection.getRng();\n const caretElement = rng.startContainer;\n const body = editor.getBody();\n if (caretElement === body && selection.isCollapsed()) {\n if (dom.isBlock(body.firstChild) && canHaveChildren(editor, body.firstChild) && dom.isEmpty(body.firstChild)) {\n rng = dom.createRng();\n rng.setStart(body.firstChild, 0);\n rng.setEnd(body.firstChild, 0);\n selection.setRng(rng);\n }\n }\n if (!selection.isCollapsed()) {\n deleteSelectedContent(editor);\n }\n const parentNode = selection.getNode();\n const parserArgs = {\n context: parentNode.nodeName.toLowerCase(),\n data: details.data,\n insert: true\n };\n const fragment = parser.parse(value, parserArgs);\n if (details.paste === true && isListFragment(editor.schema, fragment) && isParentBlockLi(dom, parentNode)) {\n rng = insertAtCaret$1(serializer, dom, selection.getRng(), fragment);\n if (rng) {\n selection.setRng(rng);\n }\n return value;\n }\n if (details.paste === true && shouldPasteContentOnly(dom, fragment, parentNode, editor.getBody())) {\n (_a = fragment.firstChild) === null || _a === void 0 ? void 0 : _a.unwrap();\n }\n markFragmentElements(fragment);\n let node = fragment.lastChild;\n if (node && node.attr('id') === 'mce_marker') {\n const marker = node;\n for (node = node.prev; node; node = node.walk(true)) {\n if (node.type === 3 || !dom.isBlock(node.name)) {\n if (node.parent && editor.schema.isValidChild(node.parent.name, 'span')) {\n node.parent.insert(marker, node, node.name === 'br');\n }\n break;\n }\n }\n }\n editor._selectionOverrides.showBlockCaretContainer(parentNode);\n if (!parserArgs.invalid) {\n value = serializer.serialize(fragment);\n validInsertion(editor, value, parentNode);\n } else {\n editor.selection.setContent(bookmarkHtml);\n let parentNode = selection.getNode();\n let tempNode;\n const rootNode = editor.getBody();\n if (isDocument$1(parentNode)) {\n parentNode = tempNode = rootNode;\n } else {\n tempNode = parentNode;\n }\n while (tempNode && tempNode !== rootNode) {\n parentNode = tempNode;\n tempNode = tempNode.parentNode;\n }\n value = parentNode === rootNode ? rootNode.innerHTML : dom.getOuterHTML(parentNode);\n const root = parser.parse(value);\n for (let markerNode = root; markerNode; markerNode = markerNode.walk()) {\n if (markerNode.attr('id') === 'mce_marker') {\n markerNode.replace(fragment);\n break;\n }\n }\n const toExtract = fragment.children();\n const parent = (_b = fragment.parent) !== null && _b !== void 0 ? _b : root;\n fragment.unwrap();\n const invalidChildren = filter$5(toExtract, node => isInvalid(editor.schema, node, parent));\n cleanInvalidNodes(invalidChildren, editor.schema);\n filter$2(parser.getNodeFilters(), parser.getAttributeFilters(), root);\n value = serializer.serialize(root);\n if (parentNode === rootNode) {\n dom.setHTML(rootNode, value);\n } else {\n dom.setOuterHTML(parentNode, value);\n }\n }\n reduceInlineTextElements(editor, merge);\n moveSelectionToMarker(editor, dom.get('mce_marker'));\n unmarkFragmentElements(editor.getBody());\n trimBrsFromTableCell(dom, selection.getStart());\n updateCaret(editor.schema, editor.getBody(), selection.getStart());\n return value;\n };\n\n const isTreeNode = content => content instanceof AstNode;\n\n const moveSelection = editor => {\n if (hasFocus(editor)) {\n firstPositionIn(editor.getBody()).each(pos => {\n const node = pos.getNode();\n const caretPos = isTable$2(node) ? firstPositionIn(node).getOr(pos) : pos;\n editor.selection.setRng(caretPos.toRange());\n });\n }\n };\n const setEditorHtml = (editor, html, noSelection) => {\n editor.dom.setHTML(editor.getBody(), html);\n if (noSelection !== true) {\n moveSelection(editor);\n }\n };\n const setContentString = (editor, body, content, args) => {\n if (content.length === 0 || /^\\s+$/.test(content)) {\n const padd = '
';\n if (body.nodeName === 'TABLE') {\n content = '
';\n return textBlock;\n };\n const exitPreBlock = (editor, direction, range) => {\n const caretWalker = CaretWalker(editor.getBody());\n const getVisualCaretPosition$1 = curry(getVisualCaretPosition, direction === 1 ? caretWalker.next : caretWalker.prev);\n if (range.collapsed) {\n const pre = editor.dom.getParent(range.startContainer, 'PRE');\n if (!pre) {\n return;\n }\n const caretPos = getVisualCaretPosition$1(CaretPosition.fromRangeStart(range));\n if (!caretPos) {\n const newBlock = SugarElement.fromDom(createTextBlock(editor));\n if (direction === 1) {\n after$4(SugarElement.fromDom(pre), newBlock);\n } else {\n before$3(SugarElement.fromDom(pre), newBlock);\n }\n editor.selection.select(newBlock.dom, true);\n editor.selection.collapse();\n }\n }\n };\n const getHorizontalRange = (editor, forward) => {\n const direction = forward ? HDirection.Forwards : HDirection.Backwards;\n const range = editor.selection.getRng();\n return moveToCeFalseHorizontally(direction, editor, range).orThunk(() => {\n exitPreBlock(editor, direction, range);\n return Optional.none();\n });\n };\n const getVerticalRange = (editor, down) => {\n const direction = down ? 1 : -1;\n const range = editor.selection.getRng();\n return moveToCeFalseVertically(direction, editor, range).orThunk(() => {\n exitPreBlock(editor, direction, range);\n return Optional.none();\n });\n };\n const moveH$2 = (editor, forward) => getHorizontalRange(editor, forward).exists(newRange => {\n moveToRange(editor, newRange);\n return true;\n });\n const moveV$3 = (editor, down) => getVerticalRange(editor, down).exists(newRange => {\n moveToRange(editor, newRange);\n return true;\n });\n const moveToLineEndPoint$1 = (editor, forward) => {\n const isCefPosition = forward ? isAfterContentEditableFalse : isBeforeContentEditableFalse;\n return moveToLineEndPoint$3(editor, forward, isCefPosition);\n };\n const selectToEndPoint = (editor, forward) => getEdgeCefPosition(editor, !forward).map(pos => {\n const rng = pos.toRange();\n const curRng = editor.selection.getRng();\n if (forward) {\n rng.setStart(curRng.startContainer, curRng.startOffset);\n } else {\n rng.setEnd(curRng.endContainer, curRng.endOffset);\n }\n return rng;\n }).exists(rng => {\n moveToRange(editor, rng);\n return true;\n });\n\n const isTarget = node => contains$2(['figcaption'], name(node));\n const getClosestTargetBlock = (pos, root) => {\n const isRoot = curry(eq, root);\n return closest$4(SugarElement.fromDom(pos.container()), isBlock$2, isRoot).filter(isTarget);\n };\n const isAtFirstOrLastLine = (root, forward, pos) => forward ? isAtLastLine(root.dom, pos) : isAtFirstLine(root.dom, pos);\n const moveCaretToNewEmptyLine = (editor, forward) => {\n const root = SugarElement.fromDom(editor.getBody());\n const pos = CaretPosition.fromRangeStart(editor.selection.getRng());\n return getClosestTargetBlock(pos, root).exists(() => {\n if (isAtFirstOrLastLine(root, forward, pos)) {\n const insertFn = forward ? append$1 : prepend;\n const rng = insertEmptyLine(editor, root, insertFn);\n editor.selection.setRng(rng);\n return true;\n } else {\n return false;\n }\n });\n };\n const moveV$2 = (editor, forward) => {\n if (editor.selection.isCollapsed()) {\n return moveCaretToNewEmptyLine(editor, forward);\n } else {\n return false;\n }\n };\n\n const baseKeyPattern = {\n shiftKey: false,\n altKey: false,\n ctrlKey: false,\n metaKey: false,\n keyCode: 0\n };\n const defaultPatterns = patterns => map$3(patterns, pattern => ({\n ...baseKeyPattern,\n ...pattern\n }));\n const defaultDelayedPatterns = patterns => map$3(patterns, pattern => ({\n ...baseKeyPattern,\n ...pattern\n }));\n const matchesEvent = (pattern, evt) => evt.keyCode === pattern.keyCode && evt.shiftKey === pattern.shiftKey && evt.altKey === pattern.altKey && evt.ctrlKey === pattern.ctrlKey && evt.metaKey === pattern.metaKey;\n const match$1 = (patterns, evt) => bind$3(defaultPatterns(patterns), pattern => matchesEvent(pattern, evt) ? [pattern] : []);\n const matchDelayed = (patterns, evt) => bind$3(defaultDelayedPatterns(patterns), pattern => matchesEvent(pattern, evt) ? [pattern] : []);\n const action = (f, ...x) => () => f.apply(null, x);\n const execute = (patterns, evt) => find$2(match$1(patterns, evt), pattern => pattern.action());\n const executeWithDelayedAction = (patterns, evt) => findMap(matchDelayed(patterns, evt), pattern => pattern.action());\n\n const moveH$1 = (editor, forward) => {\n const direction = forward ? HDirection.Forwards : HDirection.Backwards;\n const range = editor.selection.getRng();\n return moveHorizontally(editor, direction, range, isBeforeMedia, isAfterMedia, isMedia$2).exists(newRange => {\n moveToRange(editor, newRange);\n return true;\n });\n };\n const moveV$1 = (editor, down) => {\n const direction = down ? 1 : -1;\n const range = editor.selection.getRng();\n return moveVertically(editor, direction, range, isBeforeMedia, isAfterMedia, isMedia$2).exists(newRange => {\n moveToRange(editor, newRange);\n return true;\n });\n };\n const moveToLineEndPoint = (editor, forward) => {\n const isNearMedia = forward ? isAfterMedia : isBeforeMedia;\n return moveToLineEndPoint$3(editor, forward, isNearMedia);\n };\n\n const adt = Adt.generate([\n { none: ['current'] },\n { first: ['current'] },\n {\n middle: [\n 'current',\n 'target'\n ]\n },\n { last: ['current'] }\n ]);\n const none = current => adt.none(current);\n const CellLocation = {\n ...adt,\n none\n };\n\n const firstLayer = (scope, selector) => {\n return filterFirstLayer(scope, selector, always);\n };\n const filterFirstLayer = (scope, selector, predicate) => {\n return bind$3(children$1(scope), x => {\n if (is$1(x, selector)) {\n return predicate(x) ? [x] : [];\n } else {\n return filterFirstLayer(x, selector, predicate);\n }\n });\n };\n\n const lookup$1 = (tags, element, isRoot = never) => {\n if (isRoot(element)) {\n return Optional.none();\n }\n if (contains$2(tags, name(element))) {\n return Optional.some(element);\n }\n const isRootOrUpperTable = elm => is$1(elm, 'table') || isRoot(elm);\n return ancestor$2(element, tags.join(','), isRootOrUpperTable);\n };\n const cell = (element, isRoot) => lookup$1([\n 'td',\n 'th'\n ], element, isRoot);\n const cells = ancestor => firstLayer(ancestor, 'th,td');\n const table = (element, isRoot) => closest$3(element, 'table', isRoot);\n\n const walk = (all, current, index, direction, isEligible = always) => {\n const forwards = direction === 1;\n if (!forwards && index <= 0) {\n return CellLocation.first(all[0]);\n } else if (forwards && index >= all.length - 1) {\n return CellLocation.last(all[all.length - 1]);\n } else {\n const newIndex = index + direction;\n const elem = all[newIndex];\n return isEligible(elem) ? CellLocation.middle(current, elem) : walk(all, current, newIndex, direction, isEligible);\n }\n };\n const detect = (current, isRoot) => {\n return table(current, isRoot).bind(table => {\n const all = cells(table);\n const index = findIndex$2(all, x => eq(current, x));\n return index.map(index => ({\n index,\n all\n }));\n });\n };\n const next = (current, isEligible, isRoot) => {\n const detection = detect(current, isRoot);\n return detection.fold(() => {\n return CellLocation.none(current);\n }, info => {\n return walk(info.all, current, info.index, 1, isEligible);\n });\n };\n const prev = (current, isEligible, isRoot) => {\n const detection = detect(current, isRoot);\n return detection.fold(() => {\n return CellLocation.none();\n }, info => {\n return walk(info.all, current, info.index, -1, isEligible);\n });\n };\n\n const closest = target => closest$3(target, '[contenteditable]');\n const isEditable = (element, assumeEditable = false) => {\n if (inBody(element)) {\n return element.dom.isContentEditable;\n } else {\n return closest(element).fold(constant(assumeEditable), editable => getRaw(editable) === 'true');\n }\n };\n const getRaw = element => element.dom.contentEditable;\n\n const deflate = (rect, delta) => ({\n left: rect.left - delta,\n top: rect.top - delta,\n right: rect.right + delta * 2,\n bottom: rect.bottom + delta * 2,\n width: rect.width + delta,\n height: rect.height + delta\n });\n const getCorners = (getYAxisValue, tds) => bind$3(tds, td => {\n const rect = deflate(clone$1(td.getBoundingClientRect()), -1);\n return [\n {\n x: rect.left,\n y: getYAxisValue(rect),\n cell: td\n },\n {\n x: rect.right,\n y: getYAxisValue(rect),\n cell: td\n }\n ];\n });\n const findClosestCorner = (corners, x, y) => foldl(corners, (acc, newCorner) => acc.fold(() => Optional.some(newCorner), oldCorner => {\n const oldDist = Math.sqrt(Math.abs(oldCorner.x - x) + Math.abs(oldCorner.y - y));\n const newDist = Math.sqrt(Math.abs(newCorner.x - x) + Math.abs(newCorner.y - y));\n return Optional.some(newDist < oldDist ? newCorner : oldCorner);\n }), Optional.none());\n const getClosestCell = (getYAxisValue, isTargetCorner, table, x, y) => {\n const cells = descendants(SugarElement.fromDom(table), 'td,th,caption').map(e => e.dom);\n const corners = filter$5(getCorners(getYAxisValue, cells), corner => isTargetCorner(corner, y));\n return findClosestCorner(corners, x, y).map(corner => corner.cell);\n };\n const getBottomValue = rect => rect.bottom;\n const getTopValue = rect => rect.top;\n const isAbove = (corner, y) => corner.y < y;\n const isBelow = (corner, y) => corner.y > y;\n const getClosestCellAbove = curry(getClosestCell, getBottomValue, isAbove);\n const getClosestCellBelow = curry(getClosestCell, getTopValue, isBelow);\n const findClosestPositionInAboveCell = (table, pos) => head(pos.getClientRects()).bind(rect => getClosestCellAbove(table, rect.left, rect.top)).bind(cell => findClosestHorizontalPosition(getLastLinePositions(cell), pos));\n const findClosestPositionInBelowCell = (table, pos) => last$3(pos.getClientRects()).bind(rect => getClosestCellBelow(table, rect.left, rect.top)).bind(cell => findClosestHorizontalPosition(getFirstLinePositions(cell), pos));\n\n const hasNextBreak = (getPositionsUntil, scope, lineInfo) => lineInfo.breakAt.exists(breakPos => getPositionsUntil(scope, breakPos).breakAt.isSome());\n const startsWithWrapBreak = lineInfo => lineInfo.breakType === BreakType.Wrap && lineInfo.positions.length === 0;\n const startsWithBrBreak = lineInfo => lineInfo.breakType === BreakType.Br && lineInfo.positions.length === 1;\n const isAtTableCellLine = (getPositionsUntil, scope, pos) => {\n const lineInfo = getPositionsUntil(scope, pos);\n if (startsWithWrapBreak(lineInfo) || !isBr$6(pos.getNode()) && startsWithBrBreak(lineInfo)) {\n return !hasNextBreak(getPositionsUntil, scope, lineInfo);\n } else {\n return lineInfo.breakAt.isNone();\n }\n };\n const isAtFirstTableCellLine = curry(isAtTableCellLine, getPositionsUntilPreviousLine);\n const isAtLastTableCellLine = curry(isAtTableCellLine, getPositionsUntilNextLine);\n const isCaretAtStartOrEndOfTable = (forward, rng, table) => {\n const caretPos = CaretPosition.fromRangeStart(rng);\n return positionIn(!forward, table).exists(pos => pos.isEqual(caretPos));\n };\n const navigateHorizontally = (editor, forward, table, _td) => {\n const rng = editor.selection.getRng();\n const direction = forward ? 1 : -1;\n if (isFakeCaretTableBrowser() && isCaretAtStartOrEndOfTable(forward, rng, table)) {\n showCaret(direction, editor, table, !forward, false).each(newRng => {\n moveToRange(editor, newRng);\n });\n return true;\n }\n return false;\n };\n const getClosestAbovePosition = (root, table, start) => findClosestPositionInAboveCell(table, start).orThunk(() => head(start.getClientRects()).bind(rect => findClosestHorizontalPositionFromPoint(getPositionsAbove(root, CaretPosition.before(table)), rect.left))).getOr(CaretPosition.before(table));\n const getClosestBelowPosition = (root, table, start) => findClosestPositionInBelowCell(table, start).orThunk(() => head(start.getClientRects()).bind(rect => findClosestHorizontalPositionFromPoint(getPositionsBelow(root, CaretPosition.after(table)), rect.left))).getOr(CaretPosition.after(table));\n const getTable = (previous, pos) => {\n const node = pos.getNode(previous);\n return isTable$2(node) ? Optional.some(node) : Optional.none();\n };\n const renderBlock = (down, editor, table) => {\n editor.undoManager.transact(() => {\n const insertFn = down ? after$4 : before$3;\n const rng = insertEmptyLine(editor, SugarElement.fromDom(table), insertFn);\n moveToRange(editor, rng);\n });\n };\n const moveCaret = (editor, down, pos) => {\n const table = down ? getTable(true, pos) : getTable(false, pos);\n const last = down === false;\n table.fold(() => moveToRange(editor, pos.toRange()), table => positionIn(last, editor.getBody()).filter(lastPos => lastPos.isEqual(pos)).fold(() => moveToRange(editor, pos.toRange()), _ => renderBlock(down, editor, table)));\n };\n const navigateVertically = (editor, down, table, td) => {\n const rng = editor.selection.getRng();\n const pos = CaretPosition.fromRangeStart(rng);\n const root = editor.getBody();\n if (!down && isAtFirstTableCellLine(td, pos)) {\n const newPos = getClosestAbovePosition(root, table, pos);\n moveCaret(editor, down, newPos);\n return true;\n } else if (down && isAtLastTableCellLine(td, pos)) {\n const newPos = getClosestBelowPosition(root, table, pos);\n moveCaret(editor, down, newPos);\n return true;\n } else {\n return false;\n }\n };\n const move$1 = (editor, forward, mover) => Optional.from(editor.dom.getParent(editor.selection.getNode(), 'td,th')).bind(td => Optional.from(editor.dom.getParent(td, 'table')).map(table => mover(editor, forward, table, td))).getOr(false);\n const moveH = (editor, forward) => move$1(editor, forward, navigateHorizontally);\n const moveV = (editor, forward) => move$1(editor, forward, navigateVertically);\n const getCellFirstCursorPosition = cell => {\n const selection = SimSelection.exact(cell, 0, cell, 0);\n return toNative(selection);\n };\n const tabGo = (editor, isRoot, cell) => {\n return cell.fold(Optional.none, Optional.none, (_current, next) => {\n return first(next).map(cell => {\n return getCellFirstCursorPosition(cell);\n });\n }, current => {\n editor.execCommand('mceTableInsertRowAfter');\n return tabForward(editor, isRoot, current);\n });\n };\n const tabForward = (editor, isRoot, cell) => tabGo(editor, isRoot, next(cell, isEditable));\n const tabBackward = (editor, isRoot, cell) => tabGo(editor, isRoot, prev(cell, isEditable));\n const handleTab = (editor, forward) => {\n const rootElements = [\n 'table',\n 'li',\n 'dl'\n ];\n const body = SugarElement.fromDom(editor.getBody());\n const isRoot = element => {\n const name$1 = name(element);\n return eq(element, body) || contains$2(rootElements, name$1);\n };\n const rng = editor.selection.getRng();\n const container = SugarElement.fromDom(!forward ? rng.startContainer : rng.endContainer);\n return cell(container, isRoot).map(cell => {\n table(cell, isRoot).each(table => {\n editor.model.table.clearSelectedCells(table.dom);\n });\n editor.selection.collapse(!forward);\n const navigation = !forward ? tabBackward : tabForward;\n const rng = navigation(editor, isRoot, cell);\n rng.each(range => {\n editor.selection.setRng(range);\n });\n return true;\n }).getOr(false);\n };\n\n const executeKeydownOverride$4 = (editor, caret, evt) => {\n const isMac = Env.os.isMacOS() || Env.os.isiOS();\n execute([\n {\n keyCode: VK.RIGHT,\n action: action(moveH$2, editor, true)\n },\n {\n keyCode: VK.LEFT,\n action: action(moveH$2, editor, false)\n },\n {\n keyCode: VK.UP,\n action: action(moveV$3, editor, false)\n },\n {\n keyCode: VK.DOWN,\n action: action(moveV$3, editor, true)\n },\n ...isMac ? [\n {\n keyCode: VK.UP,\n action: action(selectToEndPoint, editor, false),\n metaKey: true,\n shiftKey: true\n },\n {\n keyCode: VK.DOWN,\n action: action(selectToEndPoint, editor, true),\n metaKey: true,\n shiftKey: true\n }\n ] : [],\n {\n keyCode: VK.RIGHT,\n action: action(moveH, editor, true)\n },\n {\n keyCode: VK.LEFT,\n action: action(moveH, editor, false)\n },\n {\n keyCode: VK.UP,\n action: action(moveV, editor, false)\n },\n {\n keyCode: VK.DOWN,\n action: action(moveV, editor, true)\n },\n {\n keyCode: VK.RIGHT,\n action: action(moveH$1, editor, true)\n },\n {\n keyCode: VK.LEFT,\n action: action(moveH$1, editor, false)\n },\n {\n keyCode: VK.UP,\n action: action(moveV$1, editor, false)\n },\n {\n keyCode: VK.DOWN,\n action: action(moveV$1, editor, true)\n },\n {\n keyCode: VK.RIGHT,\n action: action(move$2, editor, caret, true)\n },\n {\n keyCode: VK.LEFT,\n action: action(move$2, editor, caret, false)\n },\n {\n keyCode: VK.RIGHT,\n ctrlKey: !isMac,\n altKey: isMac,\n action: action(moveNextWord, editor, caret)\n },\n {\n keyCode: VK.LEFT,\n ctrlKey: !isMac,\n altKey: isMac,\n action: action(movePrevWord, editor, caret)\n },\n {\n keyCode: VK.UP,\n action: action(moveV$2, editor, false)\n },\n {\n keyCode: VK.DOWN,\n action: action(moveV$2, editor, true)\n }\n ], evt).each(_ => {\n evt.preventDefault();\n });\n };\n const setup$k = (editor, caret) => {\n editor.on('keydown', evt => {\n if (!evt.isDefaultPrevented()) {\n executeKeydownOverride$4(editor, caret, evt);\n }\n });\n };\n\n const point = (container, offset) => ({\n container,\n offset\n });\n\n const DOM$7 = DOMUtils.DOM;\n const alwaysNext = startNode => node => startNode === node ? -1 : 0;\n const isBoundary = dom => node => dom.isBlock(node) || contains$2([\n 'BR',\n 'IMG',\n 'HR',\n 'INPUT'\n ], node.nodeName) || dom.getContentEditable(node) === 'false';\n const textBefore = (node, offset, rootNode) => {\n if (isText$a(node) && offset >= 0) {\n return Optional.some(point(node, offset));\n } else {\n const textSeeker = TextSeeker(DOM$7);\n return Optional.from(textSeeker.backwards(node, offset, alwaysNext(node), rootNode)).map(prev => point(prev.container, prev.container.data.length));\n }\n };\n const textAfter = (node, offset, rootNode) => {\n if (isText$a(node) && offset >= node.length) {\n return Optional.some(point(node, offset));\n } else {\n const textSeeker = TextSeeker(DOM$7);\n return Optional.from(textSeeker.forwards(node, offset, alwaysNext(node), rootNode)).map(prev => point(prev.container, 0));\n }\n };\n const scanLeft = (node, offset, rootNode) => {\n if (!isText$a(node)) {\n return Optional.none();\n }\n const text = node.data;\n if (offset >= 0 && offset <= text.length) {\n return Optional.some(point(node, offset));\n } else {\n const textSeeker = TextSeeker(DOM$7);\n return Optional.from(textSeeker.backwards(node, offset, alwaysNext(node), rootNode)).bind(prev => {\n const prevText = prev.container.data;\n return scanLeft(prev.container, offset + prevText.length, rootNode);\n });\n }\n };\n const scanRight = (node, offset, rootNode) => {\n if (!isText$a(node)) {\n return Optional.none();\n }\n const text = node.data;\n if (offset <= text.length) {\n return Optional.some(point(node, offset));\n } else {\n const textSeeker = TextSeeker(DOM$7);\n return Optional.from(textSeeker.forwards(node, offset, alwaysNext(node), rootNode)).bind(next => scanRight(next.container, offset - text.length, rootNode));\n }\n };\n const repeatLeft = (dom, node, offset, process, rootNode) => {\n const search = TextSeeker(dom, isBoundary(dom));\n return Optional.from(search.backwards(node, offset, process, rootNode));\n };\n\n const isValidTextRange = rng => rng.collapsed && isText$a(rng.startContainer);\n const getText = rng => trim$1(rng.toString().replace(/\\u00A0/g, ' '));\n const isWhitespace = chr => chr !== '' && ' \\xA0\\f\\n\\r\\t\\x0B'.indexOf(chr) !== -1;\n\n const stripTrigger = (text, trigger) => text.substring(trigger.length);\n const findTrigger = (text, index, trigger) => {\n let i;\n const firstChar = trigger.charAt(0);\n for (i = index - 1; i >= 0; i--) {\n const char = text.charAt(i);\n if (isWhitespace(char)) {\n return Optional.none();\n }\n if (firstChar === char && contains$1(text, trigger, i, index)) {\n break;\n }\n }\n return Optional.some(i);\n };\n const findStart = (dom, initRange, trigger, minChars = 0) => {\n if (!isValidTextRange(initRange)) {\n return Optional.none();\n }\n const buffer = {\n text: '',\n offset: 0\n };\n const findTriggerIndex = (element, offset, text) => {\n buffer.text = text + buffer.text;\n buffer.offset += offset;\n return findTrigger(buffer.text, buffer.offset, trigger).getOr(offset);\n };\n const root = dom.getParent(initRange.startContainer, dom.isBlock) || dom.getRoot();\n return repeatLeft(dom, initRange.startContainer, initRange.startOffset, findTriggerIndex, root).bind(spot => {\n const range = initRange.cloneRange();\n range.setStart(spot.container, spot.offset);\n range.setEnd(initRange.endContainer, initRange.endOffset);\n if (range.collapsed) {\n return Optional.none();\n }\n const text = getText(range);\n const triggerIndex = text.lastIndexOf(trigger);\n if (triggerIndex !== 0 || stripTrigger(text, trigger).length < minChars) {\n return Optional.none();\n } else {\n return Optional.some({\n text: stripTrigger(text, trigger),\n range,\n trigger\n });\n }\n });\n };\n const getContext = (dom, initRange, trigger, minChars = 0) => detect$1(SugarElement.fromDom(initRange.startContainer)).fold(() => findStart(dom, initRange, trigger, minChars), elm => {\n const range = dom.createRng();\n range.selectNode(elm.dom);\n const text = getText(range);\n return Optional.some({\n range,\n text: stripTrigger(text, trigger),\n trigger\n });\n });\n\n const isText$1 = node => node.nodeType === TEXT;\n const isElement = node => node.nodeType === ELEMENT;\n const toLast = node => {\n if (isText$1(node)) {\n return point(node, node.data.length);\n } else {\n const children = node.childNodes;\n return children.length > 0 ? toLast(children[children.length - 1]) : point(node, children.length);\n }\n };\n const toLeaf = (node, offset) => {\n const children = node.childNodes;\n if (children.length > 0 && offset < children.length) {\n return toLeaf(children[offset], 0);\n } else if (children.length > 0 && isElement(node) && children.length === offset) {\n return toLast(children[children.length - 1]);\n } else {\n return point(node, offset);\n }\n };\n\n const isPreviousCharContent = (dom, leaf) => {\n var _a;\n const root = (_a = dom.getParent(leaf.container, dom.isBlock)) !== null && _a !== void 0 ? _a : dom.getRoot();\n return repeatLeft(dom, leaf.container, leaf.offset, (_element, offset) => offset === 0 ? -1 : offset, root).filter(spot => {\n const char = spot.container.data.charAt(spot.offset - 1);\n return !isWhitespace(char);\n }).isSome();\n };\n const isStartOfWord = dom => rng => {\n const leaf = toLeaf(rng.startContainer, rng.startOffset);\n return !isPreviousCharContent(dom, leaf);\n };\n const getTriggerContext = (dom, initRange, database) => findMap(database.triggers, trigger => getContext(dom, initRange, trigger));\n const lookup = (editor, getDatabase) => {\n const database = getDatabase();\n const rng = editor.selection.getRng();\n return getTriggerContext(editor.dom, rng, database).bind(context => lookupWithContext(editor, getDatabase, context));\n };\n const lookupWithContext = (editor, getDatabase, context, fetchOptions = {}) => {\n var _a;\n const database = getDatabase();\n const rng = editor.selection.getRng();\n const startText = (_a = rng.startContainer.nodeValue) !== null && _a !== void 0 ? _a : '';\n const autocompleters = filter$5(database.lookupByTrigger(context.trigger), autocompleter => context.text.length >= autocompleter.minChars && autocompleter.matches.getOrThunk(() => isStartOfWord(editor.dom))(context.range, startText, context.text));\n if (autocompleters.length === 0) {\n return Optional.none();\n }\n const lookupData = Promise.all(map$3(autocompleters, ac => {\n const fetchResult = ac.fetch(context.text, ac.maxResults, fetchOptions);\n return fetchResult.then(results => ({\n matchText: context.text,\n items: results,\n columns: ac.columns,\n onAction: ac.onAction,\n highlightOn: ac.highlightOn\n }));\n }));\n return Optional.some({\n lookupData,\n context\n });\n };\n\n var SimpleResultType;\n (function (SimpleResultType) {\n SimpleResultType[SimpleResultType['Error'] = 0] = 'Error';\n SimpleResultType[SimpleResultType['Value'] = 1] = 'Value';\n }(SimpleResultType || (SimpleResultType = {})));\n const fold$1 = (res, onError, onValue) => res.stype === SimpleResultType.Error ? onError(res.serror) : onValue(res.svalue);\n const partition = results => {\n const values = [];\n const errors = [];\n each$e(results, obj => {\n fold$1(obj, err => errors.push(err), val => values.push(val));\n });\n return {\n values,\n errors\n };\n };\n const mapError = (res, f) => {\n if (res.stype === SimpleResultType.Error) {\n return {\n stype: SimpleResultType.Error,\n serror: f(res.serror)\n };\n } else {\n return res;\n }\n };\n const map = (res, f) => {\n if (res.stype === SimpleResultType.Value) {\n return {\n stype: SimpleResultType.Value,\n svalue: f(res.svalue)\n };\n } else {\n return res;\n }\n };\n const bind = (res, f) => {\n if (res.stype === SimpleResultType.Value) {\n return f(res.svalue);\n } else {\n return res;\n }\n };\n const bindError = (res, f) => {\n if (res.stype === SimpleResultType.Error) {\n return f(res.serror);\n } else {\n return res;\n }\n };\n const svalue = v => ({\n stype: SimpleResultType.Value,\n svalue: v\n });\n const serror = e => ({\n stype: SimpleResultType.Error,\n serror: e\n });\n const toResult = res => fold$1(res, Result.error, Result.value);\n const fromResult = res => res.fold(serror, svalue);\n const SimpleResult = {\n fromResult,\n toResult,\n svalue,\n partition,\n serror,\n bind,\n bindError,\n map,\n mapError,\n fold: fold$1\n };\n\n const formatObj = input => {\n return isObject(input) && keys(input).length > 100 ? ' removed due to size' : JSON.stringify(input, null, 2);\n };\n const formatErrors = errors => {\n const es = errors.length > 10 ? errors.slice(0, 10).concat([{\n path: [],\n getErrorInfo: constant('... (only showing first ten failures)')\n }]) : errors;\n return map$3(es, e => {\n return 'Failed path: (' + e.path.join(' > ') + ')\\n' + e.getErrorInfo();\n });\n };\n\n const nu = (path, getErrorInfo) => {\n return SimpleResult.serror([{\n path,\n getErrorInfo\n }]);\n };\n const missingRequired = (path, key, obj) => nu(path, () => 'Could not find valid *required* value for \"' + key + '\" in ' + formatObj(obj));\n const missingKey = (path, key) => nu(path, () => 'Choice schema did not contain choice key: \"' + key + '\"');\n const missingBranch = (path, branches, branch) => nu(path, () => 'The chosen schema: \"' + branch + '\" did not exist in branches: ' + formatObj(branches));\n const custom = (path, err) => nu(path, constant(err));\n\n const chooseFrom = (path, input, branches, ch) => {\n const fields = get$a(branches, ch);\n return fields.fold(() => missingBranch(path, branches, ch), vp => vp.extract(path.concat(['branch: ' + ch]), input));\n };\n const choose$1 = (key, branches) => {\n const extract = (path, input) => {\n const choice = get$a(input, key);\n return choice.fold(() => missingKey(path, key), chosen => chooseFrom(path, input, branches, chosen));\n };\n const toString = () => 'chooseOn(' + key + '). Possible values: ' + keys(branches);\n return {\n extract,\n toString\n };\n };\n\n const shallow = (old, nu) => {\n return nu;\n };\n const deep = (old, nu) => {\n const bothObjects = isPlainObject(old) && isPlainObject(nu);\n return bothObjects ? deepMerge(old, nu) : nu;\n };\n const baseMerge = merger => {\n return (...objects) => {\n if (objects.length === 0) {\n throw new Error(`Can't merge zero objects`);\n }\n const ret = {};\n for (let j = 0; j < objects.length; j++) {\n const curObject = objects[j];\n for (const key in curObject) {\n if (has$2(curObject, key)) {\n ret[key] = merger(ret[key], curObject[key]);\n }\n }\n }\n return ret;\n };\n };\n const deepMerge = baseMerge(deep);\n const merge = baseMerge(shallow);\n\n const required = () => ({\n tag: 'required',\n process: {}\n });\n const defaultedThunk = fallbackThunk => ({\n tag: 'defaultedThunk',\n process: fallbackThunk\n });\n const defaulted$1 = fallback => defaultedThunk(constant(fallback));\n const asOption = () => ({\n tag: 'option',\n process: {}\n });\n\n const mergeValues = (values, base) => values.length > 0 ? SimpleResult.svalue(deepMerge(base, merge.apply(undefined, values))) : SimpleResult.svalue(base);\n const mergeErrors = errors => compose(SimpleResult.serror, flatten)(errors);\n const consolidateObj = (objects, base) => {\n const partition = SimpleResult.partition(objects);\n return partition.errors.length > 0 ? mergeErrors(partition.errors) : mergeValues(partition.values, base);\n };\n const consolidateArr = objects => {\n const partitions = SimpleResult.partition(objects);\n return partitions.errors.length > 0 ? mergeErrors(partitions.errors) : SimpleResult.svalue(partitions.values);\n };\n const ResultCombine = {\n consolidateObj,\n consolidateArr\n };\n\n const field$1 = (key, newKey, presence, prop) => ({\n tag: 'field',\n key,\n newKey,\n presence,\n prop\n });\n const customField$1 = (newKey, instantiator) => ({\n tag: 'custom',\n newKey,\n instantiator\n });\n const fold = (value, ifField, ifCustom) => {\n switch (value.tag) {\n case 'field':\n return ifField(value.key, value.newKey, value.presence, value.prop);\n case 'custom':\n return ifCustom(value.newKey, value.instantiator);\n }\n };\n\n const value = validator => {\n const extract = (path, val) => {\n return SimpleResult.bindError(validator(val), err => custom(path, err));\n };\n const toString = constant('val');\n return {\n extract,\n toString\n };\n };\n const anyValue$1 = value(SimpleResult.svalue);\n\n const requiredAccess = (path, obj, key, bundle) => get$a(obj, key).fold(() => missingRequired(path, key, obj), bundle);\n const fallbackAccess = (obj, key, fallback, bundle) => {\n const v = get$a(obj, key).getOrThunk(() => fallback(obj));\n return bundle(v);\n };\n const optionAccess = (obj, key, bundle) => bundle(get$a(obj, key));\n const optionDefaultedAccess = (obj, key, fallback, bundle) => {\n const opt = get$a(obj, key).map(val => val === true ? fallback(obj) : val);\n return bundle(opt);\n };\n const extractField = (field, path, obj, key, prop) => {\n const bundle = av => prop.extract(path.concat([key]), av);\n const bundleAsOption = optValue => optValue.fold(() => SimpleResult.svalue(Optional.none()), ov => {\n const result = prop.extract(path.concat([key]), ov);\n return SimpleResult.map(result, Optional.some);\n });\n switch (field.tag) {\n case 'required':\n return requiredAccess(path, obj, key, bundle);\n case 'defaultedThunk':\n return fallbackAccess(obj, key, field.process, bundle);\n case 'option':\n return optionAccess(obj, key, bundleAsOption);\n case 'defaultedOptionThunk':\n return optionDefaultedAccess(obj, key, field.process, bundleAsOption);\n case 'mergeWithThunk': {\n return fallbackAccess(obj, key, constant({}), v => {\n const result = deepMerge(field.process(obj), v);\n return bundle(result);\n });\n }\n }\n };\n const extractFields = (path, obj, fields) => {\n const success = {};\n const errors = [];\n for (const field of fields) {\n fold(field, (key, newKey, presence, prop) => {\n const result = extractField(presence, path, obj, key, prop);\n SimpleResult.fold(result, err => {\n errors.push(...err);\n }, res => {\n success[newKey] = res;\n });\n }, (newKey, instantiator) => {\n success[newKey] = instantiator(obj);\n });\n }\n return errors.length > 0 ? SimpleResult.serror(errors) : SimpleResult.svalue(success);\n };\n const objOf = values => {\n const extract = (path, o) => extractFields(path, o, values);\n const toString = () => {\n const fieldStrings = map$3(values, value => fold(value, (key, _okey, _presence, prop) => key + ' -> ' + prop.toString(), (newKey, _instantiator) => 'state(' + newKey + ')'));\n return 'obj{\\n' + fieldStrings.join('\\n') + '}';\n };\n return {\n extract,\n toString\n };\n };\n const arrOf = prop => {\n const extract = (path, array) => {\n const results = map$3(array, (a, i) => prop.extract(path.concat(['[' + i + ']']), a));\n return ResultCombine.consolidateArr(results);\n };\n const toString = () => 'array(' + prop.toString() + ')';\n return {\n extract,\n toString\n };\n };\n\n const valueOf = validator => value(v => validator(v).fold(SimpleResult.serror, SimpleResult.svalue));\n const extractValue = (label, prop, obj) => {\n const res = prop.extract([label], obj);\n return SimpleResult.mapError(res, errs => ({\n input: obj,\n errors: errs\n }));\n };\n const asRaw = (label, prop, obj) => SimpleResult.toResult(extractValue(label, prop, obj));\n const formatError = errInfo => {\n return 'Errors: \\n' + formatErrors(errInfo.errors).join('\\n') + '\\n\\nInput object: ' + formatObj(errInfo.input);\n };\n const choose = (key, branches) => choose$1(key, map$2(branches, objOf));\n\n const anyValue = constant(anyValue$1);\n const typedValue = (validator, expectedType) => value(a => {\n const actualType = typeof a;\n return validator(a) ? SimpleResult.svalue(a) : SimpleResult.serror(`Expected type: ${ expectedType } but got: ${ actualType }`);\n });\n const number = typedValue(isNumber, 'number');\n const string = typedValue(isString, 'string');\n const boolean = typedValue(isBoolean, 'boolean');\n const functionProcessor = typedValue(isFunction, 'function');\n\n const field = field$1;\n const customField = customField$1;\n const validateEnum = values => valueOf(value => contains$2(values, value) ? Result.value(value) : Result.error(`Unsupported value: \"${ value }\", choose one of \"${ values.join(', ') }\".`));\n const requiredOf = (key, schema) => field(key, key, required(), schema);\n const requiredString = key => requiredOf(key, string);\n const requiredFunction = key => requiredOf(key, functionProcessor);\n const requiredArrayOf = (key, schema) => field(key, key, required(), arrOf(schema));\n const optionOf = (key, schema) => field(key, key, asOption(), schema);\n const optionString = key => optionOf(key, string);\n const optionFunction = key => optionOf(key, functionProcessor);\n const defaulted = (key, fallback) => field(key, key, defaulted$1(fallback), anyValue());\n const defaultedOf = (key, fallback, schema) => field(key, key, defaulted$1(fallback), schema);\n const defaultedNumber = (key, fallback) => defaultedOf(key, fallback, number);\n const defaultedString = (key, fallback) => defaultedOf(key, fallback, string);\n const defaultedStringEnum = (key, fallback, values) => defaultedOf(key, fallback, validateEnum(values));\n const defaultedBoolean = (key, fallback) => defaultedOf(key, fallback, boolean);\n const defaultedFunction = (key, fallback) => defaultedOf(key, fallback, functionProcessor);\n const defaultedArrayOf = (key, fallback, schema) => defaultedOf(key, fallback, arrOf(schema));\n\n const type = requiredString('type');\n const fetch$1 = requiredFunction('fetch');\n const onAction = requiredFunction('onAction');\n const onSetup = defaultedFunction('onSetup', () => noop);\n const optionalText = optionString('text');\n const optionalIcon = optionString('icon');\n const optionalTooltip = optionString('tooltip');\n const optionalLabel = optionString('label');\n const active = defaultedBoolean('active', false);\n const enabled = defaultedBoolean('enabled', true);\n const primary = defaultedBoolean('primary', false);\n const defaultedColumns = num => defaulted('columns', num);\n const defaultedType = type => defaultedString('type', type);\n\n const autocompleterSchema = objOf([\n type,\n requiredString('trigger'),\n defaultedNumber('minChars', 1),\n defaultedColumns(1),\n defaultedNumber('maxResults', 10),\n optionFunction('matches'),\n fetch$1,\n onAction,\n defaultedArrayOf('highlightOn', [], string)\n ]);\n const createAutocompleter = spec => asRaw('Autocompleter', autocompleterSchema, {\n trigger: spec.ch,\n ...spec\n });\n\n const baseToolbarButtonFields = [\n enabled,\n optionalTooltip,\n optionalIcon,\n optionalText,\n onSetup\n ];\n\n const baseToolbarToggleButtonFields = [active].concat(baseToolbarButtonFields);\n\n const contextBarFields = [\n defaultedFunction('predicate', never),\n defaultedStringEnum('scope', 'node', [\n 'node',\n 'editor'\n ]),\n defaultedStringEnum('position', 'selection', [\n 'node',\n 'selection',\n 'line'\n ])\n ];\n\n const contextButtonFields = baseToolbarButtonFields.concat([\n defaultedType('contextformbutton'),\n primary,\n onAction,\n customField('original', identity)\n ]);\n const contextToggleButtonFields = baseToolbarToggleButtonFields.concat([\n defaultedType('contextformbutton'),\n primary,\n onAction,\n customField('original', identity)\n ]);\n const launchButtonFields = baseToolbarButtonFields.concat([defaultedType('contextformbutton')]);\n const launchToggleButtonFields = baseToolbarToggleButtonFields.concat([defaultedType('contextformtogglebutton')]);\n const toggleOrNormal = choose('type', {\n contextformbutton: contextButtonFields,\n contextformtogglebutton: contextToggleButtonFields\n });\n objOf([\n defaultedType('contextform'),\n defaultedFunction('initValue', constant('')),\n optionalLabel,\n requiredArrayOf('commands', toggleOrNormal),\n optionOf('launch', choose('type', {\n contextformbutton: launchButtonFields,\n contextformtogglebutton: launchToggleButtonFields\n }))\n ].concat(contextBarFields));\n\n const register$2 = editor => {\n const popups = editor.ui.registry.getAll().popups;\n const dataset = map$2(popups, popup => createAutocompleter(popup).fold(err => {\n throw new Error(formatError(err));\n }, identity));\n const triggers = stringArray(mapToArray(dataset, v => v.trigger));\n const datasetValues = values(dataset);\n const lookupByTrigger = trigger => filter$5(datasetValues, dv => dv.trigger === trigger);\n return {\n dataset,\n triggers,\n lookupByTrigger\n };\n };\n\n const setupEditorInput = (editor, api) => {\n const update = last$1(api.load, 50);\n editor.on('keypress compositionend', e => {\n if (e.which === 27) {\n return;\n }\n update.throttle();\n });\n editor.on('keydown', e => {\n const keyCode = e.which;\n if (keyCode === 8) {\n update.throttle();\n } else if (keyCode === 27) {\n api.cancelIfNecessary();\n }\n });\n editor.on('remove', update.cancel);\n };\n const setup$j = editor => {\n const activeAutocompleter = value$2();\n const uiActive = Cell(false);\n const isActive = activeAutocompleter.isSet;\n const cancelIfNecessary = () => {\n if (isActive()) {\n removeAutocompleterDecoration(editor);\n fireAutocompleterEnd(editor);\n uiActive.set(false);\n activeAutocompleter.clear();\n }\n };\n const commenceIfNecessary = context => {\n if (!isActive()) {\n addAutocompleterDecoration(editor, context.range);\n activeAutocompleter.set({\n trigger: context.trigger,\n matchLength: context.text.length\n });\n }\n };\n const getAutocompleters = cached(() => register$2(editor));\n const doLookup = fetchOptions => activeAutocompleter.get().map(ac => getContext(editor.dom, editor.selection.getRng(), ac.trigger).bind(newContext => lookupWithContext(editor, getAutocompleters, newContext, fetchOptions))).getOrThunk(() => lookup(editor, getAutocompleters));\n const load = fetchOptions => {\n doLookup(fetchOptions).fold(cancelIfNecessary, lookupInfo => {\n commenceIfNecessary(lookupInfo.context);\n lookupInfo.lookupData.then(lookupData => {\n activeAutocompleter.get().map(ac => {\n const context = lookupInfo.context;\n if (ac.trigger === context.trigger) {\n if (context.text.length - ac.matchLength >= 10) {\n cancelIfNecessary();\n } else {\n activeAutocompleter.set({\n ...ac,\n matchLength: context.text.length\n });\n if (uiActive.get()) {\n fireAutocompleterUpdate(editor, { lookupData });\n } else {\n uiActive.set(true);\n fireAutocompleterStart(editor, { lookupData });\n }\n }\n }\n });\n });\n });\n };\n editor.addCommand('mceAutocompleterReload', (_ui, value) => {\n const fetchOptions = isObject(value) ? value.fetchOptions : {};\n load(fetchOptions);\n });\n editor.addCommand('mceAutocompleterClose', cancelIfNecessary);\n setupEditorInput(editor, {\n cancelIfNecessary,\n load\n });\n };\n\n const createAndFireInputEvent = eventType => (editor, inputType, specifics = {}) => {\n const target = editor.getBody();\n const overrides = {\n bubbles: true,\n composed: true,\n data: null,\n isComposing: false,\n detail: 0,\n view: null,\n target,\n currentTarget: target,\n eventPhase: Event.AT_TARGET,\n originalTarget: target,\n explicitOriginalTarget: target,\n isTrusted: false,\n srcElement: target,\n cancelable: false,\n preventDefault: noop,\n inputType\n };\n const input = clone$3(new InputEvent(eventType));\n return editor.dispatch(eventType, {\n ...input,\n ...overrides,\n ...specifics\n });\n };\n const fireFakeInputEvent = createAndFireInputEvent('input');\n const fireFakeBeforeInputEvent = createAndFireInputEvent('beforeinput');\n\n const executeKeydownOverride$3 = (editor, caret, evt) => {\n const inputType = evt.keyCode === VK.BACKSPACE ? 'deleteContentBackward' : 'deleteContentForward';\n executeWithDelayedAction([\n {\n keyCode: VK.BACKSPACE,\n action: action(backspaceDelete, editor)\n },\n {\n keyCode: VK.BACKSPACE,\n action: action(backspaceDelete$5, editor, false)\n },\n {\n keyCode: VK.DELETE,\n action: action(backspaceDelete$5, editor, true)\n },\n {\n keyCode: VK.BACKSPACE,\n action: action(backspaceDelete$6, editor, false)\n },\n {\n keyCode: VK.DELETE,\n action: action(backspaceDelete$6, editor, true)\n },\n {\n keyCode: VK.BACKSPACE,\n action: action(backspaceDelete$3, editor, caret, false)\n },\n {\n keyCode: VK.DELETE,\n action: action(backspaceDelete$3, editor, caret, true)\n },\n {\n keyCode: VK.BACKSPACE,\n action: action(backspaceDelete$9, editor, false)\n },\n {\n keyCode: VK.DELETE,\n action: action(backspaceDelete$9, editor, true)\n },\n {\n keyCode: VK.BACKSPACE,\n action: action(backspaceDelete$4, editor, false)\n },\n {\n keyCode: VK.DELETE,\n action: action(backspaceDelete$4, editor, true)\n },\n {\n keyCode: VK.BACKSPACE,\n action: action(backspaceDelete$1, editor, false)\n },\n {\n keyCode: VK.DELETE,\n action: action(backspaceDelete$1, editor, true)\n },\n {\n keyCode: VK.BACKSPACE,\n action: action(backspaceDelete$7, editor, false)\n },\n {\n keyCode: VK.DELETE,\n action: action(backspaceDelete$7, editor, true)\n },\n {\n keyCode: VK.BACKSPACE,\n action: action(backspaceDelete$8, editor, false)\n },\n {\n keyCode: VK.DELETE,\n action: action(backspaceDelete$8, editor, true)\n },\n {\n keyCode: VK.BACKSPACE,\n action: action(backspaceDelete$2, editor, false)\n },\n {\n keyCode: VK.DELETE,\n action: action(backspaceDelete$2, editor, true)\n }\n ], evt).each(applyAction => {\n evt.preventDefault();\n const beforeInput = fireFakeBeforeInputEvent(editor, inputType);\n if (!beforeInput.isDefaultPrevented()) {\n applyAction();\n fireFakeInputEvent(editor, inputType);\n }\n });\n };\n const executeKeyupOverride = (editor, evt) => {\n execute([\n {\n keyCode: VK.BACKSPACE,\n action: action(paddEmptyElement, editor)\n },\n {\n keyCode: VK.DELETE,\n action: action(paddEmptyElement, editor)\n }\n ], evt);\n };\n const setup$i = (editor, caret) => {\n editor.on('keydown', evt => {\n if (!evt.isDefaultPrevented()) {\n executeKeydownOverride$3(editor, caret, evt);\n }\n });\n editor.on('keyup', evt => {\n if (!evt.isDefaultPrevented()) {\n executeKeyupOverride(editor, evt);\n }\n });\n };\n\n const firstNonWhiteSpaceNodeSibling = node => {\n while (node) {\n if (isElement$6(node) || isText$a(node) && node.data && /[\\r\\n\\s]/.test(node.data)) {\n return node;\n }\n node = node.nextSibling;\n }\n return null;\n };\n const moveToCaretPosition = (editor, root) => {\n const dom = editor.dom;\n const moveCaretBeforeOnEnterElementsMap = editor.schema.getMoveCaretBeforeOnEnterElements();\n if (!root) {\n return;\n }\n if (/^(LI|DT|DD)$/.test(root.nodeName)) {\n const firstChild = firstNonWhiteSpaceNodeSibling(root.firstChild);\n if (firstChild && /^(UL|OL|DL)$/.test(firstChild.nodeName)) {\n root.insertBefore(dom.doc.createTextNode(nbsp), root.firstChild);\n }\n }\n const rng = dom.createRng();\n root.normalize();\n if (root.hasChildNodes()) {\n const walker = new DomTreeWalker(root, root);\n let lastNode = root;\n let node;\n while (node = walker.current()) {\n if (isText$a(node)) {\n rng.setStart(node, 0);\n rng.setEnd(node, 0);\n break;\n }\n if (moveCaretBeforeOnEnterElementsMap[node.nodeName.toLowerCase()]) {\n rng.setStartBefore(node);\n rng.setEndBefore(node);\n break;\n }\n lastNode = node;\n node = walker.next();\n }\n if (!node) {\n rng.setStart(lastNode, 0);\n rng.setEnd(lastNode, 0);\n }\n } else {\n if (isBr$6(root)) {\n if (root.nextSibling && dom.isBlock(root.nextSibling)) {\n rng.setStartBefore(root);\n rng.setEndBefore(root);\n } else {\n rng.setStartAfter(root);\n rng.setEndAfter(root);\n }\n } else {\n rng.setStart(root, 0);\n rng.setEnd(root, 0);\n }\n }\n editor.selection.setRng(rng);\n scrollRangeIntoView(editor, rng);\n };\n const getEditableRoot = (dom, node) => {\n const root = dom.getRoot();\n let editableRoot;\n let parent = node;\n while (parent !== root && parent && dom.getContentEditable(parent) !== 'false') {\n if (dom.getContentEditable(parent) === 'true') {\n editableRoot = parent;\n }\n parent = parent.parentNode;\n }\n return parent !== root ? editableRoot : root;\n };\n const getParentBlock$1 = editor => {\n return Optional.from(editor.dom.getParent(editor.selection.getStart(true), editor.dom.isBlock));\n };\n const getParentBlockName = editor => {\n return getParentBlock$1(editor).fold(constant(''), parentBlock => {\n return parentBlock.nodeName.toUpperCase();\n });\n };\n const isListItemParentBlock = editor => {\n return getParentBlock$1(editor).filter(elm => {\n return isListItem$1(SugarElement.fromDom(elm));\n }).isSome();\n };\n\n const hasFirstChild = (elm, name) => {\n return elm.firstChild && elm.firstChild.nodeName === name;\n };\n const isFirstChild = elm => {\n var _a;\n return ((_a = elm.parentNode) === null || _a === void 0 ? void 0 : _a.firstChild) === elm;\n };\n const hasParent = (elm, parentName) => {\n const parentNode = elm === null || elm === void 0 ? void 0 : elm.parentNode;\n return isNonNullable(parentNode) && parentNode.nodeName === parentName;\n };\n const isListBlock = elm => {\n return isNonNullable(elm) && /^(OL|UL|LI)$/.test(elm.nodeName);\n };\n const isListItem = elm => {\n return isNonNullable(elm) && /^(LI|DT|DD)$/.test(elm.nodeName);\n };\n const isNestedList = elm => {\n return isListBlock(elm) && isListBlock(elm.parentNode);\n };\n const getContainerBlock = containerBlock => {\n const containerBlockParent = containerBlock.parentNode;\n return isListItem(containerBlockParent) ? containerBlockParent : containerBlock;\n };\n const isFirstOrLastLi = (containerBlock, parentBlock, first) => {\n let node = containerBlock[first ? 'firstChild' : 'lastChild'];\n while (node) {\n if (isElement$6(node)) {\n break;\n }\n node = node[first ? 'nextSibling' : 'previousSibling'];\n }\n return node === parentBlock;\n };\n const insert$3 = (editor, createNewBlock, containerBlock, parentBlock, newBlockName) => {\n const dom = editor.dom;\n const rng = editor.selection.getRng();\n const containerParent = containerBlock.parentNode;\n if (containerBlock === editor.getBody() || !containerParent) {\n return;\n }\n if (isNestedList(containerBlock)) {\n newBlockName = 'LI';\n }\n let newBlock = createNewBlock(newBlockName);\n if (isFirstOrLastLi(containerBlock, parentBlock, true) && isFirstOrLastLi(containerBlock, parentBlock, false)) {\n if (hasParent(containerBlock, 'LI')) {\n const containerBlockParent = getContainerBlock(containerBlock);\n dom.insertAfter(newBlock, containerBlockParent);\n if (isFirstChild(containerBlock)) {\n dom.remove(containerBlockParent);\n } else {\n dom.remove(containerBlock);\n }\n } else {\n dom.replace(newBlock, containerBlock);\n }\n } else if (isFirstOrLastLi(containerBlock, parentBlock, true)) {\n if (hasParent(containerBlock, 'LI')) {\n dom.insertAfter(newBlock, getContainerBlock(containerBlock));\n newBlock.appendChild(dom.doc.createTextNode(' '));\n newBlock.appendChild(containerBlock);\n } else {\n containerParent.insertBefore(newBlock, containerBlock);\n }\n dom.remove(parentBlock);\n } else if (isFirstOrLastLi(containerBlock, parentBlock, false)) {\n dom.insertAfter(newBlock, getContainerBlock(containerBlock));\n dom.remove(parentBlock);\n } else {\n containerBlock = getContainerBlock(containerBlock);\n const tmpRng = rng.cloneRange();\n tmpRng.setStartAfter(parentBlock);\n tmpRng.setEndAfter(containerBlock);\n const fragment = tmpRng.extractContents();\n if (newBlockName === 'LI' && hasFirstChild(fragment, 'LI')) {\n newBlock = fragment.firstChild;\n dom.insertAfter(fragment, containerBlock);\n } else {\n dom.insertAfter(fragment, containerBlock);\n dom.insertAfter(newBlock, containerBlock);\n }\n dom.remove(parentBlock);\n }\n moveToCaretPosition(editor, newBlock);\n };\n\n const trimZwsp = fragment => {\n each$e(descendants$1(SugarElement.fromDom(fragment), isText$b), text => {\n const rawNode = text.dom;\n rawNode.nodeValue = trim$1(rawNode.data);\n });\n };\n const isWithinNonEditableList = (editor, node) => {\n const parentList = editor.dom.getParent(node, 'ol,ul,dl');\n return parentList !== null && editor.dom.getContentEditableParent(parentList) === 'false';\n };\n const isEmptyAnchor = (dom, elm) => {\n return elm && elm.nodeName === 'A' && dom.isEmpty(elm);\n };\n const emptyBlock = elm => {\n elm.innerHTML = '
';\n };\n const containerAndSiblingName = (container, nodeName) => {\n return container.nodeName === nodeName || container.previousSibling && container.previousSibling.nodeName === nodeName;\n };\n const canSplitBlock = (dom, node) => {\n return isNonNullable(node) && dom.isBlock(node) && !/^(TD|TH|CAPTION|FORM)$/.test(node.nodeName) && !/^(fixed|absolute)/i.test(node.style.position) && dom.getContentEditable(node) !== 'true';\n };\n const trimInlineElementsOnLeftSideOfBlock = (dom, nonEmptyElementsMap, block) => {\n var _a;\n const firstChilds = [];\n if (!block) {\n return;\n }\n let currentNode = block;\n while (currentNode = currentNode.firstChild) {\n if (dom.isBlock(currentNode)) {\n return;\n }\n if (isElement$6(currentNode) && !nonEmptyElementsMap[currentNode.nodeName.toLowerCase()]) {\n firstChilds.push(currentNode);\n }\n }\n let i = firstChilds.length;\n while (i--) {\n currentNode = firstChilds[i];\n if (!currentNode.hasChildNodes() || currentNode.firstChild === currentNode.lastChild && ((_a = currentNode.firstChild) === null || _a === void 0 ? void 0 : _a.nodeValue) === '') {\n dom.remove(currentNode);\n } else {\n if (isEmptyAnchor(dom, currentNode)) {\n dom.remove(currentNode);\n }\n }\n }\n };\n const normalizeZwspOffset = (start, container, offset) => {\n if (!isText$a(container)) {\n return offset;\n } else if (start) {\n return offset === 1 && container.data.charAt(offset - 1) === ZWSP$1 ? 0 : offset;\n } else {\n return offset === container.data.length - 1 && container.data.charAt(offset) === ZWSP$1 ? container.data.length : offset;\n }\n };\n const includeZwspInRange = rng => {\n const newRng = rng.cloneRange();\n newRng.setStart(rng.startContainer, normalizeZwspOffset(true, rng.startContainer, rng.startOffset));\n newRng.setEnd(rng.endContainer, normalizeZwspOffset(false, rng.endContainer, rng.endOffset));\n return newRng;\n };\n const trimLeadingLineBreaks = node => {\n let currentNode = node;\n do {\n if (isText$a(currentNode)) {\n currentNode.data = currentNode.data.replace(/^[\\r\\n]+/, '');\n }\n currentNode = currentNode.firstChild;\n } while (currentNode);\n };\n const applyAttributes = (editor, node, forcedRootBlockAttrs) => {\n const dom = editor.dom;\n Optional.from(forcedRootBlockAttrs.style).map(dom.parseStyle).each(attrStyles => {\n const currentStyles = getAllRaw(SugarElement.fromDom(node));\n const newStyles = {\n ...currentStyles,\n ...attrStyles\n };\n dom.setStyles(node, newStyles);\n });\n const attrClassesOpt = Optional.from(forcedRootBlockAttrs.class).map(attrClasses => attrClasses.split(/\\s+/));\n const currentClassesOpt = Optional.from(node.className).map(currentClasses => filter$5(currentClasses.split(/\\s+/), clazz => clazz !== ''));\n lift2(attrClassesOpt, currentClassesOpt, (attrClasses, currentClasses) => {\n const filteredClasses = filter$5(currentClasses, clazz => !contains$2(attrClasses, clazz));\n const newClasses = [\n ...attrClasses,\n ...filteredClasses\n ];\n dom.setAttrib(node, 'class', newClasses.join(' '));\n });\n const appliedAttrs = [\n 'style',\n 'class'\n ];\n const remainingAttrs = filter$4(forcedRootBlockAttrs, (_, attrs) => !contains$2(appliedAttrs, attrs));\n dom.setAttribs(node, remainingAttrs);\n };\n const setForcedBlockAttrs = (editor, node) => {\n const forcedRootBlockName = getForcedRootBlock(editor);\n if (forcedRootBlockName.toLowerCase() === node.tagName.toLowerCase()) {\n const forcedRootBlockAttrs = getForcedRootBlockAttrs(editor);\n applyAttributes(editor, node, forcedRootBlockAttrs);\n }\n };\n const wrapSelfAndSiblingsInDefaultBlock = (editor, newBlockName, rng, container, offset) => {\n var _a;\n const dom = editor.dom;\n const editableRoot = (_a = getEditableRoot(dom, container)) !== null && _a !== void 0 ? _a : dom.getRoot();\n let parentBlock = dom.getParent(container, dom.isBlock);\n if (!parentBlock || !canSplitBlock(dom, parentBlock)) {\n parentBlock = parentBlock || editableRoot;\n let rootBlockName;\n if (parentBlock === editor.getBody() || isTableCellOrCaption(parentBlock)) {\n rootBlockName = parentBlock.nodeName.toLowerCase();\n } else if (parentBlock.parentNode) {\n rootBlockName = parentBlock.parentNode.nodeName.toLowerCase();\n } else {\n rootBlockName = '';\n }\n if (!parentBlock.hasChildNodes()) {\n const newBlock = dom.create(newBlockName);\n setForcedBlockAttrs(editor, newBlock);\n parentBlock.appendChild(newBlock);\n rng.setStart(newBlock, 0);\n rng.setEnd(newBlock, 0);\n return newBlock;\n }\n let node = container;\n while (node && node.parentNode !== parentBlock) {\n node = node.parentNode;\n }\n let startNode;\n while (node && !dom.isBlock(node)) {\n startNode = node;\n node = node.previousSibling;\n }\n if (startNode && editor.schema.isValidChild(rootBlockName, newBlockName.toLowerCase())) {\n const startNodeParent = startNode.parentNode;\n const newBlock = dom.create(newBlockName);\n setForcedBlockAttrs(editor, newBlock);\n startNodeParent.insertBefore(newBlock, startNode);\n node = startNode;\n while (node && !dom.isBlock(node)) {\n const next = node.nextSibling;\n newBlock.appendChild(node);\n node = next;\n }\n rng.setStart(container, offset);\n rng.setEnd(container, offset);\n }\n }\n return container;\n };\n const addBrToBlockIfNeeded = (dom, block) => {\n block.normalize();\n const lastChild = block.lastChild;\n if (!lastChild || isElement$6(lastChild) && /^(left|right)$/gi.test(dom.getStyle(lastChild, 'float', true))) {\n dom.add(block, 'br');\n }\n };\n const shouldEndContainer = (editor, container) => {\n const optionValue = shouldEndContainerOnEmptyBlock(editor);\n if (isNullable(container)) {\n return false;\n } else if (isString(optionValue)) {\n return contains$2(Tools.explode(optionValue), container.nodeName.toLowerCase());\n } else {\n return optionValue;\n }\n };\n const insert$2 = (editor, evt) => {\n let container;\n let offset;\n let parentBlockName;\n let containerBlock;\n let isAfterLastNodeInContainer = false;\n const dom = editor.dom;\n const schema = editor.schema, nonEmptyElementsMap = schema.getNonEmptyElements();\n const rng = editor.selection.getRng();\n const newBlockName = getForcedRootBlock(editor);\n const createNewBlock = name => {\n let node = container;\n const textInlineElements = schema.getTextInlineElements();\n let block;\n if (name || parentBlockName === 'TABLE' || parentBlockName === 'HR') {\n block = dom.create(name || newBlockName);\n } else {\n block = parentBlock.cloneNode(false);\n }\n let caretNode = block;\n if (shouldKeepStyles(editor) === false) {\n dom.setAttrib(block, 'style', null);\n dom.setAttrib(block, 'class', null);\n } else {\n do {\n if (textInlineElements[node.nodeName]) {\n if (isCaretNode(node) || isBookmarkNode$1(node)) {\n continue;\n }\n const clonedNode = node.cloneNode(false);\n dom.setAttrib(clonedNode, 'id', '');\n if (block.hasChildNodes()) {\n clonedNode.appendChild(block.firstChild);\n block.appendChild(clonedNode);\n } else {\n caretNode = clonedNode;\n block.appendChild(clonedNode);\n }\n }\n } while ((node = node.parentNode) && node !== editableRoot);\n }\n setForcedBlockAttrs(editor, block);\n emptyBlock(caretNode);\n return block;\n };\n const isCaretAtStartOrEndOfBlock = start => {\n const normalizedOffset = normalizeZwspOffset(start, container, offset);\n if (isText$a(container) && (start ? normalizedOffset > 0 : normalizedOffset < container.data.length)) {\n return false;\n }\n if (container.parentNode === parentBlock && isAfterLastNodeInContainer && !start) {\n return true;\n }\n if (start && isElement$6(container) && container === parentBlock.firstChild) {\n return true;\n }\n if (containerAndSiblingName(container, 'TABLE') || containerAndSiblingName(container, 'HR')) {\n return isAfterLastNodeInContainer && !start || !isAfterLastNodeInContainer && start;\n }\n const walker = new DomTreeWalker(container, parentBlock);\n if (isText$a(container)) {\n if (start && normalizedOffset === 0) {\n walker.prev();\n } else if (!start && normalizedOffset === container.data.length) {\n walker.next();\n }\n }\n let node;\n while (node = walker.current()) {\n if (isElement$6(node)) {\n if (!node.getAttribute('data-mce-bogus')) {\n const name = node.nodeName.toLowerCase();\n if (nonEmptyElementsMap[name] && name !== 'br') {\n return false;\n }\n }\n } else if (isText$a(node) && !isWhitespaceText(node.data)) {\n return false;\n }\n if (start) {\n walker.prev();\n } else {\n walker.next();\n }\n }\n return true;\n };\n const insertNewBlockAfter = () => {\n let block;\n if (/^(H[1-6]|PRE|FIGURE)$/.test(parentBlockName) && containerBlockName !== 'HGROUP') {\n block = createNewBlock(newBlockName);\n } else {\n block = createNewBlock();\n }\n if (shouldEndContainer(editor, containerBlock) && canSplitBlock(dom, containerBlock) && dom.isEmpty(parentBlock)) {\n block = dom.split(containerBlock, parentBlock);\n } else {\n dom.insertAfter(block, parentBlock);\n }\n moveToCaretPosition(editor, block);\n return block;\n };\n normalize$2(dom, rng).each(normRng => {\n rng.setStart(normRng.startContainer, normRng.startOffset);\n rng.setEnd(normRng.endContainer, normRng.endOffset);\n });\n container = rng.startContainer;\n offset = rng.startOffset;\n const shiftKey = !!(evt && evt.shiftKey);\n const ctrlKey = !!(evt && evt.ctrlKey);\n if (isElement$6(container) && container.hasChildNodes()) {\n isAfterLastNodeInContainer = offset > container.childNodes.length - 1;\n container = container.childNodes[Math.min(offset, container.childNodes.length - 1)] || container;\n if (isAfterLastNodeInContainer && isText$a(container)) {\n offset = container.data.length;\n } else {\n offset = 0;\n }\n }\n const editableRoot = getEditableRoot(dom, container);\n if (!editableRoot || isWithinNonEditableList(editor, container)) {\n return;\n }\n if (!shiftKey) {\n container = wrapSelfAndSiblingsInDefaultBlock(editor, newBlockName, rng, container, offset);\n }\n let parentBlock = dom.getParent(container, dom.isBlock) || dom.getRoot();\n containerBlock = isNonNullable(parentBlock === null || parentBlock === void 0 ? void 0 : parentBlock.parentNode) ? dom.getParent(parentBlock.parentNode, dom.isBlock) : null;\n parentBlockName = parentBlock ? parentBlock.nodeName.toUpperCase() : '';\n const containerBlockName = containerBlock ? containerBlock.nodeName.toUpperCase() : '';\n if (containerBlockName === 'LI' && !ctrlKey) {\n const liBlock = containerBlock;\n parentBlock = liBlock;\n containerBlock = liBlock.parentNode;\n parentBlockName = containerBlockName;\n }\n if (/^(LI|DT|DD)$/.test(parentBlockName) && isElement$6(containerBlock)) {\n if (dom.isEmpty(parentBlock)) {\n insert$3(editor, createNewBlock, containerBlock, parentBlock, newBlockName);\n return;\n }\n }\n if (parentBlock === editor.getBody()) {\n return;\n }\n const parentBlockParent = parentBlock.parentNode;\n let newBlock;\n if (isCaretContainerBlock$1(parentBlock)) {\n newBlock = showCaretContainerBlock(parentBlock);\n if (dom.isEmpty(parentBlock)) {\n emptyBlock(parentBlock);\n }\n setForcedBlockAttrs(editor, newBlock);\n moveToCaretPosition(editor, newBlock);\n } else if (isCaretAtStartOrEndOfBlock(false)) {\n newBlock = insertNewBlockAfter();\n } else if (isCaretAtStartOrEndOfBlock(true) && parentBlockParent) {\n newBlock = parentBlockParent.insertBefore(createNewBlock(), parentBlock);\n moveToCaretPosition(editor, containerAndSiblingName(parentBlock, 'HR') ? newBlock : parentBlock);\n } else {\n const tmpRng = includeZwspInRange(rng).cloneRange();\n tmpRng.setEndAfter(parentBlock);\n const fragment = tmpRng.extractContents();\n trimZwsp(fragment);\n trimLeadingLineBreaks(fragment);\n newBlock = fragment.firstChild;\n dom.insertAfter(fragment, parentBlock);\n trimInlineElementsOnLeftSideOfBlock(dom, nonEmptyElementsMap, newBlock);\n addBrToBlockIfNeeded(dom, parentBlock);\n if (dom.isEmpty(parentBlock)) {\n emptyBlock(parentBlock);\n }\n newBlock.normalize();\n if (dom.isEmpty(newBlock)) {\n dom.remove(newBlock);\n insertNewBlockAfter();\n } else {\n setForcedBlockAttrs(editor, newBlock);\n moveToCaretPosition(editor, newBlock);\n }\n }\n dom.setAttrib(newBlock, 'id', '');\n editor.dispatch('NewBlock', { newBlock });\n };\n const fakeEventName$1 = 'insertParagraph';\n const blockbreak = {\n insert: insert$2,\n fakeEventName: fakeEventName$1\n };\n\n const hasRightSideContent = (schema, container, parentBlock) => {\n const walker = new DomTreeWalker(container, parentBlock);\n let node;\n const nonEmptyElementsMap = schema.getNonEmptyElements();\n while (node = walker.next()) {\n if (nonEmptyElementsMap[node.nodeName.toLowerCase()] || isText$a(node) && node.length > 0) {\n return true;\n }\n }\n return false;\n };\n const moveSelectionToBr = (editor, brElm, extraBr) => {\n const rng = editor.dom.createRng();\n if (!extraBr) {\n rng.setStartAfter(brElm);\n rng.setEndAfter(brElm);\n } else {\n rng.setStartBefore(brElm);\n rng.setEndBefore(brElm);\n }\n editor.selection.setRng(rng);\n scrollRangeIntoView(editor, rng);\n };\n const insertBrAtCaret = (editor, evt) => {\n const selection = editor.selection;\n const dom = editor.dom;\n const rng = selection.getRng();\n let brElm;\n let extraBr = false;\n normalize$2(dom, rng).each(normRng => {\n rng.setStart(normRng.startContainer, normRng.startOffset);\n rng.setEnd(normRng.endContainer, normRng.endOffset);\n });\n let offset = rng.startOffset;\n let container = rng.startContainer;\n if (isElement$6(container) && container.hasChildNodes()) {\n const isAfterLastNodeInContainer = offset > container.childNodes.length - 1;\n container = container.childNodes[Math.min(offset, container.childNodes.length - 1)] || container;\n if (isAfterLastNodeInContainer && isText$a(container)) {\n offset = container.data.length;\n } else {\n offset = 0;\n }\n }\n let parentBlock = dom.getParent(container, dom.isBlock);\n const containerBlock = parentBlock && parentBlock.parentNode ? dom.getParent(parentBlock.parentNode, dom.isBlock) : null;\n const containerBlockName = containerBlock ? containerBlock.nodeName.toUpperCase() : '';\n const isControlKey = !!(evt && evt.ctrlKey);\n if (containerBlockName === 'LI' && !isControlKey) {\n parentBlock = containerBlock;\n }\n if (isText$a(container) && offset >= container.data.length) {\n if (!hasRightSideContent(editor.schema, container, parentBlock || dom.getRoot())) {\n brElm = dom.create('br');\n rng.insertNode(brElm);\n rng.setStartAfter(brElm);\n rng.setEndAfter(brElm);\n extraBr = true;\n }\n }\n brElm = dom.create('br');\n rangeInsertNode(dom, rng, brElm);\n moveSelectionToBr(editor, brElm, extraBr);\n editor.undoManager.add();\n };\n const insertBrBefore = (editor, inline) => {\n const br = SugarElement.fromTag('br');\n before$3(SugarElement.fromDom(inline), br);\n editor.undoManager.add();\n };\n const insertBrAfter = (editor, inline) => {\n if (!hasBrAfter(editor.getBody(), inline)) {\n after$4(SugarElement.fromDom(inline), SugarElement.fromTag('br'));\n }\n const br = SugarElement.fromTag('br');\n after$4(SugarElement.fromDom(inline), br);\n moveSelectionToBr(editor, br.dom, false);\n editor.undoManager.add();\n };\n const isBeforeBr = pos => {\n return isBr$6(pos.getNode());\n };\n const hasBrAfter = (rootNode, startNode) => {\n if (isBeforeBr(CaretPosition.after(startNode))) {\n return true;\n } else {\n return nextPosition(rootNode, CaretPosition.after(startNode)).map(pos => {\n return isBr$6(pos.getNode());\n }).getOr(false);\n }\n };\n const isAnchorLink = elm => {\n return elm && elm.nodeName === 'A' && 'href' in elm;\n };\n const isInsideAnchor = location => {\n return location.fold(never, isAnchorLink, isAnchorLink, never);\n };\n const readInlineAnchorLocation = editor => {\n const isInlineTarget$1 = curry(isInlineTarget, editor);\n const position = CaretPosition.fromRangeStart(editor.selection.getRng());\n return readLocation(isInlineTarget$1, editor.getBody(), position).filter(isInsideAnchor);\n };\n const insertBrOutsideAnchor = (editor, location) => {\n location.fold(noop, curry(insertBrBefore, editor), curry(insertBrAfter, editor), noop);\n };\n const insert$1 = (editor, evt) => {\n const anchorLocation = readInlineAnchorLocation(editor);\n if (anchorLocation.isSome()) {\n anchorLocation.each(curry(insertBrOutsideAnchor, editor));\n } else {\n insertBrAtCaret(editor, evt);\n }\n };\n const fakeEventName = 'insertLineBreak';\n const linebreak = {\n insert: insert$1,\n fakeEventName\n };\n\n const matchesSelector = (editor, selector) => {\n return getParentBlock$1(editor).filter(parentBlock => {\n return selector.length > 0 && is$1(SugarElement.fromDom(parentBlock), selector);\n }).isSome();\n };\n const shouldInsertBr = editor => {\n return matchesSelector(editor, getBrNewLineSelector(editor));\n };\n const shouldBlockNewLine$1 = editor => {\n return matchesSelector(editor, getNoNewLineSelector(editor));\n };\n\n const newLineAction = Adt.generate([\n { br: [] },\n { block: [] },\n { none: [] }\n ]);\n const shouldBlockNewLine = (editor, _shiftKey) => {\n return shouldBlockNewLine$1(editor);\n };\n const inListBlock = requiredState => {\n return (editor, _shiftKey) => {\n return isListItemParentBlock(editor) === requiredState;\n };\n };\n const inBlock = (blockName, requiredState) => (editor, _shiftKey) => {\n const state = getParentBlockName(editor) === blockName.toUpperCase();\n return state === requiredState;\n };\n const inCefBlock = editor => {\n const editableRoot = getEditableRoot(editor.dom, editor.selection.getStart());\n return isNullable(editableRoot);\n };\n const inPreBlock = requiredState => inBlock('pre', requiredState);\n const inSummaryBlock = () => inBlock('summary', true);\n const shouldPutBrInPre = requiredState => {\n return (editor, _shiftKey) => {\n return shouldPutBrInPre$1(editor) === requiredState;\n };\n };\n const inBrContext = (editor, _shiftKey) => {\n return shouldInsertBr(editor);\n };\n const hasShiftKey = (_editor, shiftKey) => {\n return shiftKey;\n };\n const canInsertIntoEditableRoot = editor => {\n const forcedRootBlock = getForcedRootBlock(editor);\n const rootEditable = getEditableRoot(editor.dom, editor.selection.getStart());\n return isNonNullable(rootEditable) && editor.schema.isValidChild(rootEditable.nodeName, forcedRootBlock);\n };\n const match = (predicates, action) => {\n return (editor, shiftKey) => {\n const isMatch = foldl(predicates, (res, p) => {\n return res && p(editor, shiftKey);\n }, true);\n return isMatch ? Optional.some(action) : Optional.none();\n };\n };\n const getAction = (editor, evt) => {\n return evaluateUntil([\n match([shouldBlockNewLine], newLineAction.none()),\n match([\n inPreBlock(true),\n inCefBlock\n ], newLineAction.none()),\n match([inSummaryBlock()], newLineAction.br()),\n match([\n inPreBlock(true),\n shouldPutBrInPre(false),\n hasShiftKey\n ], newLineAction.br()),\n match([\n inPreBlock(true),\n shouldPutBrInPre(false)\n ], newLineAction.block()),\n match([\n inPreBlock(true),\n shouldPutBrInPre(true),\n hasShiftKey\n ], newLineAction.block()),\n match([\n inPreBlock(true),\n shouldPutBrInPre(true)\n ], newLineAction.br()),\n match([\n inListBlock(true),\n hasShiftKey\n ], newLineAction.br()),\n match([inListBlock(true)], newLineAction.block()),\n match([inBrContext], newLineAction.br()),\n match([hasShiftKey], newLineAction.br()),\n match([canInsertIntoEditableRoot], newLineAction.block())\n ], [\n editor,\n !!(evt && evt.shiftKey)\n ]).getOr(newLineAction.none());\n };\n\n const insertBreak = (breakType, editor, evt) => {\n if (!editor.selection.isCollapsed()) {\n execEditorDeleteCommand(editor);\n }\n if (isNonNullable(evt)) {\n const event = fireFakeBeforeInputEvent(editor, breakType.fakeEventName);\n if (event.isDefaultPrevented()) {\n return;\n }\n }\n breakType.insert(editor, evt);\n if (isNonNullable(evt)) {\n fireFakeInputEvent(editor, breakType.fakeEventName);\n }\n };\n const insert = (editor, evt) => {\n const br = () => insertBreak(linebreak, editor, evt);\n const block = () => insertBreak(blockbreak, editor, evt);\n const logicalAction = getAction(editor, evt);\n switch (getNewlineBehavior(editor)) {\n case 'linebreak':\n logicalAction.fold(br, br, noop);\n break;\n case 'block':\n logicalAction.fold(block, block, noop);\n break;\n case 'invert':\n logicalAction.fold(block, br, noop);\n break;\n default:\n logicalAction.fold(br, block, noop);\n break;\n }\n };\n\n const handleEnterKeyEvent = (editor, event) => {\n if (event.isDefaultPrevented()) {\n return;\n }\n event.preventDefault();\n endTypingLevelIgnoreLocks(editor.undoManager);\n editor.undoManager.transact(() => {\n insert(editor, event);\n });\n };\n const setup$h = editor => {\n editor.on('keydown', event => {\n if (event.keyCode === VK.ENTER) {\n handleEnterKeyEvent(editor, event);\n }\n });\n };\n\n const executeKeydownOverride$2 = (editor, caret, evt) => {\n const isMac = Env.os.isMacOS() || Env.os.isiOS();\n execute([\n {\n keyCode: VK.END,\n action: action(moveToLineEndPoint$1, editor, true)\n },\n {\n keyCode: VK.HOME,\n action: action(moveToLineEndPoint$1, editor, false)\n },\n ...!isMac ? [\n {\n keyCode: VK.HOME,\n action: action(selectToEndPoint, editor, false),\n ctrlKey: true,\n shiftKey: true\n },\n {\n keyCode: VK.END,\n action: action(selectToEndPoint, editor, true),\n ctrlKey: true,\n shiftKey: true\n }\n ] : [],\n {\n keyCode: VK.END,\n action: action(moveToLineEndPoint, editor, true)\n },\n {\n keyCode: VK.HOME,\n action: action(moveToLineEndPoint, editor, false)\n },\n {\n keyCode: VK.END,\n action: action(moveToLineEndPoint$2, editor, true, caret)\n },\n {\n keyCode: VK.HOME,\n action: action(moveToLineEndPoint$2, editor, false, caret)\n }\n ], evt).each(_ => {\n evt.preventDefault();\n });\n };\n const setup$g = (editor, caret) => {\n editor.on('keydown', evt => {\n if (!evt.isDefaultPrevented()) {\n executeKeydownOverride$2(editor, caret, evt);\n }\n });\n };\n\n const setup$f = editor => {\n editor.on('input', e => {\n if (!e.isComposing) {\n normalizeNbspsInEditor(editor);\n }\n });\n };\n\n const platform = detect$2();\n const executeKeyupAction = (editor, caret, evt) => {\n execute([\n {\n keyCode: VK.PAGE_UP,\n action: action(moveToLineEndPoint$2, editor, false, caret)\n },\n {\n keyCode: VK.PAGE_DOWN,\n action: action(moveToLineEndPoint$2, editor, true, caret)\n }\n ], evt);\n };\n const stopImmediatePropagation = e => e.stopImmediatePropagation();\n const isPageUpDown = evt => evt.keyCode === VK.PAGE_UP || evt.keyCode === VK.PAGE_DOWN;\n const setNodeChangeBlocker = (blocked, editor, block) => {\n if (block && !blocked.get()) {\n editor.on('NodeChange', stopImmediatePropagation, true);\n } else if (!block && blocked.get()) {\n editor.off('NodeChange', stopImmediatePropagation);\n }\n blocked.set(block);\n };\n const setup$e = (editor, caret) => {\n if (platform.os.isMacOS()) {\n return;\n }\n const blocked = Cell(false);\n editor.on('keydown', evt => {\n if (isPageUpDown(evt)) {\n setNodeChangeBlocker(blocked, editor, true);\n }\n });\n editor.on('keyup', evt => {\n if (!evt.isDefaultPrevented()) {\n executeKeyupAction(editor, caret, evt);\n }\n if (isPageUpDown(evt) && blocked.get()) {\n setNodeChangeBlocker(blocked, editor, false);\n editor.nodeChanged();\n }\n });\n };\n\n const insertTextAtPosition = (text, pos) => {\n const container = pos.container();\n const offset = pos.offset();\n if (isText$a(container)) {\n container.insertData(offset, text);\n return Optional.some(CaretPosition(container, offset + text.length));\n } else {\n return getElementFromPosition(pos).map(elm => {\n const textNode = SugarElement.fromText(text);\n if (pos.isAtEnd()) {\n after$4(elm, textNode);\n } else {\n before$3(elm, textNode);\n }\n return CaretPosition(textNode.dom, text.length);\n });\n }\n };\n const insertNbspAtPosition = curry(insertTextAtPosition, nbsp);\n const insertSpaceAtPosition = curry(insertTextAtPosition, ' ');\n\n const locationToCaretPosition = root => location => location.fold(element => prevPosition(root.dom, CaretPosition.before(element)), element => firstPositionIn(element), element => lastPositionIn(element), element => nextPosition(root.dom, CaretPosition.after(element)));\n const insertInlineBoundarySpaceOrNbsp = (root, pos) => checkPos => needsToHaveNbsp(root, checkPos) ? insertNbspAtPosition(pos) : insertSpaceAtPosition(pos);\n const setSelection = editor => pos => {\n editor.selection.setRng(pos.toRange());\n editor.nodeChanged();\n return true;\n };\n const insertSpaceOrNbspAtSelection = editor => {\n const pos = CaretPosition.fromRangeStart(editor.selection.getRng());\n const root = SugarElement.fromDom(editor.getBody());\n if (editor.selection.isCollapsed()) {\n const isInlineTarget$1 = curry(isInlineTarget, editor);\n const caretPosition = CaretPosition.fromRangeStart(editor.selection.getRng());\n return readLocation(isInlineTarget$1, editor.getBody(), caretPosition).bind(locationToCaretPosition(root)).map(checkPos => () => insertInlineBoundarySpaceOrNbsp(root, pos)(checkPos).each(setSelection(editor)));\n } else {\n return Optional.none();\n }\n };\n\n const executeKeydownOverride$1 = (editor, evt) => {\n executeWithDelayedAction([{\n keyCode: VK.SPACEBAR,\n action: action(insertSpaceOrNbspAtSelection, editor)\n }], evt).each(applyAction => {\n evt.preventDefault();\n const event = fireFakeBeforeInputEvent(editor, 'insertText', { data: ' ' });\n if (!event.isDefaultPrevented()) {\n applyAction();\n fireFakeInputEvent(editor, 'insertText', { data: ' ' });\n }\n });\n };\n const setup$d = editor => {\n editor.on('keydown', evt => {\n if (!evt.isDefaultPrevented()) {\n executeKeydownOverride$1(editor, evt);\n }\n });\n };\n\n const tableTabNavigation = editor => {\n if (hasTableTabNavigation(editor)) {\n return [\n {\n keyCode: VK.TAB,\n action: action(handleTab, editor, true)\n },\n {\n keyCode: VK.TAB,\n shiftKey: true,\n action: action(handleTab, editor, false)\n }\n ];\n } else {\n return [];\n }\n };\n const executeKeydownOverride = (editor, evt) => {\n execute([...tableTabNavigation(editor)], evt).each(_ => {\n evt.preventDefault();\n });\n };\n const setup$c = editor => {\n editor.on('keydown', evt => {\n if (!evt.isDefaultPrevented()) {\n executeKeydownOverride(editor, evt);\n }\n });\n };\n\n const setup$b = editor => {\n editor.addShortcut('Meta+P', '', 'mcePrint');\n setup$j(editor);\n if (isRtc(editor)) {\n return Cell(null);\n } else {\n const caret = setupSelectedState(editor);\n setup$l(editor);\n setup$k(editor, caret);\n setup$i(editor, caret);\n setup$h(editor);\n setup$d(editor);\n setup$f(editor);\n setup$c(editor);\n setup$g(editor, caret);\n setup$e(editor, caret);\n return caret;\n }\n };\n\n class NodeChange {\n constructor(editor) {\n this.lastPath = [];\n this.editor = editor;\n let lastRng;\n const self = this;\n if (!('onselectionchange' in editor.getDoc())) {\n editor.on('NodeChange click mouseup keyup focus', e => {\n const nativeRng = editor.selection.getRng();\n const fakeRng = {\n startContainer: nativeRng.startContainer,\n startOffset: nativeRng.startOffset,\n endContainer: nativeRng.endContainer,\n endOffset: nativeRng.endOffset\n };\n if (e.type === 'nodechange' || !isEq$4(fakeRng, lastRng)) {\n editor.dispatch('SelectionChange');\n }\n lastRng = fakeRng;\n });\n }\n editor.on('contextmenu', () => {\n editor.dispatch('SelectionChange');\n });\n editor.on('SelectionChange', () => {\n const startElm = editor.selection.getStart(true);\n if (!startElm) {\n return;\n }\n if (hasAnyRanges(editor) && !self.isSameElementPath(startElm) && editor.dom.isChildOf(startElm, editor.getBody())) {\n editor.nodeChanged({ selectionChange: true });\n }\n });\n editor.on('mouseup', e => {\n if (!e.isDefaultPrevented() && hasAnyRanges(editor)) {\n if (editor.selection.getNode().nodeName === 'IMG') {\n Delay.setEditorTimeout(editor, () => {\n editor.nodeChanged();\n });\n } else {\n editor.nodeChanged();\n }\n }\n });\n }\n nodeChanged(args = {}) {\n const selection = this.editor.selection;\n let node;\n if (this.editor.initialized && selection && !shouldDisableNodeChange(this.editor) && !this.editor.mode.isReadOnly()) {\n const root = this.editor.getBody();\n node = selection.getStart(true) || root;\n if (node.ownerDocument !== this.editor.getDoc() || !this.editor.dom.isChildOf(node, root)) {\n node = root;\n }\n const parents = [];\n this.editor.dom.getParent(node, node => {\n if (node === root) {\n return true;\n } else {\n parents.push(node);\n return false;\n }\n });\n this.editor.dispatch('NodeChange', {\n ...args,\n element: node,\n parents\n });\n }\n }\n isSameElementPath(startElm) {\n let i;\n const editor = this.editor;\n const currentPath = reverse(editor.dom.getParents(startElm, always, editor.getBody()));\n if (currentPath.length === this.lastPath.length) {\n for (i = currentPath.length; i >= 0; i--) {\n if (currentPath[i] !== this.lastPath[i]) {\n break;\n }\n }\n if (i === -1) {\n this.lastPath = currentPath;\n return true;\n }\n }\n this.lastPath = currentPath;\n return false;\n }\n }\n\n const internalMimeType = 'x-tinymce/html';\n const internalHtmlMime = constant(internalMimeType);\n const internalMark = '';\n const mark = html => internalMark + html;\n const unmark = html => html.replace(internalMark, '');\n const isMarked = html => html.indexOf(internalMark) !== -1;\n\n const isPlainText = text => {\n return !/<(?:\\/?(?!(?:div|p|br|span)>)\\w+|(?:(?!(?:span style=\"white-space:\\s?pre;?\">)|br\\s?\\/>))\\w+\\s[^>]+)>/i.test(text);\n };\n const openContainer = (rootTag, rootAttrs) => {\n let tag = '<' + rootTag;\n const attrs = mapToArray(rootAttrs, (value, key) => key + '=\"' + Entities.encodeAllRaw(value) + '\"');\n if (attrs.length) {\n tag += ' ' + attrs.join(' ');\n }\n return tag + '>';\n };\n const toBlockElements = (text, rootTag, rootAttrs) => {\n const blocks = text.split(/\\n\\n/);\n const tagOpen = openContainer(rootTag, rootAttrs);\n const tagClose = '';\n const paragraphs = map$3(blocks, p => {\n return p.split(/\\n/).join('
');\n });\n const stitch = p => {\n return tagOpen + p + tagClose;\n };\n return paragraphs.length === 1 ? paragraphs[0] : map$3(paragraphs, stitch).join('');\n };\n\n const pasteBinDefaultContent = '%MCEPASTEBIN%';\n const create$6 = (editor, lastRngCell) => {\n const {dom, selection} = editor;\n const body = editor.getBody();\n lastRngCell.set(selection.getRng());\n const pasteBinElm = dom.add(editor.getBody(), 'div', {\n 'id': 'mcepastebin',\n 'class': 'mce-pastebin',\n 'contentEditable': true,\n 'data-mce-bogus': 'all',\n 'style': 'position: fixed; top: 50%; width: 10px; height: 10px; overflow: hidden; opacity: 0'\n }, pasteBinDefaultContent);\n if (Env.browser.isFirefox()) {\n dom.setStyle(pasteBinElm, 'left', dom.getStyle(body, 'direction', true) === 'rtl' ? 65535 : -65535);\n }\n dom.bind(pasteBinElm, 'beforedeactivate focusin focusout', e => {\n e.stopPropagation();\n });\n pasteBinElm.focus();\n selection.select(pasteBinElm, true);\n };\n const remove = (editor, lastRngCell) => {\n const dom = editor.dom;\n if (getEl(editor)) {\n let pasteBinClone;\n const lastRng = lastRngCell.get();\n while (pasteBinClone = getEl(editor)) {\n dom.remove(pasteBinClone);\n dom.unbind(pasteBinClone);\n }\n if (lastRng) {\n editor.selection.setRng(lastRng);\n }\n }\n lastRngCell.set(null);\n };\n const getEl = editor => editor.dom.get('mcepastebin');\n const isPasteBin = elm => isNonNullable(elm) && elm.id === 'mcepastebin';\n const getHtml = editor => {\n const dom = editor.dom;\n const copyAndRemove = (toElm, fromElm) => {\n toElm.appendChild(fromElm);\n dom.remove(fromElm, true);\n };\n const [pasteBinElm, ...pasteBinClones] = filter$5(editor.getBody().childNodes, isPasteBin);\n each$e(pasteBinClones, pasteBinClone => {\n copyAndRemove(pasteBinElm, pasteBinClone);\n });\n const dirtyWrappers = dom.select('div[id=mcepastebin]', pasteBinElm);\n for (let i = dirtyWrappers.length - 1; i >= 0; i--) {\n const cleanWrapper = dom.create('div');\n pasteBinElm.insertBefore(cleanWrapper, dirtyWrappers[i]);\n copyAndRemove(cleanWrapper, dirtyWrappers[i]);\n }\n return pasteBinElm ? pasteBinElm.innerHTML : '';\n };\n const isDefaultPasteBinContent = content => content === pasteBinDefaultContent;\n const PasteBin = editor => {\n const lastRng = Cell(null);\n return {\n create: () => create$6(editor, lastRng),\n remove: () => remove(editor, lastRng),\n getEl: () => getEl(editor),\n getHtml: () => getHtml(editor),\n getLastRng: lastRng.get\n };\n };\n\n const filter = (content, items) => {\n Tools.each(items, v => {\n if (is$4(v, RegExp)) {\n content = content.replace(v, '');\n } else {\n content = content.replace(v[0], v[1]);\n }\n });\n return content;\n };\n const innerText = html => {\n const schema = Schema();\n const domParser = DomParser({}, schema);\n let text = '';\n const voidElements = schema.getVoidElements();\n const ignoreElements = Tools.makeMap('script noscript style textarea video audio iframe object', ' ');\n const blockElements = schema.getBlockElements();\n const walk = node => {\n const name = node.name, currentNode = node;\n if (name === 'br') {\n text += '\\n';\n return;\n }\n if (name === 'wbr') {\n return;\n }\n if (voidElements[name]) {\n text += ' ';\n }\n if (ignoreElements[name]) {\n text += ' ';\n return;\n }\n if (node.type === 3) {\n text += node.value;\n }\n if (!(node.name in schema.getVoidElements())) {\n let currentNode = node.firstChild;\n if (currentNode) {\n do {\n walk(currentNode);\n } while (currentNode = currentNode.next);\n }\n }\n if (blockElements[name] && currentNode.next) {\n text += '\\n';\n if (name === 'p') {\n text += '\\n';\n }\n }\n };\n html = filter(html, [//g]);\n walk(domParser.parse(html));\n return text;\n };\n const trimHtml = html => {\n const trimSpaces = (all, s1, s2) => {\n if (!s1 && !s2) {\n return ' ';\n }\n return nbsp;\n };\n html = filter(html, [\n /^[\\s\\S]*
/g,\n /
$/i\n ]);\n return html;\n };\n const createIdGenerator = prefix => {\n let count = 0;\n return () => {\n return prefix + count++;\n };\n };\n const getImageMimeType = ext => {\n const lowerExt = ext.toLowerCase();\n const mimeOverrides = {\n jpg: 'jpeg',\n jpe: 'jpeg',\n jfi: 'jpeg',\n jif: 'jpeg',\n jfif: 'jpeg',\n pjpeg: 'jpeg',\n pjp: 'jpeg',\n svg: 'svg+xml'\n };\n return Tools.hasOwn(mimeOverrides, lowerExt) ? 'image/' + mimeOverrides[lowerExt] : 'image/' + lowerExt;\n };\n\n const preProcess = (editor, html) => {\n const parser = DomParser({}, editor.schema);\n parser.addNodeFilter('meta', nodes => {\n Tools.each(nodes, node => {\n node.remove();\n });\n });\n const fragment = parser.parse(html, {\n forced_root_block: false,\n isRootContent: true\n });\n return HtmlSerializer({ validate: true }, editor.schema).serialize(fragment);\n };\n const processResult = (content, cancelled) => ({\n content,\n cancelled\n });\n const postProcessFilter = (editor, html, internal) => {\n const tempBody = editor.dom.create('div', { style: 'display:none' }, html);\n const postProcessArgs = firePastePostProcess(editor, tempBody, internal);\n return processResult(postProcessArgs.node.innerHTML, postProcessArgs.isDefaultPrevented());\n };\n const filterContent = (editor, content, internal) => {\n const preProcessArgs = firePastePreProcess(editor, content, internal);\n const filteredContent = preProcess(editor, preProcessArgs.content);\n if (editor.hasEventListeners('PastePostProcess') && !preProcessArgs.isDefaultPrevented()) {\n return postProcessFilter(editor, filteredContent, internal);\n } else {\n return processResult(filteredContent, preProcessArgs.isDefaultPrevented());\n }\n };\n const process = (editor, html, internal) => {\n return filterContent(editor, html, internal);\n };\n\n const pasteHtml$1 = (editor, html) => {\n editor.insertContent(html, {\n merge: shouldPasteMergeFormats(editor),\n paste: true\n });\n return true;\n };\n const isAbsoluteUrl = url => /^https?:\\/\\/[\\w\\-\\/+=.,!;:&%@^~(){}?#]+$/i.test(url);\n const isImageUrl = (editor, url) => {\n return isAbsoluteUrl(url) && exists(getAllowedImageFileTypes(editor), type => endsWith(url.toLowerCase(), `.${ type.toLowerCase() }`));\n };\n const createImage = (editor, url, pasteHtmlFn) => {\n editor.undoManager.extra(() => {\n pasteHtmlFn(editor, url);\n }, () => {\n editor.insertContent('
' + '';\n return iframeHTML;\n };\n const createIframe = (editor, boxInfo) => {\n const iframeTitle = editor.translate('Rich Text Area');\n const tabindex = getOpt(SugarElement.fromDom(editor.getElement()), 'tabindex').bind(toInt);\n const ifr = createIframeElement(editor.id, iframeTitle, getIframeAttrs(editor), tabindex).dom;\n ifr.onload = () => {\n ifr.onload = null;\n editor.dispatch('load');\n };\n editor.contentAreaContainer = boxInfo.iframeContainer;\n editor.iframeElement = ifr;\n editor.iframeHTML = getIframeHtml(editor);\n DOM$5.add(boxInfo.iframeContainer, ifr);\n };\n const init$1 = (editor, boxInfo) => {\n createIframe(editor, boxInfo);\n if (boxInfo.editorContainer) {\n boxInfo.editorContainer.style.display = editor.orgDisplay;\n editor.hidden = DOM$5.isHidden(boxInfo.editorContainer);\n }\n editor.getElement().style.display = 'none';\n DOM$5.setAttrib(editor.id, 'aria-hidden', 'true');\n initContentBody(editor);\n };\n\n const DOM$4 = DOMUtils.DOM;\n const initPlugin = (editor, initializedPlugins, plugin) => {\n const Plugin = PluginManager.get(plugin);\n const pluginUrl = PluginManager.urls[plugin] || editor.documentBaseUrl.replace(/\\/$/, '');\n plugin = Tools.trim(plugin);\n if (Plugin && Tools.inArray(initializedPlugins, plugin) === -1) {\n if (editor.plugins[plugin]) {\n return;\n }\n try {\n const pluginInstance = Plugin(editor, pluginUrl) || {};\n editor.plugins[plugin] = pluginInstance;\n if (isFunction(pluginInstance.init)) {\n pluginInstance.init(editor, pluginUrl);\n initializedPlugins.push(plugin);\n }\n } catch (e) {\n pluginInitError(editor, plugin, e);\n }\n }\n };\n const trimLegacyPrefix = name => {\n return name.replace(/^\\-/, '');\n };\n const initPlugins = editor => {\n const initializedPlugins = [];\n each$e(getPlugins(editor), name => {\n initPlugin(editor, initializedPlugins, trimLegacyPrefix(name));\n });\n };\n const initIcons = editor => {\n const iconPackName = Tools.trim(getIconPackName(editor));\n const currentIcons = editor.ui.registry.getAll().icons;\n const loadIcons = {\n ...IconManager.get('default').icons,\n ...IconManager.get(iconPackName).icons\n };\n each$d(loadIcons, (svgData, icon) => {\n if (!has$2(currentIcons, icon)) {\n editor.ui.registry.addIcon(icon, svgData);\n }\n });\n };\n const initTheme = editor => {\n const theme = getTheme(editor);\n if (isString(theme)) {\n const Theme = ThemeManager.get(theme);\n editor.theme = Theme(editor, ThemeManager.urls[theme]) || {};\n if (isFunction(editor.theme.init)) {\n editor.theme.init(editor, ThemeManager.urls[theme] || editor.documentBaseUrl.replace(/\\/$/, ''));\n }\n } else {\n editor.theme = {};\n }\n };\n const initModel = editor => {\n const model = getModel(editor);\n const Model = ModelManager.get(model);\n editor.model = Model(editor, ModelManager.urls[model]);\n };\n const renderFromLoadedTheme = editor => {\n const render = editor.theme.renderUI;\n return render ? render() : renderThemeFalse(editor);\n };\n const renderFromThemeFunc = editor => {\n const elm = editor.getElement();\n const theme = getTheme(editor);\n const info = theme(editor, elm);\n if (info.editorContainer.nodeType) {\n info.editorContainer.id = info.editorContainer.id || editor.id + '_parent';\n }\n if (info.iframeContainer && info.iframeContainer.nodeType) {\n info.iframeContainer.id = info.iframeContainer.id || editor.id + '_iframecontainer';\n }\n info.height = info.iframeHeight ? info.iframeHeight : elm.offsetHeight;\n return info;\n };\n const createThemeFalseResult = (element, iframe) => {\n return {\n editorContainer: element,\n iframeContainer: iframe,\n api: {}\n };\n };\n const renderThemeFalseIframe = targetElement => {\n const iframeContainer = DOM$4.create('div');\n DOM$4.insertAfter(iframeContainer, targetElement);\n return createThemeFalseResult(iframeContainer, iframeContainer);\n };\n const renderThemeFalse = editor => {\n const targetElement = editor.getElement();\n return editor.inline ? createThemeFalseResult(null) : renderThemeFalseIframe(targetElement);\n };\n const renderThemeUi = editor => {\n const elm = editor.getElement();\n editor.orgDisplay = elm.style.display;\n if (isString(getTheme(editor))) {\n return renderFromLoadedTheme(editor);\n } else if (isFunction(getTheme(editor))) {\n return renderFromThemeFunc(editor);\n } else {\n return renderThemeFalse(editor);\n }\n };\n const augmentEditorUiApi = (editor, api) => {\n const uiApiFacade = {\n show: Optional.from(api.show).getOr(noop),\n hide: Optional.from(api.hide).getOr(noop),\n isEnabled: Optional.from(api.isEnabled).getOr(always),\n setEnabled: state => {\n if (!editor.mode.isReadOnly()) {\n Optional.from(api.setEnabled).each(f => f(state));\n }\n }\n };\n editor.ui = {\n ...editor.ui,\n ...uiApiFacade\n };\n };\n const init = editor => {\n editor.dispatch('ScriptsLoaded');\n initIcons(editor);\n initTheme(editor);\n initModel(editor);\n initPlugins(editor);\n const renderInfo = renderThemeUi(editor);\n augmentEditorUiApi(editor, Optional.from(renderInfo.api).getOr({}));\n editor.editorContainer = renderInfo.editorContainer;\n appendContentCssFromSettings(editor);\n if (editor.inline) {\n initContentBody(editor);\n } else {\n init$1(editor, {\n editorContainer: renderInfo.editorContainer,\n iframeContainer: renderInfo.iframeContainer\n });\n }\n };\n\n const DOM$3 = DOMUtils.DOM;\n const hasSkipLoadPrefix = name => name.charAt(0) === '-';\n const loadLanguage = (scriptLoader, editor) => {\n const languageCode = getLanguageCode(editor);\n const languageUrl = getLanguageUrl(editor);\n if (!I18n.hasCode(languageCode) && languageCode !== 'en') {\n const url = isNotEmpty(languageUrl) ? languageUrl : `${ editor.editorManager.baseURL }/langs/${ languageCode }.js`;\n scriptLoader.add(url).catch(() => {\n languageLoadError(editor, url, languageCode);\n });\n }\n };\n const loadTheme = (editor, suffix) => {\n const theme = getTheme(editor);\n if (isString(theme) && !hasSkipLoadPrefix(theme) && !has$2(ThemeManager.urls, theme)) {\n const themeUrl = getThemeUrl(editor);\n const url = themeUrl ? editor.documentBaseURI.toAbsolute(themeUrl) : `themes/${ theme }/theme${ suffix }.js`;\n ThemeManager.load(theme, url).catch(() => {\n themeLoadError(editor, url, theme);\n });\n }\n };\n const loadModel = (editor, suffix) => {\n const model = getModel(editor);\n if (model !== 'plugin' && !has$2(ModelManager.urls, model)) {\n const modelUrl = getModelUrl(editor);\n const url = isString(modelUrl) ? editor.documentBaseURI.toAbsolute(modelUrl) : `models/${ model }/model${ suffix }.js`;\n ModelManager.load(model, url).catch(() => {\n modelLoadError(editor, url, model);\n });\n }\n };\n const getIconsUrlMetaFromUrl = editor => Optional.from(getIconsUrl(editor)).filter(isNotEmpty).map(url => ({\n url,\n name: Optional.none()\n }));\n const getIconsUrlMetaFromName = (editor, name, suffix) => Optional.from(name).filter(name => isNotEmpty(name) && !IconManager.has(name)).map(name => ({\n url: `${ editor.editorManager.baseURL }/icons/${ name }/icons${ suffix }.js`,\n name: Optional.some(name)\n }));\n const loadIcons = (scriptLoader, editor, suffix) => {\n const defaultIconsUrl = getIconsUrlMetaFromName(editor, 'default', suffix);\n const customIconsUrl = getIconsUrlMetaFromUrl(editor).orThunk(() => getIconsUrlMetaFromName(editor, getIconPackName(editor), ''));\n each$e(cat([\n defaultIconsUrl,\n customIconsUrl\n ]), urlMeta => {\n scriptLoader.add(urlMeta.url).catch(() => {\n iconsLoadError(editor, urlMeta.url, urlMeta.name.getOrUndefined());\n });\n });\n };\n const loadPlugins = (editor, suffix) => {\n const loadPlugin = (name, url) => {\n PluginManager.load(name, url).catch(() => {\n pluginLoadError(editor, url, name);\n });\n };\n each$d(getExternalPlugins$1(editor), (url, name) => {\n loadPlugin(name, url);\n editor.options.set('plugins', getPlugins(editor).concat(name));\n });\n each$e(getPlugins(editor), plugin => {\n plugin = Tools.trim(plugin);\n if (plugin && !PluginManager.urls[plugin] && !hasSkipLoadPrefix(plugin)) {\n loadPlugin(plugin, `plugins/${ plugin }/plugin${ suffix }.js`);\n }\n });\n };\n const isThemeLoaded = editor => {\n const theme = getTheme(editor);\n return !isString(theme) || isNonNullable(ThemeManager.get(theme));\n };\n const isModelLoaded = editor => {\n const model = getModel(editor);\n return isNonNullable(ModelManager.get(model));\n };\n const loadScripts = (editor, suffix) => {\n const scriptLoader = ScriptLoader.ScriptLoader;\n const initEditor = () => {\n if (!editor.removed && isThemeLoaded(editor) && isModelLoaded(editor)) {\n init(editor);\n }\n };\n loadTheme(editor, suffix);\n loadModel(editor, suffix);\n loadLanguage(scriptLoader, editor);\n loadIcons(scriptLoader, editor, suffix);\n loadPlugins(editor, suffix);\n scriptLoader.loadQueue().then(initEditor, initEditor);\n };\n const getStyleSheetLoader = (element, editor) => instance.forElement(element, {\n contentCssCors: hasContentCssCors(editor),\n referrerPolicy: getReferrerPolicy(editor)\n });\n const render = editor => {\n const id = editor.id;\n I18n.setCode(getLanguageCode(editor));\n const readyHandler = () => {\n DOM$3.unbind(window, 'ready', readyHandler);\n editor.render();\n };\n if (!EventUtils.Event.domLoaded) {\n DOM$3.bind(window, 'ready', readyHandler);\n return;\n }\n if (!editor.getElement()) {\n return;\n }\n const element = SugarElement.fromDom(editor.getElement());\n const snapshot = clone$4(element);\n editor.on('remove', () => {\n eachr(element.dom.attributes, attr => remove$b(element, attr.name));\n setAll$1(element, snapshot);\n });\n editor.ui.styleSheetLoader = getStyleSheetLoader(element, editor);\n if (!isInline(editor)) {\n editor.orgVisibility = editor.getElement().style.visibility;\n editor.getElement().style.visibility = 'hidden';\n } else {\n editor.inline = true;\n }\n const form = editor.getElement().form || DOM$3.getParent(id, 'form');\n if (form) {\n editor.formElement = form;\n if (hasHiddenInput(editor) && !isTextareaOrInput(editor.getElement())) {\n DOM$3.insertAfter(DOM$3.create('input', {\n type: 'hidden',\n name: id\n }), id);\n editor.hasHiddenInput = true;\n }\n editor.formEventDelegate = e => {\n editor.dispatch(e.type, e);\n };\n DOM$3.bind(form, 'submit reset', editor.formEventDelegate);\n editor.on('reset', () => {\n editor.resetContent();\n });\n if (shouldPatchSubmit(editor) && !form.submit.nodeType && !form.submit.length && !form._mceOldSubmit) {\n form._mceOldSubmit = form.submit;\n form.submit = () => {\n editor.editorManager.triggerSave();\n editor.setDirty(false);\n return form._mceOldSubmit(form);\n };\n }\n }\n editor.windowManager = WindowManager(editor);\n editor.notificationManager = NotificationManager(editor);\n if (isEncodingXml(editor)) {\n editor.on('GetContent', e => {\n if (e.save) {\n e.content = DOM$3.encode(e.content);\n }\n });\n }\n if (shouldAddFormSubmitTrigger(editor)) {\n editor.on('submit', () => {\n if (editor.initialized) {\n editor.save();\n }\n });\n }\n if (shouldAddUnloadTrigger(editor)) {\n editor._beforeUnload = () => {\n if (editor.initialized && !editor.destroyed && !editor.isHidden()) {\n editor.save({\n format: 'raw',\n no_events: true,\n set_dirty: false\n });\n }\n };\n editor.editorManager.on('BeforeUnload', editor._beforeUnload);\n }\n editor.editorManager.add(editor);\n loadScripts(editor, editor.suffix);\n };\n\n const sectionResult = (sections, settings) => ({\n sections: constant(sections),\n options: constant(settings)\n });\n const deviceDetection = detect$2().deviceType;\n const isPhone = deviceDetection.isPhone();\n const isTablet = deviceDetection.isTablet();\n const normalizePlugins = plugins => {\n if (isNullable(plugins)) {\n return [];\n } else {\n const pluginNames = isArray$1(plugins) ? plugins : plugins.split(/[ ,]/);\n const trimmedPlugins = map$3(pluginNames, trim$3);\n return filter$5(trimmedPlugins, isNotEmpty);\n }\n };\n const extractSections = (keys, options) => {\n const result = bifilter(options, (value, key) => {\n return contains$2(keys, key);\n });\n return sectionResult(result.t, result.f);\n };\n const getSection = (sectionResult, name, defaults = {}) => {\n const sections = sectionResult.sections();\n const sectionOptions = get$a(sections, name).getOr({});\n return Tools.extend({}, defaults, sectionOptions);\n };\n const hasSection = (sectionResult, name) => {\n return has$2(sectionResult.sections(), name);\n };\n const getSectionConfig = (sectionResult, name) => {\n return hasSection(sectionResult, name) ? sectionResult.sections()[name] : {};\n };\n const getMobileOverrideOptions = (mobileOptions, isPhone) => {\n const defaultMobileOptions = {\n table_grid: false,\n object_resizing: false,\n resize: false,\n toolbar_mode: get$a(mobileOptions, 'toolbar_mode').getOr('scrolling'),\n toolbar_sticky: false\n };\n const defaultPhoneOptions = { menubar: false };\n return {\n ...defaultMobileOptions,\n ...isPhone ? defaultPhoneOptions : {}\n };\n };\n const getExternalPlugins = (overrideOptions, options) => {\n var _a;\n const userDefinedExternalPlugins = (_a = options.external_plugins) !== null && _a !== void 0 ? _a : {};\n if (overrideOptions && overrideOptions.external_plugins) {\n return Tools.extend({}, overrideOptions.external_plugins, userDefinedExternalPlugins);\n } else {\n return userDefinedExternalPlugins;\n }\n };\n const combinePlugins = (forcedPlugins, plugins) => [\n ...normalizePlugins(forcedPlugins),\n ...normalizePlugins(plugins)\n ];\n const getPlatformPlugins = (isMobileDevice, sectionResult, desktopPlugins, mobilePlugins) => {\n if (isMobileDevice && hasSection(sectionResult, 'mobile')) {\n return mobilePlugins;\n } else {\n return desktopPlugins;\n }\n };\n const processPlugins = (isMobileDevice, sectionResult, defaultOverrideOptions, options) => {\n const forcedPlugins = normalizePlugins(defaultOverrideOptions.forced_plugins);\n const desktopPlugins = normalizePlugins(options.plugins);\n const mobileConfig = getSectionConfig(sectionResult, 'mobile');\n const mobilePlugins = mobileConfig.plugins ? normalizePlugins(mobileConfig.plugins) : desktopPlugins;\n const platformPlugins = getPlatformPlugins(isMobileDevice, sectionResult, desktopPlugins, mobilePlugins);\n const combinedPlugins = combinePlugins(forcedPlugins, platformPlugins);\n return Tools.extend(options, {\n forced_plugins: forcedPlugins,\n plugins: combinedPlugins\n });\n };\n const isOnMobile = (isMobileDevice, sectionResult) => {\n return isMobileDevice && hasSection(sectionResult, 'mobile');\n };\n const combineOptions = (isMobileDevice, isPhone, defaultOptions, defaultOverrideOptions, options) => {\n var _a;\n const deviceOverrideOptions = isMobileDevice ? { mobile: getMobileOverrideOptions((_a = options.mobile) !== null && _a !== void 0 ? _a : {}, isPhone) } : {};\n const sectionResult = extractSections(['mobile'], deepMerge(deviceOverrideOptions, options));\n const extendedOptions = Tools.extend(defaultOptions, defaultOverrideOptions, sectionResult.options(), isOnMobile(isMobileDevice, sectionResult) ? getSection(sectionResult, 'mobile') : {}, { external_plugins: getExternalPlugins(defaultOverrideOptions, sectionResult.options()) });\n return processPlugins(isMobileDevice, sectionResult, defaultOverrideOptions, extendedOptions);\n };\n const normalizeOptions = (defaultOverrideOptions, options) => combineOptions(isPhone || isTablet, isPhone, options, defaultOverrideOptions, options);\n\n const addVisual = (editor, elm) => addVisual$1(editor, elm);\n\n const registerExecCommands$3 = editor => {\n const toggleFormat = (name, value) => {\n editor.formatter.toggle(name, value);\n editor.nodeChanged();\n };\n const toggleAlign = align => () => {\n each$e('left,center,right,justify'.split(','), name => {\n if (align !== name) {\n editor.formatter.remove('align' + name);\n }\n });\n if (align !== 'none') {\n toggleFormat('align' + align);\n }\n };\n editor.editorCommands.addCommands({\n JustifyLeft: toggleAlign('left'),\n JustifyCenter: toggleAlign('center'),\n JustifyRight: toggleAlign('right'),\n JustifyFull: toggleAlign('justify'),\n JustifyNone: toggleAlign('none')\n });\n };\n const registerQueryStateCommands$1 = editor => {\n const alignStates = name => () => {\n const selection = editor.selection;\n const nodes = selection.isCollapsed() ? [editor.dom.getParent(selection.getNode(), editor.dom.isBlock)] : selection.getSelectedBlocks();\n return exists(nodes, node => isNonNullable(editor.formatter.matchNode(node, name)));\n };\n editor.editorCommands.addCommands({\n JustifyLeft: alignStates('alignleft'),\n JustifyCenter: alignStates('aligncenter'),\n JustifyRight: alignStates('alignright'),\n JustifyFull: alignStates('alignjustify')\n }, 'state');\n };\n const registerCommands$a = editor => {\n registerExecCommands$3(editor);\n registerQueryStateCommands$1(editor);\n };\n\n const registerCommands$9 = editor => {\n editor.editorCommands.addCommands({\n 'Cut,Copy,Paste': command => {\n const doc = editor.getDoc();\n let failed;\n try {\n doc.execCommand(command);\n } catch (ex) {\n failed = true;\n }\n if (command === 'paste' && !doc.queryCommandEnabled(command)) {\n failed = true;\n }\n if (failed || !doc.queryCommandSupported(command)) {\n let msg = editor.translate(`Your browser doesn't support direct access to the clipboard. ` + 'Please use the Ctrl+X/C/V keyboard shortcuts instead.');\n if (Env.os.isMacOS() || Env.os.isiOS()) {\n msg = msg.replace(/Ctrl\\+/g, '\\u2318+');\n }\n editor.notificationManager.open({\n text: msg,\n type: 'error'\n });\n }\n }\n });\n };\n\n const trimOrPadLeftRight = (dom, rng, html) => {\n const root = SugarElement.fromDom(dom.getRoot());\n if (needsToBeNbspLeft(root, CaretPosition.fromRangeStart(rng))) {\n html = html.replace(/^ /, ' ');\n } else {\n html = html.replace(/^ /, ' ');\n }\n if (needsToBeNbspRight(root, CaretPosition.fromRangeEnd(rng))) {\n html = html.replace(/( | )(
');\n },\n insertText: (_command, _ui, value) => {\n insertAtCaret(editor, editor.dom.encode(value));\n },\n insertHTML: (_command, _ui, value) => {\n insertAtCaret(editor, value);\n },\n mceInsertContent: (_command, _ui, value) => {\n insertAtCaret(editor, value);\n },\n mceSetContent: (_command, _ui, value) => {\n editor.setContent(value);\n },\n mceReplaceContent: (_command, _ui, value) => {\n editor.execCommand('mceInsertContent', false, value.replace(/\\{\\$selection\\}/g, editor.selection.getContent({ format: 'text' })));\n },\n mceNewDocument: () => {\n editor.setContent('');\n }\n });\n };\n\n const legacyPropNames = {\n 'font-size': 'size',\n 'font-family': 'face'\n };\n const isFont = isTag('font');\n const getSpecifiedFontProp = (propName, rootElm, elm) => {\n const getProperty = elm => getRaw$1(elm, propName).orThunk(() => {\n if (isFont(elm)) {\n return get$a(legacyPropNames, propName).bind(legacyPropName => getOpt(elm, legacyPropName));\n } else {\n return Optional.none();\n }\n });\n const isRoot = elm => eq(SugarElement.fromDom(rootElm), elm);\n return closest$2(SugarElement.fromDom(elm), elm => getProperty(elm), isRoot);\n };\n const normalizeFontFamily = fontFamily => fontFamily.replace(/[\\'\\\"\\\\]/g, '').replace(/,\\s+/g, ',');\n const getComputedFontProp = (propName, elm) => Optional.from(DOMUtils.DOM.getStyle(elm, propName, true));\n const getFontProp = propName => (rootElm, elm) => Optional.from(elm).map(SugarElement.fromDom).filter(isElement$7).bind(element => getSpecifiedFontProp(propName, rootElm, element.dom).or(getComputedFontProp(propName, element.dom))).getOr('');\n const getFontSize = getFontProp('font-size');\n const getFontFamily = compose(normalizeFontFamily, getFontProp('font-family'));\n\n const findFirstCaretElement = editor => firstPositionIn(editor.getBody()).bind(caret => {\n const container = caret.container();\n return Optional.from(isText$a(container) ? container.parentNode : container);\n });\n const getCaretElement = editor => Optional.from(editor.selection.getRng()).bind(rng => {\n const root = editor.getBody();\n const atStartOfNode = rng.startContainer === root && rng.startOffset === 0;\n return atStartOfNode ? Optional.none() : Optional.from(editor.selection.getStart(true));\n });\n const bindRange = (editor, binder) => getCaretElement(editor).orThunk(curry(findFirstCaretElement, editor)).map(SugarElement.fromDom).filter(isElement$7).bind(binder);\n const mapRange = (editor, mapper) => bindRange(editor, compose1(Optional.some, mapper));\n\n const fromFontSizeNumber = (editor, value) => {\n if (/^[0-9.]+$/.test(value)) {\n const fontSizeNumber = parseInt(value, 10);\n if (fontSizeNumber >= 1 && fontSizeNumber <= 7) {\n const fontSizes = getFontStyleValues(editor);\n const fontClasses = getFontSizeClasses(editor);\n if (fontClasses.length > 0) {\n return fontClasses[fontSizeNumber - 1] || value;\n } else {\n return fontSizes[fontSizeNumber - 1] || value;\n }\n } else {\n return value;\n }\n } else {\n return value;\n }\n };\n const normalizeFontNames = font => {\n const fonts = font.split(/\\s*,\\s*/);\n return map$3(fonts, font => {\n if (font.indexOf(' ') !== -1 && !(startsWith(font, '\"') || startsWith(font, `'`))) {\n return `'${ font }'`;\n } else {\n return font;\n }\n }).join(',');\n };\n const fontNameAction = (editor, value) => {\n const font = fromFontSizeNumber(editor, value);\n editor.formatter.toggle('fontname', { value: normalizeFontNames(font) });\n editor.nodeChanged();\n };\n const fontNameQuery = editor => mapRange(editor, elm => getFontFamily(editor.getBody(), elm.dom)).getOr('');\n const fontSizeAction = (editor, value) => {\n editor.formatter.toggle('fontsize', { value: fromFontSizeNumber(editor, value) });\n editor.nodeChanged();\n };\n const fontSizeQuery = editor => mapRange(editor, elm => getFontSize(editor.getBody(), elm.dom)).getOr('');\n\n const lineHeightQuery = editor => mapRange(editor, elm => {\n const root = SugarElement.fromDom(editor.getBody());\n const specifiedStyle = closest$2(elm, elm => getRaw$1(elm, 'line-height'), curry(eq, root));\n const computedStyle = () => {\n const lineHeight = parseFloat(get$7(elm, 'line-height'));\n const fontSize = parseFloat(get$7(elm, 'font-size'));\n return String(lineHeight / fontSize);\n };\n return specifiedStyle.getOrThunk(computedStyle);\n }).getOr('');\n const lineHeightAction = (editor, lineHeight) => {\n editor.formatter.toggle('lineheight', { value: String(lineHeight) });\n editor.nodeChanged();\n };\n\n const registerExecCommands$2 = editor => {\n const toggleFormat = (name, value) => {\n editor.formatter.toggle(name, value);\n editor.nodeChanged();\n };\n editor.editorCommands.addCommands({\n 'Bold,Italic,Underline,Strikethrough,Superscript,Subscript': command => {\n toggleFormat(command);\n },\n 'ForeColor,HiliteColor': (command, _ui, value) => {\n toggleFormat(command, { value });\n },\n 'BackColor': (_command, _ui, value) => {\n toggleFormat('hilitecolor', { value });\n },\n 'FontName': (_command, _ui, value) => {\n fontNameAction(editor, value);\n },\n 'FontSize': (_command, _ui, value) => {\n fontSizeAction(editor, value);\n },\n 'LineHeight': (_command, _ui, value) => {\n lineHeightAction(editor, value);\n },\n 'Lang': (command, _ui, lang) => {\n var _a;\n toggleFormat(command, {\n value: lang.code,\n customValue: (_a = lang.customCode) !== null && _a !== void 0 ? _a : null\n });\n },\n 'RemoveFormat': command => {\n editor.formatter.remove(command);\n },\n 'mceBlockQuote': () => {\n toggleFormat('blockquote');\n },\n 'FormatBlock': (_command, _ui, value) => {\n toggleFormat(isString(value) ? value : 'p');\n },\n 'mceToggleFormat': (_command, _ui, value) => {\n toggleFormat(value);\n }\n });\n };\n const registerQueryValueCommands = editor => {\n const isFormatMatch = name => editor.formatter.match(name);\n editor.editorCommands.addCommands({\n 'Bold,Italic,Underline,Strikethrough,Superscript,Subscript': command => isFormatMatch(command),\n 'mceBlockQuote': () => isFormatMatch('blockquote')\n }, 'state');\n editor.editorCommands.addQueryValueHandler('FontName', () => fontNameQuery(editor));\n editor.editorCommands.addQueryValueHandler('FontSize', () => fontSizeQuery(editor));\n editor.editorCommands.addQueryValueHandler('LineHeight', () => lineHeightQuery(editor));\n };\n const registerCommands$7 = editor => {\n registerExecCommands$2(editor);\n registerQueryValueCommands(editor);\n };\n\n const registerCommands$6 = editor => {\n editor.editorCommands.addCommands({\n mceAddUndoLevel: () => {\n editor.undoManager.add();\n },\n mceEndUndoLevel: () => {\n editor.undoManager.add();\n },\n Undo: () => {\n editor.undoManager.undo();\n },\n Redo: () => {\n editor.undoManager.redo();\n }\n });\n };\n\n const registerCommands$5 = editor => {\n editor.editorCommands.addCommands({\n Indent: () => {\n indent(editor);\n },\n Outdent: () => {\n outdent(editor);\n }\n });\n editor.editorCommands.addCommands({ Outdent: () => canOutdent(editor) }, 'state');\n };\n\n const registerCommands$4 = editor => {\n const applyLinkToSelection = (_command, _ui, value) => {\n const linkDetails = isString(value) ? { href: value } : value;\n const anchor = editor.dom.getParent(editor.selection.getNode(), 'a');\n if (isObject(linkDetails) && isString(linkDetails.href)) {\n linkDetails.href = linkDetails.href.replace(/ /g, '%20');\n if (!anchor || !linkDetails.href) {\n editor.formatter.remove('link');\n }\n if (linkDetails.href) {\n editor.formatter.apply('link', linkDetails, anchor);\n }\n }\n };\n editor.editorCommands.addCommands({\n unlink: () => {\n if (editor.selection.isCollapsed()) {\n const elm = editor.dom.getParent(editor.selection.getStart(), 'a');\n if (elm) {\n editor.dom.remove(elm, true);\n }\n return;\n }\n editor.formatter.remove('link');\n },\n mceInsertLink: applyLinkToSelection,\n createLink: applyLinkToSelection\n });\n };\n\n const registerExecCommands$1 = editor => {\n editor.editorCommands.addCommands({\n 'InsertUnorderedList,InsertOrderedList': command => {\n editor.getDoc().execCommand(command);\n const listElm = editor.dom.getParent(editor.selection.getNode(), 'ol,ul');\n if (listElm) {\n const listParent = listElm.parentNode;\n if (listParent && /^(H[1-6]|P|ADDRESS|PRE)$/.test(listParent.nodeName)) {\n const bm = editor.selection.getBookmark();\n editor.dom.split(listParent, listElm);\n editor.selection.moveToBookmark(bm);\n }\n }\n }\n });\n };\n const registerQueryStateCommands = editor => {\n editor.editorCommands.addCommands({\n 'InsertUnorderedList,InsertOrderedList': command => {\n const list = editor.dom.getParent(editor.selection.getNode(), 'ul,ol');\n return list && (command === 'insertunorderedlist' && list.tagName === 'UL' || command === 'insertorderedlist' && list.tagName === 'OL');\n }\n }, 'state');\n };\n const registerCommands$3 = editor => {\n registerExecCommands$1(editor);\n registerQueryStateCommands(editor);\n };\n\n const registerCommands$2 = editor => {\n editor.editorCommands.addCommands({\n insertParagraph: () => {\n insertBreak(blockbreak, editor);\n },\n mceInsertNewLine: (_command, _ui, value) => {\n insert(editor, value);\n },\n InsertLineBreak: (_command, _ui, _value) => {\n insertBreak(linebreak, editor);\n }\n });\n };\n\n const registerCommands$1 = editor => {\n editor.editorCommands.addCommands({\n mceSelectNodeDepth: (_command, _ui, value) => {\n let counter = 0;\n editor.dom.getParent(editor.selection.getNode(), node => {\n if (isElement$6(node) && counter++ === value) {\n editor.selection.select(node);\n return false;\n } else {\n return true;\n }\n }, editor.getBody());\n },\n mceSelectNode: (_command, _ui, value) => {\n editor.selection.select(value);\n },\n selectAll: () => {\n const editingHost = editor.dom.getParent(editor.selection.getStart(), isContentEditableTrue$3);\n if (editingHost) {\n const rng = editor.dom.createRng();\n rng.selectNodeContents(editingHost);\n editor.selection.setRng(rng);\n }\n }\n });\n };\n\n const registerExecCommands = editor => {\n editor.editorCommands.addCommands({\n mceRemoveNode: (_command, _ui, value) => {\n const node = value !== null && value !== void 0 ? value : editor.selection.getNode();\n if (node !== editor.getBody()) {\n const bm = editor.selection.getBookmark();\n editor.dom.remove(node, true);\n editor.selection.moveToBookmark(bm);\n }\n },\n mcePrint: () => {\n editor.getWin().print();\n },\n mceFocus: (_command, _ui, value) => {\n focus(editor, value === true);\n },\n mceToggleVisualAid: () => {\n editor.hasVisual = !editor.hasVisual;\n editor.addVisual();\n }\n });\n };\n const registerCommands = editor => {\n registerCommands$a(editor);\n registerCommands$9(editor);\n registerCommands$6(editor);\n registerCommands$1(editor);\n registerCommands$8(editor);\n registerCommands$4(editor);\n registerCommands$5(editor);\n registerCommands$2(editor);\n registerCommands$3(editor);\n registerCommands$7(editor);\n registerExecCommands(editor);\n };\n\n const selectionSafeCommands = ['toggleview'];\n const isSelectionSafeCommand = command => contains$2(selectionSafeCommands, command.toLowerCase());\n class EditorCommands {\n constructor(editor) {\n this.commands = {\n state: {},\n exec: {},\n value: {}\n };\n this.editor = editor;\n }\n execCommand(command, ui = false, value, args) {\n const editor = this.editor;\n const lowerCaseCommand = command.toLowerCase();\n const skipFocus = args === null || args === void 0 ? void 0 : args.skip_focus;\n if (editor.removed) {\n return false;\n }\n if (lowerCaseCommand !== 'mcefocus') {\n if (!/^(mceAddUndoLevel|mceEndUndoLevel)$/i.test(lowerCaseCommand) && !skipFocus) {\n editor.focus();\n } else {\n restore(editor);\n }\n }\n const eventArgs = editor.dispatch('BeforeExecCommand', {\n command,\n ui,\n value\n });\n if (eventArgs.isDefaultPrevented()) {\n return false;\n }\n const func = this.commands.exec[lowerCaseCommand];\n if (isFunction(func)) {\n func(lowerCaseCommand, ui, value);\n editor.dispatch('ExecCommand', {\n command,\n ui,\n value\n });\n return true;\n }\n return false;\n }\n queryCommandState(command) {\n if (!isSelectionSafeCommand(command) && this.editor.quirks.isHidden() || this.editor.removed) {\n return false;\n }\n const lowerCaseCommand = command.toLowerCase();\n const func = this.commands.state[lowerCaseCommand];\n if (isFunction(func)) {\n return func(lowerCaseCommand);\n }\n return false;\n }\n queryCommandValue(command) {\n if (!isSelectionSafeCommand(command) && this.editor.quirks.isHidden() || this.editor.removed) {\n return '';\n }\n const lowerCaseCommand = command.toLowerCase();\n const func = this.commands.value[lowerCaseCommand];\n if (isFunction(func)) {\n return func(lowerCaseCommand);\n }\n return '';\n }\n addCommands(commandList, type = 'exec') {\n const commands = this.commands;\n each$d(commandList, (callback, command) => {\n each$e(command.toLowerCase().split(','), command => {\n commands[type][command] = callback;\n });\n });\n }\n addCommand(command, callback, scope) {\n const lowerCaseCommand = command.toLowerCase();\n this.commands.exec[lowerCaseCommand] = (_command, ui, value) => callback.call(scope !== null && scope !== void 0 ? scope : this.editor, ui, value);\n }\n queryCommandSupported(command) {\n const lowerCaseCommand = command.toLowerCase();\n if (this.commands.exec[lowerCaseCommand]) {\n return true;\n } else {\n return false;\n }\n }\n addQueryStateHandler(command, callback, scope) {\n this.commands.state[command.toLowerCase()] = () => callback.call(scope !== null && scope !== void 0 ? scope : this.editor);\n }\n addQueryValueHandler(command, callback, scope) {\n this.commands.value[command.toLowerCase()] = () => callback.call(scope !== null && scope !== void 0 ? scope : this.editor);\n }\n }\n\n const internalContentEditableAttr = 'data-mce-contenteditable';\n const toggleClass = (elm, cls, state) => {\n if (has(elm, cls) && !state) {\n remove$8(elm, cls);\n } else if (state) {\n add$2(elm, cls);\n }\n };\n const setEditorCommandState = (editor, cmd, state) => {\n try {\n editor.getDoc().execCommand(cmd, false, String(state));\n } catch (ex) {\n }\n };\n const setContentEditable = (elm, state) => {\n elm.dom.contentEditable = state ? 'true' : 'false';\n };\n const switchOffContentEditableTrue = elm => {\n each$e(descendants(elm, '*[contenteditable=\"true\"]'), elm => {\n set$2(elm, internalContentEditableAttr, 'true');\n setContentEditable(elm, false);\n });\n };\n const switchOnContentEditableTrue = elm => {\n each$e(descendants(elm, `*[${ internalContentEditableAttr }=\"true\"]`), elm => {\n remove$b(elm, internalContentEditableAttr);\n setContentEditable(elm, true);\n });\n };\n const removeFakeSelection = editor => {\n Optional.from(editor.selection.getNode()).each(elm => {\n elm.removeAttribute('data-mce-selected');\n });\n };\n const restoreFakeSelection = editor => {\n editor.selection.setRng(editor.selection.getRng());\n };\n const toggleReadOnly = (editor, state) => {\n const body = SugarElement.fromDom(editor.getBody());\n toggleClass(body, 'mce-content-readonly', state);\n if (state) {\n editor.selection.controlSelection.hideResizeRect();\n editor._selectionOverrides.hideFakeCaret();\n removeFakeSelection(editor);\n editor.readonly = true;\n setContentEditable(body, false);\n switchOffContentEditableTrue(body);\n } else {\n editor.readonly = false;\n setContentEditable(body, true);\n switchOnContentEditableTrue(body);\n setEditorCommandState(editor, 'StyleWithCSS', false);\n setEditorCommandState(editor, 'enableInlineTableEditing', false);\n setEditorCommandState(editor, 'enableObjectResizing', false);\n if (hasEditorOrUiFocus(editor)) {\n editor.focus();\n }\n restoreFakeSelection(editor);\n editor.nodeChanged();\n }\n };\n const isReadOnly = editor => editor.readonly;\n const registerFilters = editor => {\n editor.parser.addAttributeFilter('contenteditable', nodes => {\n if (isReadOnly(editor)) {\n each$e(nodes, node => {\n node.attr(internalContentEditableAttr, node.attr('contenteditable'));\n node.attr('contenteditable', 'false');\n });\n }\n });\n editor.serializer.addAttributeFilter(internalContentEditableAttr, nodes => {\n if (isReadOnly(editor)) {\n each$e(nodes, node => {\n node.attr('contenteditable', node.attr(internalContentEditableAttr));\n });\n }\n });\n editor.serializer.addTempAttr(internalContentEditableAttr);\n };\n const registerReadOnlyContentFilters = editor => {\n if (editor.serializer) {\n registerFilters(editor);\n } else {\n editor.on('PreInit', () => {\n registerFilters(editor);\n });\n }\n };\n const isClickEvent = e => e.type === 'click';\n const allowedEvents = ['copy'];\n const isReadOnlyAllowedEvent = e => contains$2(allowedEvents, e.type);\n const getAnchorHrefOpt = (editor, elm) => {\n const isRoot = elm => eq(elm, SugarElement.fromDom(editor.getBody()));\n return closest$3(elm, 'a', isRoot).bind(a => getOpt(a, 'href'));\n };\n const processReadonlyEvents = (editor, e) => {\n if (isClickEvent(e) && !VK.metaKeyPressed(e)) {\n const elm = SugarElement.fromDom(e.target);\n getAnchorHrefOpt(editor, elm).each(href => {\n e.preventDefault();\n if (/^#/.test(href)) {\n const targetEl = editor.dom.select(`${ href },[name=\"${ removeLeading(href, '#') }\"]`);\n if (targetEl.length) {\n editor.selection.scrollIntoView(targetEl[0], true);\n }\n } else {\n window.open(href, '_blank', 'rel=noopener noreferrer,menubar=yes,toolbar=yes,location=yes,status=yes,resizable=yes,scrollbars=yes');\n }\n });\n } else if (isReadOnlyAllowedEvent(e)) {\n editor.dispatch(e.type, e);\n }\n };\n const registerReadOnlySelectionBlockers = editor => {\n editor.on('ShowCaret', e => {\n if (isReadOnly(editor)) {\n e.preventDefault();\n }\n });\n editor.on('ObjectSelected', e => {\n if (isReadOnly(editor)) {\n e.preventDefault();\n }\n });\n };\n\n const nativeEvents = Tools.makeMap('focus blur focusin focusout click dblclick mousedown mouseup mousemove mouseover beforepaste paste cut copy selectionchange ' + 'mouseout mouseenter mouseleave wheel keydown keypress keyup input beforeinput contextmenu dragstart dragend dragover ' + 'draggesture dragdrop drop drag submit ' + 'compositionstart compositionend compositionupdate touchstart touchmove touchend touchcancel', ' ');\n class EventDispatcher {\n constructor(settings) {\n this.bindings = {};\n this.settings = settings || {};\n this.scope = this.settings.scope || this;\n this.toggleEvent = this.settings.toggleEvent || never;\n }\n static isNative(name) {\n return !!nativeEvents[name.toLowerCase()];\n }\n fire(name, args) {\n return this.dispatch(name, args);\n }\n dispatch(name, args) {\n const lcName = name.toLowerCase();\n const event = normalize$3(lcName, args !== null && args !== void 0 ? args : {}, this.scope);\n if (this.settings.beforeFire) {\n this.settings.beforeFire(event);\n }\n const handlers = this.bindings[lcName];\n if (handlers) {\n for (let i = 0, l = handlers.length; i < l; i++) {\n const callback = handlers[i];\n if (callback.removed) {\n continue;\n }\n if (callback.once) {\n this.off(lcName, callback.func);\n }\n if (event.isImmediatePropagationStopped()) {\n return event;\n }\n if (callback.func.call(this.scope, event) === false) {\n event.preventDefault();\n return event;\n }\n }\n }\n return event;\n }\n on(name, callback, prepend, extra) {\n if (callback === false) {\n callback = never;\n }\n if (callback) {\n const wrappedCallback = {\n func: callback,\n removed: false\n };\n if (extra) {\n Tools.extend(wrappedCallback, extra);\n }\n const names = name.toLowerCase().split(' ');\n let i = names.length;\n while (i--) {\n const currentName = names[i];\n let handlers = this.bindings[currentName];\n if (!handlers) {\n handlers = [];\n this.toggleEvent(currentName, true);\n }\n if (prepend) {\n handlers = [\n wrappedCallback,\n ...handlers\n ];\n } else {\n handlers = [\n ...handlers,\n wrappedCallback\n ];\n }\n this.bindings[currentName] = handlers;\n }\n }\n return this;\n }\n off(name, callback) {\n if (name) {\n const names = name.toLowerCase().split(' ');\n let i = names.length;\n while (i--) {\n const currentName = names[i];\n let handlers = this.bindings[currentName];\n if (!currentName) {\n each$d(this.bindings, (_value, bindingName) => {\n this.toggleEvent(bindingName, false);\n delete this.bindings[bindingName];\n });\n return this;\n }\n if (handlers) {\n if (!callback) {\n handlers.length = 0;\n } else {\n const filteredHandlers = partition$2(handlers, handler => handler.func === callback);\n handlers = filteredHandlers.fail;\n this.bindings[currentName] = handlers;\n each$e(filteredHandlers.pass, handler => {\n handler.removed = true;\n });\n }\n if (!handlers.length) {\n this.toggleEvent(name, false);\n delete this.bindings[currentName];\n }\n }\n }\n } else {\n each$d(this.bindings, (_value, name) => {\n this.toggleEvent(name, false);\n });\n this.bindings = {};\n }\n return this;\n }\n once(name, callback, prepend) {\n return this.on(name, callback, prepend, { once: true });\n }\n has(name) {\n name = name.toLowerCase();\n const binding = this.bindings[name];\n return !(!binding || binding.length === 0);\n }\n }\n\n const getEventDispatcher = obj => {\n if (!obj._eventDispatcher) {\n obj._eventDispatcher = new EventDispatcher({\n scope: obj,\n toggleEvent: (name, state) => {\n if (EventDispatcher.isNative(name) && obj.toggleNativeEvent) {\n obj.toggleNativeEvent(name, state);\n }\n }\n });\n }\n return obj._eventDispatcher;\n };\n const Observable = {\n fire(name, args, bubble) {\n return this.dispatch(name, args, bubble);\n },\n dispatch(name, args, bubble) {\n const self = this;\n if (self.removed && name !== 'remove' && name !== 'detach') {\n return normalize$3(name.toLowerCase(), args !== null && args !== void 0 ? args : {}, self);\n }\n const dispatcherArgs = getEventDispatcher(self).dispatch(name, args);\n if (bubble !== false && self.parent) {\n let parent = self.parent();\n while (parent && !dispatcherArgs.isPropagationStopped()) {\n parent.dispatch(name, dispatcherArgs, false);\n parent = parent.parent ? parent.parent() : undefined;\n }\n }\n return dispatcherArgs;\n },\n on(name, callback, prepend) {\n return getEventDispatcher(this).on(name, callback, prepend);\n },\n off(name, callback) {\n return getEventDispatcher(this).off(name, callback);\n },\n once(name, callback) {\n return getEventDispatcher(this).once(name, callback);\n },\n hasEventListeners(name) {\n return getEventDispatcher(this).has(name);\n }\n };\n\n const DOM$2 = DOMUtils.DOM;\n let customEventRootDelegates;\n const getEventTarget = (editor, eventName) => {\n if (eventName === 'selectionchange') {\n return editor.getDoc();\n }\n if (!editor.inline && /^mouse|touch|click|contextmenu|drop|dragover|dragend/.test(eventName)) {\n return editor.getDoc().documentElement;\n }\n const eventRoot = getEventRoot(editor);\n if (eventRoot) {\n if (!editor.eventRoot) {\n editor.eventRoot = DOM$2.select(eventRoot)[0];\n }\n return editor.eventRoot;\n }\n return editor.getBody();\n };\n const isListening = editor => !editor.hidden && !isReadOnly(editor);\n const fireEvent = (editor, eventName, e) => {\n if (isListening(editor)) {\n editor.dispatch(eventName, e);\n } else if (isReadOnly(editor)) {\n processReadonlyEvents(editor, e);\n }\n };\n const bindEventDelegate = (editor, eventName) => {\n if (!editor.delegates) {\n editor.delegates = {};\n }\n if (editor.delegates[eventName] || editor.removed) {\n return;\n }\n const eventRootElm = getEventTarget(editor, eventName);\n if (getEventRoot(editor)) {\n if (!customEventRootDelegates) {\n customEventRootDelegates = {};\n editor.editorManager.on('removeEditor', () => {\n if (!editor.editorManager.activeEditor) {\n if (customEventRootDelegates) {\n each$d(customEventRootDelegates, (_value, name) => {\n editor.dom.unbind(getEventTarget(editor, name));\n });\n customEventRootDelegates = null;\n }\n }\n });\n }\n if (customEventRootDelegates[eventName]) {\n return;\n }\n const delegate = e => {\n const target = e.target;\n const editors = editor.editorManager.get();\n let i = editors.length;\n while (i--) {\n const body = editors[i].getBody();\n if (body === target || DOM$2.isChildOf(target, body)) {\n fireEvent(editors[i], eventName, e);\n }\n }\n };\n customEventRootDelegates[eventName] = delegate;\n DOM$2.bind(eventRootElm, eventName, delegate);\n } else {\n const delegate = e => {\n fireEvent(editor, eventName, e);\n };\n DOM$2.bind(eventRootElm, eventName, delegate);\n editor.delegates[eventName] = delegate;\n }\n };\n const EditorObservable = {\n ...Observable,\n bindPendingEventDelegates() {\n const self = this;\n Tools.each(self._pendingNativeEvents, name => {\n bindEventDelegate(self, name);\n });\n },\n toggleNativeEvent(name, state) {\n const self = this;\n if (name === 'focus' || name === 'blur') {\n return;\n }\n if (self.removed) {\n return;\n }\n if (state) {\n if (self.initialized) {\n bindEventDelegate(self, name);\n } else {\n if (!self._pendingNativeEvents) {\n self._pendingNativeEvents = [name];\n } else {\n self._pendingNativeEvents.push(name);\n }\n }\n } else if (self.initialized && self.delegates) {\n self.dom.unbind(getEventTarget(self, name), name, self.delegates[name]);\n delete self.delegates[name];\n }\n },\n unbindAllNativeEvents() {\n const self = this;\n const body = self.getBody();\n const dom = self.dom;\n if (self.delegates) {\n each$d(self.delegates, (value, name) => {\n self.dom.unbind(getEventTarget(self, name), name, value);\n });\n delete self.delegates;\n }\n if (!self.inline && body && dom) {\n body.onload = null;\n dom.unbind(self.getWin());\n dom.unbind(self.getDoc());\n }\n if (dom) {\n dom.unbind(body);\n dom.unbind(self.getContainer());\n }\n }\n };\n\n const stringListProcessor = value => {\n if (isString(value)) {\n return {\n value: value.split(/[ ,]/),\n valid: true\n };\n } else if (isArrayOf(value, isString)) {\n return {\n value,\n valid: true\n };\n } else {\n return {\n valid: false,\n message: `The value must be a string[] or a comma/space separated string.`\n };\n }\n };\n const getBuiltInProcessor = type => {\n const validator = (() => {\n switch (type) {\n case 'array':\n return isArray$1;\n case 'boolean':\n return isBoolean;\n case 'function':\n return isFunction;\n case 'number':\n return isNumber;\n case 'object':\n return isObject;\n case 'string':\n return isString;\n case 'string[]':\n return stringListProcessor;\n case 'object[]':\n return val => isArrayOf(val, isObject);\n case 'regexp':\n return val => is$4(val, RegExp);\n default:\n return always;\n }\n })();\n return value => processValue(value, validator, `The value must be a ${ type }.`);\n };\n const isBuiltInSpec = spec => isString(spec.processor);\n const getErrorMessage = (message, result) => {\n const additionalText = isEmpty$3(result.message) ? '' : `. ${ result.message }`;\n return message + additionalText;\n };\n const isValidResult = result => result.valid;\n const processValue = (value, processor, message = '') => {\n const result = processor(value);\n if (isBoolean(result)) {\n return result ? {\n value: value,\n valid: true\n } : {\n valid: false,\n message\n };\n } else {\n return result;\n }\n };\n const processDefaultValue = (name, defaultValue, processor) => {\n if (!isUndefined(defaultValue)) {\n const result = processValue(defaultValue, processor);\n if (isValidResult(result)) {\n return result.value;\n } else {\n console.error(getErrorMessage(`Invalid default value passed for the \"${ name }\" option`, result));\n }\n }\n return undefined;\n };\n const create$5 = (editor, initialOptions) => {\n const registry = {};\n const values = {};\n const setValue = (name, value, processor) => {\n const result = processValue(value, processor);\n if (isValidResult(result)) {\n values[name] = result.value;\n return true;\n } else {\n console.warn(getErrorMessage(`Invalid value passed for the ${ name } option`, result));\n return false;\n }\n };\n const register = (name, spec) => {\n const processor = isBuiltInSpec(spec) ? getBuiltInProcessor(spec.processor) : spec.processor;\n const defaultValue = processDefaultValue(name, spec.default, processor);\n registry[name] = {\n ...spec,\n default: defaultValue,\n processor\n };\n const initValue = get$a(values, name).orThunk(() => get$a(initialOptions, name));\n initValue.each(value => setValue(name, value, processor));\n };\n const isRegistered = name => has$2(registry, name);\n const get = name => get$a(values, name).orThunk(() => get$a(registry, name).map(spec => spec.default)).getOrUndefined();\n const set = (name, value) => {\n if (!isRegistered(name)) {\n console.warn(`\"${ name }\" is not a registered option. Ensure the option has been registered before setting a value.`);\n return false;\n } else {\n const spec = registry[name];\n if (spec.immutable) {\n console.error(`\"${ name }\" is an immutable option and cannot be updated`);\n return false;\n } else {\n return setValue(name, value, spec.processor);\n }\n }\n };\n const unset = name => {\n const registered = isRegistered(name);\n if (registered) {\n delete values[name];\n }\n return registered;\n };\n const isSet = name => has$2(values, name);\n return {\n register,\n isRegistered,\n get,\n set,\n unset,\n isSet\n };\n };\n\n const defaultModes = [\n 'design',\n 'readonly'\n ];\n const switchToMode = (editor, activeMode, availableModes, mode) => {\n const oldMode = availableModes[activeMode.get()];\n const newMode = availableModes[mode];\n try {\n newMode.activate();\n } catch (e) {\n console.error(`problem while activating editor mode ${ mode }:`, e);\n return;\n }\n oldMode.deactivate();\n if (oldMode.editorReadOnly !== newMode.editorReadOnly) {\n toggleReadOnly(editor, newMode.editorReadOnly);\n }\n activeMode.set(mode);\n fireSwitchMode(editor, mode);\n };\n const setMode = (editor, availableModes, activeMode, mode) => {\n if (mode === activeMode.get()) {\n return;\n } else if (!has$2(availableModes, mode)) {\n throw new Error(`Editor mode '${ mode }' is invalid`);\n }\n if (editor.initialized) {\n switchToMode(editor, activeMode, availableModes, mode);\n } else {\n editor.on('init', () => switchToMode(editor, activeMode, availableModes, mode));\n }\n };\n const registerMode = (availableModes, mode, api) => {\n if (contains$2(defaultModes, mode)) {\n throw new Error(`Cannot override default mode ${ mode }`);\n }\n return {\n ...availableModes,\n [mode]: {\n ...api,\n deactivate: () => {\n try {\n api.deactivate();\n } catch (e) {\n console.error(`problem while deactivating editor mode ${ mode }:`, e);\n }\n }\n }\n };\n };\n\n const create$4 = editor => {\n const activeMode = Cell('design');\n const availableModes = Cell({\n design: {\n activate: noop,\n deactivate: noop,\n editorReadOnly: false\n },\n readonly: {\n activate: noop,\n deactivate: noop,\n editorReadOnly: true\n }\n });\n registerReadOnlyContentFilters(editor);\n registerReadOnlySelectionBlockers(editor);\n return {\n isReadOnly: () => isReadOnly(editor),\n set: mode => setMode(editor, availableModes.get(), activeMode, mode),\n get: () => activeMode.get(),\n register: (mode, api) => {\n availableModes.set(registerMode(availableModes.get(), mode, api));\n }\n };\n };\n\n const each$2 = Tools.each, explode = Tools.explode;\n const keyCodeLookup = {\n f1: 112,\n f2: 113,\n f3: 114,\n f4: 115,\n f5: 116,\n f6: 117,\n f7: 118,\n f8: 119,\n f9: 120,\n f10: 121,\n f11: 122,\n f12: 123\n };\n const modifierNames = Tools.makeMap('alt,ctrl,shift,meta,access');\n const isModifier = key => key in modifierNames;\n const parseShortcut = pattern => {\n const shortcut = {};\n const isMac = Env.os.isMacOS() || Env.os.isiOS();\n each$2(explode(pattern.toLowerCase(), '+'), value => {\n if (isModifier(value)) {\n shortcut[value] = true;\n } else {\n if (/^[0-9]{2,}$/.test(value)) {\n shortcut.keyCode = parseInt(value, 10);\n } else {\n shortcut.charCode = value.charCodeAt(0);\n shortcut.keyCode = keyCodeLookup[value] || value.toUpperCase().charCodeAt(0);\n }\n }\n });\n const id = [shortcut.keyCode];\n let key;\n for (key in modifierNames) {\n if (shortcut[key]) {\n id.push(key);\n } else {\n shortcut[key] = false;\n }\n }\n shortcut.id = id.join(',');\n if (shortcut.access) {\n shortcut.alt = true;\n if (isMac) {\n shortcut.ctrl = true;\n } else {\n shortcut.shift = true;\n }\n }\n if (shortcut.meta) {\n if (isMac) {\n shortcut.meta = true;\n } else {\n shortcut.ctrl = true;\n shortcut.meta = false;\n }\n }\n return shortcut;\n };\n class Shortcuts {\n constructor(editor) {\n this.shortcuts = {};\n this.pendingPatterns = [];\n this.editor = editor;\n const self = this;\n editor.on('keyup keypress keydown', e => {\n if ((self.hasModifier(e) || self.isFunctionKey(e)) && !e.isDefaultPrevented()) {\n each$2(self.shortcuts, shortcut => {\n if (self.matchShortcut(e, shortcut)) {\n self.pendingPatterns = shortcut.subpatterns.slice(0);\n if (e.type === 'keydown') {\n self.executeShortcutAction(shortcut);\n }\n }\n });\n if (self.matchShortcut(e, self.pendingPatterns[0])) {\n if (self.pendingPatterns.length === 1) {\n if (e.type === 'keydown') {\n self.executeShortcutAction(self.pendingPatterns[0]);\n }\n }\n self.pendingPatterns.shift();\n }\n }\n });\n }\n add(pattern, desc, cmdFunc, scope) {\n const self = this;\n const func = self.normalizeCommandFunc(cmdFunc);\n each$2(explode(Tools.trim(pattern)), pattern => {\n const shortcut = self.createShortcut(pattern, desc, func, scope);\n self.shortcuts[shortcut.id] = shortcut;\n });\n return true;\n }\n remove(pattern) {\n const shortcut = this.createShortcut(pattern);\n if (this.shortcuts[shortcut.id]) {\n delete this.shortcuts[shortcut.id];\n return true;\n }\n return false;\n }\n normalizeCommandFunc(cmdFunc) {\n const self = this;\n const cmd = cmdFunc;\n if (typeof cmd === 'string') {\n return () => {\n self.editor.execCommand(cmd, false, null);\n };\n } else if (Tools.isArray(cmd)) {\n return () => {\n self.editor.execCommand(cmd[0], cmd[1], cmd[2]);\n };\n } else {\n return cmd;\n }\n }\n createShortcut(pattern, desc, cmdFunc, scope) {\n const shortcuts = Tools.map(explode(pattern, '>'), parseShortcut);\n shortcuts[shortcuts.length - 1] = Tools.extend(shortcuts[shortcuts.length - 1], {\n func: cmdFunc,\n scope: scope || this.editor\n });\n return Tools.extend(shortcuts[0], {\n desc: this.editor.translate(desc),\n subpatterns: shortcuts.slice(1)\n });\n }\n hasModifier(e) {\n return e.altKey || e.ctrlKey || e.metaKey;\n }\n isFunctionKey(e) {\n return e.type === 'keydown' && e.keyCode >= 112 && e.keyCode <= 123;\n }\n matchShortcut(e, shortcut) {\n if (!shortcut) {\n return false;\n }\n if (shortcut.ctrl !== e.ctrlKey || shortcut.meta !== e.metaKey) {\n return false;\n }\n if (shortcut.alt !== e.altKey || shortcut.shift !== e.shiftKey) {\n return false;\n }\n if (e.keyCode === shortcut.keyCode || e.charCode && e.charCode === shortcut.charCode) {\n e.preventDefault();\n return true;\n }\n return false;\n }\n executeShortcutAction(shortcut) {\n return shortcut.func ? shortcut.func.call(shortcut.scope) : null;\n }\n }\n\n const create$3 = () => {\n const buttons = {};\n const menuItems = {};\n const popups = {};\n const icons = {};\n const contextMenus = {};\n const contextToolbars = {};\n const sidebars = {};\n const views = {};\n const add = (collection, type) => (name, spec) => {\n collection[name.toLowerCase()] = {\n ...spec,\n type\n };\n };\n const addIcon = (name, svgData) => icons[name.toLowerCase()] = svgData;\n return {\n addButton: add(buttons, 'button'),\n addGroupToolbarButton: add(buttons, 'grouptoolbarbutton'),\n addToggleButton: add(buttons, 'togglebutton'),\n addMenuButton: add(buttons, 'menubutton'),\n addSplitButton: add(buttons, 'splitbutton'),\n addMenuItem: add(menuItems, 'menuitem'),\n addNestedMenuItem: add(menuItems, 'nestedmenuitem'),\n addToggleMenuItem: add(menuItems, 'togglemenuitem'),\n addAutocompleter: add(popups, 'autocompleter'),\n addContextMenu: add(contextMenus, 'contextmenu'),\n addContextToolbar: add(contextToolbars, 'contexttoolbar'),\n addContextForm: add(contextToolbars, 'contextform'),\n addSidebar: add(sidebars, 'sidebar'),\n addView: add(views, 'views'),\n addIcon,\n getAll: () => ({\n buttons,\n menuItems,\n icons,\n popups,\n contextMenus,\n contextToolbars,\n sidebars,\n views\n })\n };\n };\n\n const registry = () => {\n const bridge = create$3();\n return {\n addAutocompleter: bridge.addAutocompleter,\n addButton: bridge.addButton,\n addContextForm: bridge.addContextForm,\n addContextMenu: bridge.addContextMenu,\n addContextToolbar: bridge.addContextToolbar,\n addIcon: bridge.addIcon,\n addMenuButton: bridge.addMenuButton,\n addMenuItem: bridge.addMenuItem,\n addNestedMenuItem: bridge.addNestedMenuItem,\n addSidebar: bridge.addSidebar,\n addSplitButton: bridge.addSplitButton,\n addToggleButton: bridge.addToggleButton,\n addGroupToolbarButton: bridge.addGroupToolbarButton,\n addToggleMenuItem: bridge.addToggleMenuItem,\n addView: bridge.addView,\n getAll: bridge.getAll\n };\n };\n\n const DOM$1 = DOMUtils.DOM;\n const extend = Tools.extend, each$1 = Tools.each;\n class Editor {\n constructor(id, options, editorManager) {\n this.plugins = {};\n this.contentCSS = [];\n this.contentStyles = [];\n this.loadedCSS = {};\n this.isNotDirty = false;\n this.composing = false;\n this.destroyed = false;\n this.hasHiddenInput = false;\n this.iframeElement = null;\n this.initialized = false;\n this.readonly = false;\n this.removed = false;\n this.startContent = '';\n this._pendingNativeEvents = [];\n this._skinLoaded = false;\n this.editorManager = editorManager;\n this.documentBaseUrl = editorManager.documentBaseURL;\n extend(this, EditorObservable);\n const self = this;\n this.id = id;\n this.hidden = false;\n const normalizedOptions = normalizeOptions(editorManager.defaultOptions, options);\n this.options = create$5(self, normalizedOptions);\n register$7(self);\n const getOption = this.options.get;\n if (getOption('deprecation_warnings')) {\n logWarnings(options, normalizedOptions);\n }\n const suffix = getOption('suffix');\n if (suffix) {\n editorManager.suffix = suffix;\n }\n this.suffix = editorManager.suffix;\n const baseUrl = getOption('base_url');\n if (baseUrl) {\n editorManager._setBaseUrl(baseUrl);\n }\n this.baseUri = editorManager.baseURI;\n const referrerPolicy = getReferrerPolicy(self);\n if (referrerPolicy) {\n ScriptLoader.ScriptLoader._setReferrerPolicy(referrerPolicy);\n DOMUtils.DOM.styleSheetLoader._setReferrerPolicy(referrerPolicy);\n }\n const contentCssCors = hasContentCssCors(self);\n if (isNonNullable(contentCssCors)) {\n DOMUtils.DOM.styleSheetLoader._setContentCssCors(contentCssCors);\n }\n AddOnManager.languageLoad = getOption('language_load');\n AddOnManager.baseURL = editorManager.baseURL;\n this.setDirty(false);\n this.documentBaseURI = new URI(getDocumentBaseUrl(self), { base_uri: this.baseUri });\n this.baseURI = this.baseUri;\n this.inline = isInline(self);\n this.hasVisual = isVisualAidsEnabled(self);\n this.shortcuts = new Shortcuts(this);\n this.editorCommands = new EditorCommands(this);\n registerCommands(this);\n const cacheSuffix = getOption('cache_suffix');\n if (cacheSuffix) {\n Env.cacheSuffix = cacheSuffix.replace(/^[\\?\\&]+/, '');\n }\n this.ui = {\n registry: registry(),\n styleSheetLoader: undefined,\n show: noop,\n hide: noop,\n setEnabled: noop,\n isEnabled: always\n };\n this.mode = create$4(self);\n editorManager.dispatch('SetupEditor', { editor: this });\n const setupCallback = getSetupCallback(self);\n if (isFunction(setupCallback)) {\n setupCallback.call(self, self);\n }\n }\n render() {\n render(this);\n }\n focus(skipFocus) {\n this.execCommand('mceFocus', false, skipFocus);\n }\n hasFocus() {\n return hasFocus(this);\n }\n translate(text) {\n return I18n.translate(text);\n }\n getParam(name, defaultVal, type) {\n const options = this.options;\n if (!options.isRegistered(name)) {\n if (isNonNullable(type)) {\n options.register(name, {\n processor: type,\n default: defaultVal\n });\n } else {\n options.register(name, {\n processor: always,\n default: defaultVal\n });\n }\n }\n return !options.isSet(name) && !isUndefined(defaultVal) ? defaultVal : options.get(name);\n }\n hasPlugin(name, loaded) {\n const hasPlugin = contains$2(getPlugins(this), name);\n if (hasPlugin) {\n return loaded ? PluginManager.get(name) !== undefined : true;\n } else {\n return false;\n }\n }\n nodeChanged(args) {\n this._nodeChangeDispatcher.nodeChanged(args);\n }\n addCommand(name, callback, scope) {\n this.editorCommands.addCommand(name, callback, scope);\n }\n addQueryStateHandler(name, callback, scope) {\n this.editorCommands.addQueryStateHandler(name, callback, scope);\n }\n addQueryValueHandler(name, callback, scope) {\n this.editorCommands.addQueryValueHandler(name, callback, scope);\n }\n addShortcut(pattern, desc, cmdFunc, scope) {\n this.shortcuts.add(pattern, desc, cmdFunc, scope);\n }\n execCommand(cmd, ui, value, args) {\n return this.editorCommands.execCommand(cmd, ui, value, args);\n }\n queryCommandState(cmd) {\n return this.editorCommands.queryCommandState(cmd);\n }\n queryCommandValue(cmd) {\n return this.editorCommands.queryCommandValue(cmd);\n }\n queryCommandSupported(cmd) {\n return this.editorCommands.queryCommandSupported(cmd);\n }\n show() {\n const self = this;\n if (self.hidden) {\n self.hidden = false;\n if (self.inline) {\n self.getBody().contentEditable = 'true';\n } else {\n DOM$1.show(self.getContainer());\n DOM$1.hide(self.id);\n }\n self.load();\n self.dispatch('show');\n }\n }\n hide() {\n const self = this;\n if (!self.hidden) {\n self.save();\n if (self.inline) {\n self.getBody().contentEditable = 'false';\n if (self === self.editorManager.focusedEditor) {\n self.editorManager.focusedEditor = null;\n }\n } else {\n DOM$1.hide(self.getContainer());\n DOM$1.setStyle(self.id, 'display', self.orgDisplay);\n }\n self.hidden = true;\n self.dispatch('hide');\n }\n }\n isHidden() {\n return this.hidden;\n }\n setProgressState(state, time) {\n this.dispatch('ProgressState', {\n state,\n time\n });\n }\n load(args = {}) {\n const self = this;\n const elm = self.getElement();\n if (self.removed) {\n return '';\n }\n if (elm) {\n const loadArgs = {\n ...args,\n load: true\n };\n const value = isTextareaOrInput(elm) ? elm.value : elm.innerHTML;\n const html = self.setContent(value, loadArgs);\n if (!loadArgs.no_events) {\n self.dispatch('LoadContent', {\n ...loadArgs,\n element: elm\n });\n }\n return html;\n } else {\n return '';\n }\n }\n save(args = {}) {\n const self = this;\n let elm = self.getElement();\n if (!elm || !self.initialized || self.removed) {\n return '';\n }\n const getArgs = {\n ...args,\n save: true,\n element: elm\n };\n let html = self.getContent(getArgs);\n const saveArgs = {\n ...getArgs,\n content: html\n };\n if (!saveArgs.no_events) {\n self.dispatch('SaveContent', saveArgs);\n }\n if (saveArgs.format === 'raw') {\n self.dispatch('RawSaveContent', saveArgs);\n }\n html = saveArgs.content;\n if (!isTextareaOrInput(elm)) {\n if (args.is_removing || !self.inline) {\n elm.innerHTML = html;\n }\n const form = DOM$1.getParent(self.id, 'form');\n if (form) {\n each$1(form.elements, elm => {\n if (elm.name === self.id) {\n elm.value = html;\n return false;\n } else {\n return true;\n }\n });\n }\n } else {\n elm.value = html;\n }\n saveArgs.element = getArgs.element = elm = null;\n if (saveArgs.set_dirty !== false) {\n self.setDirty(false);\n }\n return html;\n }\n setContent(content, args) {\n return setContent(this, content, args);\n }\n getContent(args) {\n return getContent(this, args);\n }\n insertContent(content, args) {\n if (args) {\n content = extend({ content }, args);\n }\n this.execCommand('mceInsertContent', false, content);\n }\n resetContent(initialContent) {\n if (initialContent === undefined) {\n setContent(this, this.startContent, { format: 'raw' });\n } else {\n setContent(this, initialContent);\n }\n this.undoManager.reset();\n this.setDirty(false);\n this.nodeChanged();\n }\n isDirty() {\n return !this.isNotDirty;\n }\n setDirty(state) {\n const oldState = !this.isNotDirty;\n this.isNotDirty = !state;\n if (state && state !== oldState) {\n this.dispatch('dirty');\n }\n }\n getContainer() {\n const self = this;\n if (!self.container) {\n self.container = self.editorContainer || DOM$1.get(self.id + '_parent');\n }\n return self.container;\n }\n getContentAreaContainer() {\n return this.contentAreaContainer;\n }\n getElement() {\n if (!this.targetElm) {\n this.targetElm = DOM$1.get(this.id);\n }\n return this.targetElm;\n }\n getWin() {\n const self = this;\n if (!self.contentWindow) {\n const elm = self.iframeElement;\n if (elm) {\n self.contentWindow = elm.contentWindow;\n }\n }\n return self.contentWindow;\n }\n getDoc() {\n const self = this;\n if (!self.contentDocument) {\n const win = self.getWin();\n if (win) {\n self.contentDocument = win.document;\n }\n }\n return self.contentDocument;\n }\n getBody() {\n var _a, _b;\n const doc = this.getDoc();\n return (_b = (_a = this.bodyElement) !== null && _a !== void 0 ? _a : doc === null || doc === void 0 ? void 0 : doc.body) !== null && _b !== void 0 ? _b : null;\n }\n convertURL(url, name, elm) {\n const self = this, getOption = self.options.get;\n const urlConverterCallback = getUrlConverterCallback(self);\n if (isFunction(urlConverterCallback)) {\n return urlConverterCallback.call(self, url, elm, true, name);\n }\n if (!getOption('convert_urls') || elm === 'link' || isObject(elm) && elm.nodeName === 'LINK' || url.indexOf('file:') === 0 || url.length === 0) {\n return url;\n }\n if (getOption('relative_urls')) {\n return self.documentBaseURI.toRelative(url);\n }\n url = self.documentBaseURI.toAbsolute(url, getOption('remove_script_host'));\n return url;\n }\n addVisual(elm) {\n addVisual(this, elm);\n }\n remove() {\n remove$1(this);\n }\n destroy(automatic) {\n destroy(this, automatic);\n }\n uploadImages() {\n return this.editorUpload.uploadImages();\n }\n _scanForImages() {\n return this.editorUpload.scanForImages();\n }\n }\n\n const DOM = DOMUtils.DOM;\n const each = Tools.each;\n let boundGlobalEvents = false;\n let beforeUnloadDelegate;\n let editors = [];\n const globalEventDelegate = e => {\n const type = e.type;\n each(EditorManager.get(), editor => {\n switch (type) {\n case 'scroll':\n editor.dispatch('ScrollWindow', e);\n break;\n case 'resize':\n editor.dispatch('ResizeWindow', e);\n break;\n }\n });\n };\n const toggleGlobalEvents = state => {\n if (state !== boundGlobalEvents) {\n const DOM = DOMUtils.DOM;\n if (state) {\n DOM.bind(window, 'resize', globalEventDelegate);\n DOM.bind(window, 'scroll', globalEventDelegate);\n } else {\n DOM.unbind(window, 'resize', globalEventDelegate);\n DOM.unbind(window, 'scroll', globalEventDelegate);\n }\n boundGlobalEvents = state;\n }\n };\n const removeEditorFromList = targetEditor => {\n const oldEditors = editors;\n editors = filter$5(editors, editor => {\n return targetEditor !== editor;\n });\n if (EditorManager.activeEditor === targetEditor) {\n EditorManager.activeEditor = editors.length > 0 ? editors[0] : null;\n }\n if (EditorManager.focusedEditor === targetEditor) {\n EditorManager.focusedEditor = null;\n }\n return oldEditors.length !== editors.length;\n };\n const purgeDestroyedEditor = editor => {\n if (editor && editor.initialized && !(editor.getContainer() || editor.getBody()).parentNode) {\n removeEditorFromList(editor);\n editor.unbindAllNativeEvents();\n editor.destroy(true);\n editor.removed = true;\n }\n };\n const isQuirksMode = document.compatMode !== 'CSS1Compat';\n const EditorManager = {\n ...Observable,\n baseURI: null,\n baseURL: null,\n defaultOptions: {},\n documentBaseURL: null,\n suffix: null,\n majorVersion: '6',\n minorVersion: '3.1',\n releaseDate: '2022-12-06',\n i18n: I18n,\n activeEditor: null,\n focusedEditor: null,\n setup() {\n const self = this;\n let baseURL = '';\n let suffix = '';\n let documentBaseURL = URI.getDocumentBaseUrl(document.location);\n if (/^[^:]+:\\/\\/\\/?[^\\/]+\\//.test(documentBaseURL)) {\n documentBaseURL = documentBaseURL.replace(/[\\?#].*$/, '').replace(/[\\/\\\\][^\\/]+$/, '');\n if (!/[\\/\\\\]$/.test(documentBaseURL)) {\n documentBaseURL += '/';\n }\n }\n const preInit = window.tinymce || window.tinyMCEPreInit;\n if (preInit) {\n baseURL = preInit.base || preInit.baseURL;\n suffix = preInit.suffix;\n } else {\n const scripts = document.getElementsByTagName('script');\n for (let i = 0; i < scripts.length; i++) {\n const src = scripts[i].src || '';\n if (src === '') {\n continue;\n }\n const srcScript = src.substring(src.lastIndexOf('/'));\n if (/tinymce(\\.full|\\.jquery|)(\\.min|\\.dev|)\\.js/.test(src)) {\n if (srcScript.indexOf('.min') !== -1) {\n suffix = '.min';\n }\n baseURL = src.substring(0, src.lastIndexOf('/'));\n break;\n }\n }\n if (!baseURL && document.currentScript) {\n const src = document.currentScript.src;\n if (src.indexOf('.min') !== -1) {\n suffix = '.min';\n }\n baseURL = src.substring(0, src.lastIndexOf('/'));\n }\n }\n self.baseURL = new URI(documentBaseURL).toAbsolute(baseURL);\n self.documentBaseURL = documentBaseURL;\n self.baseURI = new URI(self.baseURL);\n self.suffix = suffix;\n setup$v(self);\n },\n overrideDefaults(defaultOptions) {\n const baseUrl = defaultOptions.base_url;\n if (baseUrl) {\n this._setBaseUrl(baseUrl);\n }\n const suffix = defaultOptions.suffix;\n if (suffix) {\n this.suffix = suffix;\n }\n this.defaultOptions = defaultOptions;\n const pluginBaseUrls = defaultOptions.plugin_base_urls;\n if (pluginBaseUrls !== undefined) {\n each$d(pluginBaseUrls, (pluginBaseUrl, pluginName) => {\n AddOnManager.PluginManager.urls[pluginName] = pluginBaseUrl;\n });\n }\n },\n init(options) {\n const self = this;\n let result;\n const invalidInlineTargets = Tools.makeMap('area base basefont br col frame hr img input isindex link meta param embed source wbr track ' + 'colgroup option table tbody tfoot thead tr th td script noscript style textarea video audio iframe object menu', ' ');\n const isInvalidInlineTarget = (options, elm) => options.inline && elm.tagName.toLowerCase() in invalidInlineTargets;\n const createId = elm => {\n let id = elm.id;\n if (!id) {\n id = get$a(elm, 'name').filter(name => !DOM.get(name)).getOrThunk(DOM.uniqueId);\n elm.setAttribute('id', id);\n }\n return id;\n };\n const execCallback = name => {\n const callback = options[name];\n if (!callback) {\n return;\n }\n return callback.apply(self, []);\n };\n const findTargets = options => {\n if (Env.browser.isIE() || Env.browser.isEdge()) {\n initError('TinyMCE does not support the browser you are using. For a list of supported' + ' browsers please see: https://www.tiny.cloud/docs/tinymce/6/support/#supportedwebbrowsers');\n return [];\n } else if (isQuirksMode) {\n initError('Failed to initialize the editor as the document is not in standards mode. ' + 'TinyMCE requires standards mode.');\n return [];\n } else if (isString(options.selector)) {\n return DOM.select(options.selector);\n } else if (isNonNullable(options.target)) {\n return [options.target];\n } else {\n return [];\n }\n };\n let provideResults = editors => {\n result = editors;\n };\n const initEditors = () => {\n let initCount = 0;\n const editors = [];\n let targets;\n const createEditor = (id, options, targetElm) => {\n const editor = new Editor(id, options, self);\n editors.push(editor);\n editor.on('init', () => {\n if (++initCount === targets.length) {\n provideResults(editors);\n }\n });\n editor.targetElm = editor.targetElm || targetElm;\n editor.render();\n };\n DOM.unbind(window, 'ready', initEditors);\n execCallback('onpageload');\n targets = unique$1(findTargets(options));\n Tools.each(targets, elm => {\n purgeDestroyedEditor(self.get(elm.id));\n });\n targets = Tools.grep(targets, elm => {\n return !self.get(elm.id);\n });\n if (targets.length === 0) {\n provideResults([]);\n } else {\n each(targets, elm => {\n if (isInvalidInlineTarget(options, elm)) {\n initError('Could not initialize inline editor on invalid inline target element', elm);\n } else {\n createEditor(createId(elm), options, elm);\n }\n });\n }\n };\n DOM.bind(window, 'ready', initEditors);\n return new Promise(resolve => {\n if (result) {\n resolve(result);\n } else {\n provideResults = editors => {\n resolve(editors);\n };\n }\n });\n },\n get(id) {\n if (arguments.length === 0) {\n return editors.slice(0);\n } else if (isString(id)) {\n return find$2(editors, editor => {\n return editor.id === id;\n }).getOr(null);\n } else if (isNumber(id)) {\n return editors[id] ? editors[id] : null;\n } else {\n return null;\n }\n },\n add(editor) {\n const self = this;\n const existingEditor = self.get(editor.id);\n if (existingEditor === editor) {\n return editor;\n }\n if (existingEditor === null) {\n editors.push(editor);\n }\n toggleGlobalEvents(true);\n self.activeEditor = editor;\n self.dispatch('AddEditor', { editor });\n if (!beforeUnloadDelegate) {\n beforeUnloadDelegate = e => {\n const event = self.dispatch('BeforeUnload');\n if (event.returnValue) {\n e.preventDefault();\n e.returnValue = event.returnValue;\n return event.returnValue;\n }\n };\n window.addEventListener('beforeunload', beforeUnloadDelegate);\n }\n return editor;\n },\n createEditor(id, options) {\n return this.add(new Editor(id, options, this));\n },\n remove(selector) {\n const self = this;\n let editor;\n if (!selector) {\n for (let i = editors.length - 1; i >= 0; i--) {\n self.remove(editors[i]);\n }\n return;\n }\n if (isString(selector)) {\n each(DOM.select(selector), elm => {\n editor = self.get(elm.id);\n if (editor) {\n self.remove(editor);\n }\n });\n return;\n }\n editor = selector;\n if (isNull(self.get(editor.id))) {\n return null;\n }\n if (removeEditorFromList(editor)) {\n self.dispatch('RemoveEditor', { editor });\n }\n if (editors.length === 0) {\n window.removeEventListener('beforeunload', beforeUnloadDelegate);\n }\n editor.remove();\n toggleGlobalEvents(editors.length > 0);\n return editor;\n },\n execCommand(cmd, ui, value) {\n var _a;\n const self = this;\n const editorId = isObject(value) ? (_a = value.id) !== null && _a !== void 0 ? _a : value.index : value;\n switch (cmd) {\n case 'mceAddEditor': {\n if (!self.get(editorId)) {\n const editorOptions = value.options;\n new Editor(editorId, editorOptions, self).render();\n }\n return true;\n }\n case 'mceRemoveEditor': {\n const editor = self.get(editorId);\n if (editor) {\n editor.remove();\n }\n return true;\n }\n case 'mceToggleEditor': {\n const editor = self.get(editorId);\n if (!editor) {\n self.execCommand('mceAddEditor', false, value);\n return true;\n }\n if (editor.isHidden()) {\n editor.show();\n } else {\n editor.hide();\n }\n return true;\n }\n }\n if (self.activeEditor) {\n return self.activeEditor.execCommand(cmd, ui, value);\n }\n return false;\n },\n triggerSave: () => {\n each(editors, editor => {\n editor.save();\n });\n },\n addI18n: (code, items) => {\n I18n.add(code, items);\n },\n translate: text => {\n return I18n.translate(text);\n },\n setActive(editor) {\n const activeEditor = this.activeEditor;\n if (this.activeEditor !== editor) {\n if (activeEditor) {\n activeEditor.dispatch('deactivate', { relatedTarget: editor });\n }\n editor.dispatch('activate', { relatedTarget: activeEditor });\n }\n this.activeEditor = editor;\n },\n _setBaseUrl(baseUrl) {\n this.baseURL = new URI(this.documentBaseURL).toAbsolute(baseUrl.replace(/\\/+$/, ''));\n this.baseURI = new URI(this.baseURL);\n }\n };\n EditorManager.setup();\n\n const setup = () => {\n const dataValue = value$2();\n const FakeClipboardItem = items => ({\n items,\n types: keys(items),\n getType: type => get$a(items, type).getOrUndefined()\n });\n const write = data => {\n dataValue.set(data);\n };\n const read = () => dataValue.get().getOrUndefined();\n const clear = dataValue.clear;\n return {\n FakeClipboardItem,\n write,\n read,\n clear\n };\n };\n const FakeClipboard = setup();\n\n const min = Math.min, max = Math.max, round = Math.round;\n const relativePosition = (rect, targetRect, rel) => {\n let x = targetRect.x;\n let y = targetRect.y;\n const w = rect.w;\n const h = rect.h;\n const targetW = targetRect.w;\n const targetH = targetRect.h;\n const relChars = (rel || '').split('');\n if (relChars[0] === 'b') {\n y += targetH;\n }\n if (relChars[1] === 'r') {\n x += targetW;\n }\n if (relChars[0] === 'c') {\n y += round(targetH / 2);\n }\n if (relChars[1] === 'c') {\n x += round(targetW / 2);\n }\n if (relChars[3] === 'b') {\n y -= h;\n }\n if (relChars[4] === 'r') {\n x -= w;\n }\n if (relChars[3] === 'c') {\n y -= round(h / 2);\n }\n if (relChars[4] === 'c') {\n x -= round(w / 2);\n }\n return create$2(x, y, w, h);\n };\n const findBestRelativePosition = (rect, targetRect, constrainRect, rels) => {\n for (let i = 0; i < rels.length; i++) {\n const pos = relativePosition(rect, targetRect, rels[i]);\n if (pos.x >= constrainRect.x && pos.x + pos.w <= constrainRect.w + constrainRect.x && pos.y >= constrainRect.y && pos.y + pos.h <= constrainRect.h + constrainRect.y) {\n return rels[i];\n }\n }\n return null;\n };\n const inflate = (rect, w, h) => {\n return create$2(rect.x - w, rect.y - h, rect.w + w * 2, rect.h + h * 2);\n };\n const intersect = (rect, cropRect) => {\n const x1 = max(rect.x, cropRect.x);\n const y1 = max(rect.y, cropRect.y);\n const x2 = min(rect.x + rect.w, cropRect.x + cropRect.w);\n const y2 = min(rect.y + rect.h, cropRect.y + cropRect.h);\n if (x2 - x1 < 0 || y2 - y1 < 0) {\n return null;\n }\n return create$2(x1, y1, x2 - x1, y2 - y1);\n };\n const clamp = (rect, clampRect, fixedSize) => {\n let x1 = rect.x;\n let y1 = rect.y;\n let x2 = rect.x + rect.w;\n let y2 = rect.y + rect.h;\n const cx2 = clampRect.x + clampRect.w;\n const cy2 = clampRect.y + clampRect.h;\n const underflowX1 = max(0, clampRect.x - x1);\n const underflowY1 = max(0, clampRect.y - y1);\n const overflowX2 = max(0, x2 - cx2);\n const overflowY2 = max(0, y2 - cy2);\n x1 += underflowX1;\n y1 += underflowY1;\n if (fixedSize) {\n x2 += underflowX1;\n y2 += underflowY1;\n x1 -= overflowX2;\n y1 -= overflowY2;\n }\n x2 -= overflowX2;\n y2 -= overflowY2;\n return create$2(x1, y1, x2 - x1, y2 - y1);\n };\n const create$2 = (x, y, w, h) => {\n return {\n x,\n y,\n w,\n h\n };\n };\n const fromClientRect = clientRect => {\n return create$2(clientRect.left, clientRect.top, clientRect.width, clientRect.height);\n };\n const Rect = {\n inflate,\n relativePosition,\n findBestRelativePosition,\n intersect,\n clamp,\n create: create$2,\n fromClientRect\n };\n\n const awaiter = (resolveCb, rejectCb, timeout = 1000) => {\n let done = false;\n let timer = null;\n const complete = completer => (...args) => {\n if (!done) {\n done = true;\n if (timer !== null) {\n clearTimeout(timer);\n timer = null;\n }\n completer.apply(null, args);\n }\n };\n const resolve = complete(resolveCb);\n const reject = complete(rejectCb);\n const start = (...args) => {\n if (!done && timer === null) {\n timer = setTimeout(() => reject.apply(null, args), timeout);\n }\n };\n return {\n start,\n resolve,\n reject\n };\n };\n const create$1 = () => {\n const tasks = {};\n const resultFns = {};\n const load = (id, url) => {\n const loadErrMsg = `Script at URL \"${ url }\" failed to load`;\n const runErrMsg = `Script at URL \"${ url }\" did not call \\`tinymce.Resource.add('${ id }', data)\\` within 1 second`;\n if (tasks[id] !== undefined) {\n return tasks[id];\n } else {\n const task = new Promise((resolve, reject) => {\n const waiter = awaiter(resolve, reject);\n resultFns[id] = waiter.resolve;\n ScriptLoader.ScriptLoader.loadScript(url).then(() => waiter.start(runErrMsg), () => waiter.reject(loadErrMsg));\n });\n tasks[id] = task;\n return task;\n }\n };\n const add = (id, data) => {\n if (resultFns[id] !== undefined) {\n resultFns[id](data);\n delete resultFns[id];\n }\n tasks[id] = Promise.resolve(data);\n };\n const unload = id => {\n delete tasks[id];\n };\n return {\n load,\n add,\n unload\n };\n };\n const Resource = create$1();\n\n const create = () => (() => {\n let data = {};\n let keys = [];\n const storage = {\n getItem: key => {\n const item = data[key];\n return item ? item : null;\n },\n setItem: (key, value) => {\n keys.push(key);\n data[key] = String(value);\n },\n key: index => {\n return keys[index];\n },\n removeItem: key => {\n keys = keys.filter(k => k === key);\n delete data[key];\n },\n clear: () => {\n keys = [];\n data = {};\n },\n length: 0\n };\n Object.defineProperty(storage, 'length', {\n get: () => keys.length,\n configurable: false,\n enumerable: false\n });\n return storage;\n })();\n\n let localStorage;\n try {\n const test = '__storage_test__';\n localStorage = window.localStorage;\n localStorage.setItem(test, test);\n localStorage.removeItem(test);\n } catch (e) {\n localStorage = create();\n }\n var LocalStorage = localStorage;\n\n const publicApi = {\n geom: { Rect },\n util: {\n Delay,\n Tools,\n VK,\n URI,\n EventDispatcher,\n Observable,\n I18n,\n LocalStorage,\n ImageUploader\n },\n dom: {\n EventUtils,\n TreeWalker: DomTreeWalker,\n TextSeeker,\n DOMUtils,\n ScriptLoader,\n RangeUtils,\n Serializer: DomSerializer,\n StyleSheetLoader,\n ControlSelection,\n BookmarkManager,\n Selection: EditorSelection,\n Event: EventUtils.Event\n },\n html: {\n Styles,\n Entities,\n Node: AstNode,\n Schema,\n DomParser,\n Writer,\n Serializer: HtmlSerializer\n },\n Env,\n AddOnManager,\n Annotator,\n Formatter,\n UndoManager,\n EditorCommands,\n WindowManager,\n NotificationManager,\n EditorObservable,\n Shortcuts,\n Editor,\n FocusManager,\n EditorManager,\n DOM: DOMUtils.DOM,\n ScriptLoader: ScriptLoader.ScriptLoader,\n PluginManager,\n ThemeManager,\n ModelManager,\n IconManager,\n Resource,\n FakeClipboard,\n trim: Tools.trim,\n isArray: Tools.isArray,\n is: Tools.is,\n toArray: Tools.toArray,\n makeMap: Tools.makeMap,\n each: Tools.each,\n map: Tools.map,\n grep: Tools.grep,\n inArray: Tools.inArray,\n extend: Tools.extend,\n walk: Tools.walk,\n resolve: Tools.resolve,\n explode: Tools.explode,\n _addCacheSuffix: Tools._addCacheSuffix\n };\n const tinymce = Tools.extend(EditorManager, publicApi);\n\n const exportToModuleLoaders = tinymce => {\n if (typeof module === 'object') {\n try {\n module.exports = tinymce;\n } catch (_) {\n }\n }\n };\n const exportToWindowGlobal = tinymce => {\n window.tinymce = tinymce;\n window.tinyMCE = tinymce;\n };\n exportToWindowGlobal(tinymce);\n exportToModuleLoaders(tinymce);\n\n})();\n", "/*!\n * jQuery JavaScript Library v3.6.3\n * https://jquery.com/\n *\n * Includes Sizzle.js\n * https://sizzlejs.com/\n *\n * Copyright OpenJS Foundation and other contributors\n * Released under the MIT license\n * https://jquery.org/license\n *\n * Date: 2022-12-20T21:28Z\n */\n( function( global, factory ) {\n\n\t\"use strict\";\n\n\tif ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\n\t\t// For CommonJS and CommonJS-like environments where a proper `window`\n\t\t// is present, execute the factory and get jQuery.\n\t\t// For environments that do not have a `window` with a `document`\n\t\t// (such as Node.js), expose a factory as module.exports.\n\t\t// This accentuates the need for the creation of a real `window`.\n\t\t// e.g. var jQuery = require(\"jquery\")(window);\n\t\t// See ticket trac-14549 for more info.\n\t\tmodule.exports = global.document ?\n\t\t\tfactory( global, true ) :\n\t\t\tfunction( w ) {\n\t\t\t\tif ( !w.document ) {\n\t\t\t\t\tthrow new Error( \"jQuery requires a window with a document\" );\n\t\t\t\t}\n\t\t\t\treturn factory( w );\n\t\t\t};\n\t} else {\n\t\tfactory( global );\n\t}\n\n// Pass this if window is not defined yet\n} )( typeof window !== \"undefined\" ? window : this, function( window, noGlobal ) {\n\n// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1\n// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode\n// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common\n// enough that all such attempts are guarded in a try block.\n\"use strict\";\n\nvar arr = [];\n\nvar getProto = Object.getPrototypeOf;\n\nvar slice = arr.slice;\n\nvar flat = arr.flat ? function( array ) {\n\treturn arr.flat.call( array );\n} : function( array ) {\n\treturn arr.concat.apply( [], array );\n};\n\n\nvar push = arr.push;\n\nvar indexOf = arr.indexOf;\n\nvar class2type = {};\n\nvar toString = class2type.toString;\n\nvar hasOwn = class2type.hasOwnProperty;\n\nvar fnToString = hasOwn.toString;\n\nvar ObjectFunctionString = fnToString.call( Object );\n\nvar support = {};\n\nvar isFunction = function isFunction( obj ) {\n\n\t\t// Support: Chrome <=57, Firefox <=52\n\t\t// In some browsers, typeof returns \"function\" for HTML