] + var ancestors = listAncestor(point.node, func.eq(root)); + + if (!ancestors.length) { + return null; + } else if (ancestors.length === 1) { + return splitNode(point, options); + } + + return ancestors.reduce(function (node, parent) { + if (node === point.node) { + node = splitNode(point, options); + } + + return splitNode({ + node: parent, + offset: node ? position(node) : nodeLength(parent) + }, options); + }); +} +/** + * split point + * + * @param {Point} point + * @param {Boolean} isInline + * @return {Object} + */ + + +function splitPoint(point, isInline) { + // find splitRoot, container + // - inline: splitRoot is a child of paragraph + // - block: splitRoot is a child of bodyContainer + var pred = isInline ? isPara : isBodyContainer; + var ancestors = listAncestor(point.node, pred); + var topAncestor = lists.last(ancestors) || point.node; + var splitRoot, container; + + if (pred(topAncestor)) { + splitRoot = ancestors[ancestors.length - 2]; + container = topAncestor; + } else { + splitRoot = topAncestor; + container = splitRoot.parentNode; + } // if splitRoot is exists, split with splitTree + + + var pivot = splitRoot && splitTree(splitRoot, point, { + isSkipPaddingBlankHTML: isInline, + isNotSplitEdgePoint: isInline + }); // if container is point.node, find pivot with point.offset + + if (!pivot && container === point.node) { + pivot = point.node.childNodes[point.offset]; + } + + return { + rightNode: pivot, + container: container + }; +} + +function create(nodeName) { + return document.createElement(nodeName); +} + +function createText(text) { + return document.createTextNode(text); +} +/** + * @method remove + * + * remove node, (isRemoveChild: remove child or not) + * + * @param {Node} node + * @param {Boolean} isRemoveChild + */ + + +function remove(node, isRemoveChild) { + if (!node || !node.parentNode) { + return; + } + + if (node.removeNode) { + return node.removeNode(isRemoveChild); + } + + var parent = node.parentNode; + + if (!isRemoveChild) { + var nodes = []; + + for (var i = 0, len = node.childNodes.length; i < len; i++) { + nodes.push(node.childNodes[i]); + } + + for (var _i = 0, _len = nodes.length; _i < _len; _i++) { + parent.insertBefore(nodes[_i], node); + } + } + + parent.removeChild(node); +} +/** + * @method removeWhile + * + * @param {Node} node + * @param {Function} pred + */ + + +function removeWhile(node, pred) { + while (node) { + if (isEditable(node) || !pred(node)) { + break; + } + + var parent = node.parentNode; + remove(node); + node = parent; + } +} +/** + * @method replace + * + * replace node with provided nodeName + * + * @param {Node} node + * @param {String} nodeName + * @return {Node} - new node + */ + + +function replace(node, nodeName) { + if (node.nodeName.toUpperCase() === nodeName.toUpperCase()) { + return node; + } + + var newNode = create(nodeName); + + if (node.style.cssText) { + newNode.style.cssText = node.style.cssText; + } + + appendChildNodes(newNode, lists.from(node.childNodes)); + insertAfter(newNode, node); + remove(node); + return newNode; +} + +var isTextarea = makePredByNodeName('TEXTAREA'); +/** + * @param {jQuery} $node + * @param {Boolean} [stripLinebreaks] - default: false + */ + +function value($node, stripLinebreaks) { + var val = isTextarea($node[0]) ? $node.val() : $node.html(); + + if (stripLinebreaks) { + return val.replace(/[\n\r]/g, ''); + } + + return val; +} +/** + * @method html + * + * get the HTML contents of node + * + * @param {jQuery} $node + * @param {Boolean} [isNewlineOnBlock] + */ + + +function html($node, isNewlineOnBlock) { + var markup = value($node); + + if (isNewlineOnBlock) { + var regexTag = /<(\/?)(\b(?!!)[^>\s]*)(.*?)(\s*\/?>)/g; + markup = markup.replace(regexTag, function (match, endSlash, name) { + name = name.toUpperCase(); + var isEndOfInlineContainer = /^DIV|^TD|^TH|^P|^LI|^H[1-7]/.test(name) && !!endSlash; + var isBlockNode = /^BLOCKQUOTE|^TABLE|^TBODY|^TR|^HR|^UL|^OL/.test(name); + return match + (isEndOfInlineContainer || isBlockNode ? '\n' : ''); + }); + markup = markup.trim(); + } + + return markup; +} + +function posFromPlaceholder(placeholder) { + var $placeholder = external_jQuery_default()(placeholder); + var pos = $placeholder.offset(); + var height = $placeholder.outerHeight(true); // include margin + + return { + left: pos.left, + top: pos.top + height + }; +} + +function attachEvents($node, events) { + Object.keys(events).forEach(function (key) { + $node.on(key, events[key]); + }); +} + +function detachEvents($node, events) { + Object.keys(events).forEach(function (key) { + $node.off(key, events[key]); + }); +} +/** + * @method isCustomStyleTag + * + * assert if a node contains a "note-styletag" class, + * which implies that's a custom-made style tag node + * + * @param {Node} an HTML DOM node + */ + + +function isCustomStyleTag(node) { + return node && !isText(node) && lists.contains(node.classList, 'note-styletag'); +} + +/* harmony default export */ const dom = ({ + /** @property {String} NBSP_CHAR */ + NBSP_CHAR: NBSP_CHAR, + + /** @property {String} ZERO_WIDTH_NBSP_CHAR */ + ZERO_WIDTH_NBSP_CHAR: ZERO_WIDTH_NBSP_CHAR, + + /** @property {String} blank */ + blank: blankHTML, + + /** @property {String} emptyPara */ + emptyPara: "
".concat(blankHTML, "
"), + makePredByNodeName: makePredByNodeName, + isEditable: isEditable, + isControlSizing: isControlSizing, + isText: isText, + isElement: isElement, + isVoid: isVoid, + isPara: isPara, + isPurePara: isPurePara, + isHeading: isHeading, + isInline: isInline, + isBlock: func.not(isInline), + isBodyInline: isBodyInline, + isBody: isBody, + isParaInline: isParaInline, + isPre: isPre, + isList: isList, + isTable: isTable, + isData: isData, + isCell: isCell, + isBlockquote: isBlockquote, + isBodyContainer: isBodyContainer, + isAnchor: isAnchor, + isDiv: makePredByNodeName('DIV'), + isLi: isLi, + isBR: makePredByNodeName('BR'), + isSpan: makePredByNodeName('SPAN'), + isB: makePredByNodeName('B'), + isU: makePredByNodeName('U'), + isS: makePredByNodeName('S'), + isI: makePredByNodeName('I'), + isImg: makePredByNodeName('IMG'), + isTextarea: isTextarea, + deepestChildIsEmpty: deepestChildIsEmpty, + isEmpty: dom_isEmpty, + isEmptyAnchor: func.and(isAnchor, dom_isEmpty), + isClosestSibling: isClosestSibling, + withClosestSiblings: withClosestSiblings, + nodeLength: nodeLength, + isLeftEdgePoint: isLeftEdgePoint, + isRightEdgePoint: isRightEdgePoint, + isEdgePoint: isEdgePoint, + isLeftEdgeOf: isLeftEdgeOf, + isRightEdgeOf: isRightEdgeOf, + isLeftEdgePointOf: isLeftEdgePointOf, + isRightEdgePointOf: isRightEdgePointOf, + prevPoint: prevPoint, + nextPoint: nextPoint, + nextPointWithEmptyNode: nextPointWithEmptyNode, + isSamePoint: isSamePoint, + isVisiblePoint: isVisiblePoint, + prevPointUntil: prevPointUntil, + nextPointUntil: nextPointUntil, + isCharPoint: isCharPoint, + isSpacePoint: isSpacePoint, + walkPoint: walkPoint, + ancestor: ancestor, + singleChildAncestor: singleChildAncestor, + listAncestor: listAncestor, + lastAncestor: lastAncestor, + listNext: listNext, + listPrev: listPrev, + listDescendant: listDescendant, + commonAncestor: commonAncestor, + wrap: wrap, + insertAfter: insertAfter, + appendChildNodes: appendChildNodes, + position: position, + hasChildren: hasChildren, + makeOffsetPath: makeOffsetPath, + fromOffsetPath: fromOffsetPath, + splitTree: splitTree, + splitPoint: splitPoint, + create: create, + createText: createText, + remove: remove, + removeWhile: removeWhile, + replace: replace, + html: html, + value: value, + posFromPlaceholder: posFromPlaceholder, + attachEvents: attachEvents, + detachEvents: detachEvents, + isCustomStyleTag: isCustomStyleTag +}); +;// CONCATENATED MODULE: ./src/js/Context.js +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + + + + + + +var Context = /*#__PURE__*/function () { + /** + * @param {jQuery} $note + * @param {Object} options + */ + function Context($note, options) { + _classCallCheck(this, Context); + + this.$note = $note; + this.memos = {}; + this.modules = {}; + this.layoutInfo = {}; + this.options = external_jQuery_default().extend(true, {}, options); // init ui with options + + (external_jQuery_default()).summernote.ui = external_jQuery_default().summernote.ui_template(this.options); + this.ui = (external_jQuery_default()).summernote.ui; + this.initialize(); + } + /** + * create layout and initialize modules and other resources + */ + + + _createClass(Context, [{ + key: "initialize", + value: function initialize() { + this.layoutInfo = this.ui.createLayout(this.$note); + + this._initialize(); + + this.$note.hide(); + return this; + } + /** + * destroy modules and other resources and remove layout + */ + + }, { + key: "destroy", + value: function destroy() { + this._destroy(); + + this.$note.removeData('summernote'); + this.ui.removeLayout(this.$note, this.layoutInfo); + } + /** + * destory modules and other resources and initialize it again + */ + + }, { + key: "reset", + value: function reset() { + var disabled = this.isDisabled(); + this.code(dom.emptyPara); + + this._destroy(); + + this._initialize(); + + if (disabled) { + this.disable(); + } + } + }, { + key: "_initialize", + value: function _initialize() { + var _this = this; + + // set own id + this.options.id = func.uniqueId(external_jQuery_default().now()); // set default container for tooltips, popovers, and dialogs + + this.options.container = this.options.container || this.layoutInfo.editor; // add optional buttons + + var buttons = external_jQuery_default().extend({}, this.options.buttons); + Object.keys(buttons).forEach(function (key) { + _this.memo('button.' + key, buttons[key]); + }); + var modules = external_jQuery_default().extend({}, this.options.modules, (external_jQuery_default()).summernote.plugins || {}); // add and initialize modules + + Object.keys(modules).forEach(function (key) { + _this.module(key, modules[key], true); + }); + Object.keys(this.modules).forEach(function (key) { + _this.initializeModule(key); + }); + } + }, { + key: "_destroy", + value: function _destroy() { + var _this2 = this; + + // destroy modules with reversed order + Object.keys(this.modules).reverse().forEach(function (key) { + _this2.removeModule(key); + }); + Object.keys(this.memos).forEach(function (key) { + _this2.removeMemo(key); + }); // trigger custom onDestroy callback + + this.triggerEvent('destroy', this); + } + }, { + key: "code", + value: function code(html) { + var isActivated = this.invoke('codeview.isActivated'); + + if (html === undefined) { + this.invoke('codeview.sync'); + return isActivated ? this.layoutInfo.codable.val() : this.layoutInfo.editable.html(); + } else { + if (isActivated) { + this.invoke('codeview.sync', html); + } else { + this.layoutInfo.editable.html(html); + } + + this.$note.val(html); + this.triggerEvent('change', html, this.layoutInfo.editable); + } + } + }, { + key: "isDisabled", + value: function isDisabled() { + return this.layoutInfo.editable.attr('contenteditable') === 'false'; + } + }, { + key: "enable", + value: function enable() { + this.layoutInfo.editable.attr('contenteditable', true); + this.invoke('toolbar.activate', true); + this.triggerEvent('disable', false); + this.options.editing = true; + } + }, { + key: "disable", + value: function disable() { + // close codeview if codeview is opend + if (this.invoke('codeview.isActivated')) { + this.invoke('codeview.deactivate'); + } + + this.layoutInfo.editable.attr('contenteditable', false); + this.options.editing = false; + this.invoke('toolbar.deactivate', true); + this.triggerEvent('disable', true); + } + }, { + key: "triggerEvent", + value: function triggerEvent() { + var namespace = lists.head(arguments); + var args = lists.tail(lists.from(arguments)); + var callback = this.options.callbacks[func.namespaceToCamel(namespace, 'on')]; + + if (callback) { + callback.apply(this.$note[0], args); + } + + this.$note.trigger('summernote.' + namespace, args); + } + }, { + key: "initializeModule", + value: function initializeModule(key) { + var module = this.modules[key]; + module.shouldInitialize = module.shouldInitialize || func.ok; + + if (!module.shouldInitialize()) { + return; + } // initialize module + + + if (module.initialize) { + module.initialize(); + } // attach events + + + if (module.events) { + dom.attachEvents(this.$note, module.events); + } + } + }, { + key: "module", + value: function module(key, ModuleClass, withoutIntialize) { + if (arguments.length === 1) { + return this.modules[key]; + } + + this.modules[key] = new ModuleClass(this); + + if (!withoutIntialize) { + this.initializeModule(key); + } + } + }, { + key: "removeModule", + value: function removeModule(key) { + var module = this.modules[key]; + + if (module.shouldInitialize()) { + if (module.events) { + dom.detachEvents(this.$note, module.events); + } + + if (module.destroy) { + module.destroy(); + } + } + + delete this.modules[key]; + } + }, { + key: "memo", + value: function memo(key, obj) { + if (arguments.length === 1) { + return this.memos[key]; + } + + this.memos[key] = obj; + } + }, { + key: "removeMemo", + value: function removeMemo(key) { + if (this.memos[key] && this.memos[key].destroy) { + this.memos[key].destroy(); + } + + delete this.memos[key]; + } + /** + * Some buttons need to change their visual style immediately once they get pressed + */ + + }, { + key: "createInvokeHandlerAndUpdateState", + value: function createInvokeHandlerAndUpdateState(namespace, value) { + var _this3 = this; + + return function (event) { + _this3.createInvokeHandler(namespace, value)(event); + + _this3.invoke('buttons.updateCurrentStyle'); + }; + } + }, { + key: "createInvokeHandler", + value: function createInvokeHandler(namespace, value) { + var _this4 = this; + + return function (event) { + event.preventDefault(); + var $target = external_jQuery_default()(event.target); + + _this4.invoke(namespace, value || $target.closest('[data-value]').data('value'), $target); + }; + } + }, { + key: "invoke", + value: function invoke() { + var namespace = lists.head(arguments); + var args = lists.tail(lists.from(arguments)); + var splits = namespace.split('.'); + var hasSeparator = splits.length > 1; + var moduleName = hasSeparator && lists.head(splits); + var methodName = hasSeparator ? lists.last(splits) : lists.head(splits); + var module = this.modules[moduleName || 'editor']; + + if (!moduleName && this[methodName]) { + return this[methodName].apply(this, args); + } else if (module && module[methodName] && module.shouldInitialize()) { + return module[methodName].apply(module, args); + } + } + }]); + + return Context; +}(); + + +;// CONCATENATED MODULE: ./src/js/summernote.js + + + + +external_jQuery_default().fn.extend({ + /** + * Summernote API + * + * @param {Object|String} + * @return {this} + */ + summernote: function summernote() { + var type = external_jQuery_default().type(lists.head(arguments)); + var isExternalAPICalled = type === 'string'; + var hasInitOptions = type === 'object'; + var options = external_jQuery_default().extend({}, (external_jQuery_default()).summernote.options, hasInitOptions ? lists.head(arguments) : {}); // Update options + + options.langInfo = external_jQuery_default().extend(true, {}, (external_jQuery_default()).summernote.lang["en-US"], (external_jQuery_default()).summernote.lang[options.lang]); + options.icons = external_jQuery_default().extend(true, {}, (external_jQuery_default()).summernote.options.icons, options.icons); + options.tooltip = options.tooltip === 'auto' ? !env.isSupportTouch : options.tooltip; + this.each(function (idx, note) { + var $note = external_jQuery_default()(note); + + if (!$note.data('summernote')) { + var context = new Context($note, options); + $note.data('summernote', context); + $note.data('summernote').triggerEvent('init', context.layoutInfo); + } + }); + var $note = this.first(); + + if ($note.length) { + var context = $note.data('summernote'); + + if (isExternalAPICalled) { + return context.invoke.apply(context, lists.from(arguments)); + } else if (options.focus) { + context.invoke('editor.focus'); + } + } + + return this; + } +}); +;// CONCATENATED MODULE: ./src/js/core/range.js +function range_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function range_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function range_createClass(Constructor, protoProps, staticProps) { if (protoProps) range_defineProperties(Constructor.prototype, protoProps); if (staticProps) range_defineProperties(Constructor, staticProps); return Constructor; } + + + + + + +/** + * return boundaryPoint from TextRange, inspired by Andy Na's HuskyRange.js + * + * @param {TextRange} textRange + * @param {Boolean} isStart + * @return {BoundaryPoint} + * + * @see http://msdn.microsoft.com/en-us/library/ie/ms535872(v=vs.85).aspx + */ + +function textRangeToPoint(textRange, isStart) { + var container = textRange.parentElement(); + var offset; + var tester = document.body.createTextRange(); + var prevContainer; + var childNodes = lists.from(container.childNodes); + + for (offset = 0; offset < childNodes.length; offset++) { + if (dom.isText(childNodes[offset])) { + continue; + } + + tester.moveToElementText(childNodes[offset]); + + if (tester.compareEndPoints('StartToStart', textRange) >= 0) { + break; + } + + prevContainer = childNodes[offset]; + } + + if (offset !== 0 && dom.isText(childNodes[offset - 1])) { + var textRangeStart = document.body.createTextRange(); + var curTextNode = null; + textRangeStart.moveToElementText(prevContainer || container); + textRangeStart.collapse(!prevContainer); + curTextNode = prevContainer ? prevContainer.nextSibling : container.firstChild; + var pointTester = textRange.duplicate(); + pointTester.setEndPoint('StartToStart', textRangeStart); + var textCount = pointTester.text.replace(/[\r\n]/g, '').length; + + while (textCount > curTextNode.nodeValue.length && curTextNode.nextSibling) { + textCount -= curTextNode.nodeValue.length; + curTextNode = curTextNode.nextSibling; + } // [workaround] enforce IE to re-reference curTextNode, hack + + + var dummy = curTextNode.nodeValue; // eslint-disable-line + + if (isStart && curTextNode.nextSibling && dom.isText(curTextNode.nextSibling) && textCount === curTextNode.nodeValue.length) { + textCount -= curTextNode.nodeValue.length; + curTextNode = curTextNode.nextSibling; + } + + container = curTextNode; + offset = textCount; + } + + return { + cont: container, + offset: offset + }; +} +/** + * return TextRange from boundary point (inspired by google closure-library) + * @param {BoundaryPoint} point + * @return {TextRange} + */ + + +function pointToTextRange(point) { + var textRangeInfo = function textRangeInfo(container, offset) { + var node, isCollapseToStart; + + if (dom.isText(container)) { + var prevTextNodes = dom.listPrev(container, func.not(dom.isText)); + var prevContainer = lists.last(prevTextNodes).previousSibling; + node = prevContainer || container.parentNode; + offset += lists.sum(lists.tail(prevTextNodes), dom.nodeLength); + isCollapseToStart = !prevContainer; + } else { + node = container.childNodes[offset] || container; + + if (dom.isText(node)) { + return textRangeInfo(node, 0); + } + + offset = 0; + isCollapseToStart = false; + } + + return { + node: node, + collapseToStart: isCollapseToStart, + offset: offset + }; + }; + + var textRange = document.body.createTextRange(); + var info = textRangeInfo(point.node, point.offset); + textRange.moveToElementText(info.node); + textRange.collapse(info.collapseToStart); + textRange.moveStart('character', info.offset); + return textRange; +} +/** + * Wrapped Range + * + * @constructor + * @param {Node} sc - start container + * @param {Number} so - start offset + * @param {Node} ec - end container + * @param {Number} eo - end offset + */ + + +var WrappedRange = /*#__PURE__*/function () { + function WrappedRange(sc, so, ec, eo) { + range_classCallCheck(this, WrappedRange); + + this.sc = sc; + this.so = so; + this.ec = ec; + this.eo = eo; // isOnEditable: judge whether range is on editable or not + + this.isOnEditable = this.makeIsOn(dom.isEditable); // isOnList: judge whether range is on list node or not + + this.isOnList = this.makeIsOn(dom.isList); // isOnAnchor: judge whether range is on anchor node or not + + this.isOnAnchor = this.makeIsOn(dom.isAnchor); // isOnCell: judge whether range is on cell node or not + + this.isOnCell = this.makeIsOn(dom.isCell); // isOnData: judge whether range is on data node or not + + this.isOnData = this.makeIsOn(dom.isData); + } // nativeRange: get nativeRange from sc, so, ec, eo + + + range_createClass(WrappedRange, [{ + key: "nativeRange", + value: function nativeRange() { + if (env.isW3CRangeSupport) { + var w3cRange = document.createRange(); + w3cRange.setStart(this.sc, this.so); + w3cRange.setEnd(this.ec, this.eo); + return w3cRange; + } else { + var textRange = pointToTextRange({ + node: this.sc, + offset: this.so + }); + textRange.setEndPoint('EndToEnd', pointToTextRange({ + node: this.ec, + offset: this.eo + })); + return textRange; + } + } + }, { + key: "getPoints", + value: function getPoints() { + return { + sc: this.sc, + so: this.so, + ec: this.ec, + eo: this.eo + }; + } + }, { + key: "getStartPoint", + value: function getStartPoint() { + return { + node: this.sc, + offset: this.so + }; + } + }, { + key: "getEndPoint", + value: function getEndPoint() { + return { + node: this.ec, + offset: this.eo + }; + } + /** + * select update visible range + */ + + }, { + key: "select", + value: function select() { + var nativeRng = this.nativeRange(); + + if (env.isW3CRangeSupport) { + var selection = document.getSelection(); + + if (selection.rangeCount > 0) { + selection.removeAllRanges(); + } + + selection.addRange(nativeRng); + } else { + nativeRng.select(); + } + + return this; + } + /** + * Moves the scrollbar to start container(sc) of current range + * + * @return {WrappedRange} + */ + + }, { + key: "scrollIntoView", + value: function scrollIntoView(container) { + var height = external_jQuery_default()(container).height(); + + if (container.scrollTop + height < this.sc.offsetTop) { + container.scrollTop += Math.abs(container.scrollTop + height - this.sc.offsetTop); + } + + return this; + } + /** + * @return {WrappedRange} + */ + + }, { + key: "normalize", + value: function normalize() { + /** + * @param {BoundaryPoint} point + * @param {Boolean} isLeftToRight - true: prefer to choose right node + * - false: prefer to choose left node + * @return {BoundaryPoint} + */ + var getVisiblePoint = function getVisiblePoint(point, isLeftToRight) { + if (!point) { + return point; + } // Just use the given point [XXX:Adhoc] + // - case 01. if the point is on the middle of the node + // - case 02. if the point is on the right edge and prefer to choose left node + // - case 03. if the point is on the left edge and prefer to choose right node + // - case 04. if the point is on the right edge and prefer to choose right node but the node is void + // - case 05. if the point is on the left edge and prefer to choose left node but the node is void + // - case 06. if the point is on the block node and there is no children + + + if (dom.isVisiblePoint(point)) { + if (!dom.isEdgePoint(point) || dom.isRightEdgePoint(point) && !isLeftToRight || dom.isLeftEdgePoint(point) && isLeftToRight || dom.isRightEdgePoint(point) && isLeftToRight && dom.isVoid(point.node.nextSibling) || dom.isLeftEdgePoint(point) && !isLeftToRight && dom.isVoid(point.node.previousSibling) || dom.isBlock(point.node) && dom.isEmpty(point.node)) { + return point; + } + } // point on block's edge + + + var block = dom.ancestor(point.node, dom.isBlock); + var hasRightNode = false; + + if (!hasRightNode) { + var prevPoint = dom.prevPoint(point) || { + node: null + }; + hasRightNode = (dom.isLeftEdgePointOf(point, block) || dom.isVoid(prevPoint.node)) && !isLeftToRight; + } + + var hasLeftNode = false; + + if (!hasLeftNode) { + var _nextPoint = dom.nextPoint(point) || { + node: null + }; + + hasLeftNode = (dom.isRightEdgePointOf(point, block) || dom.isVoid(_nextPoint.node)) && isLeftToRight; + } + + if (hasRightNode || hasLeftNode) { + // returns point already on visible point + if (dom.isVisiblePoint(point)) { + return point; + } // reverse direction + + + isLeftToRight = !isLeftToRight; + } + + var nextPoint = isLeftToRight ? dom.nextPointUntil(dom.nextPoint(point), dom.isVisiblePoint) : dom.prevPointUntil(dom.prevPoint(point), dom.isVisiblePoint); + return nextPoint || point; + }; + + var endPoint = getVisiblePoint(this.getEndPoint(), false); + var startPoint = this.isCollapsed() ? endPoint : getVisiblePoint(this.getStartPoint(), true); + return new WrappedRange(startPoint.node, startPoint.offset, endPoint.node, endPoint.offset); + } + /** + * returns matched nodes on range + * + * @param {Function} [pred] - predicate function + * @param {Object} [options] + * @param {Boolean} [options.includeAncestor] + * @param {Boolean} [options.fullyContains] + * @return {Node[]} + */ + + }, { + key: "nodes", + value: function nodes(pred, options) { + pred = pred || func.ok; + var includeAncestor = options && options.includeAncestor; + var fullyContains = options && options.fullyContains; // TODO compare points and sort + + var startPoint = this.getStartPoint(); + var endPoint = this.getEndPoint(); + var nodes = []; + var leftEdgeNodes = []; + dom.walkPoint(startPoint, endPoint, function (point) { + if (dom.isEditable(point.node)) { + return; + } + + var node; + + if (fullyContains) { + if (dom.isLeftEdgePoint(point)) { + leftEdgeNodes.push(point.node); + } + + if (dom.isRightEdgePoint(point) && lists.contains(leftEdgeNodes, point.node)) { + node = point.node; + } + } else if (includeAncestor) { + node = dom.ancestor(point.node, pred); + } else { + node = point.node; + } + + if (node && pred(node)) { + nodes.push(node); + } + }, true); + return lists.unique(nodes); + } + /** + * returns commonAncestor of range + * @return {Element} - commonAncestor + */ + + }, { + key: "commonAncestor", + value: function commonAncestor() { + return dom.commonAncestor(this.sc, this.ec); + } + /** + * returns expanded range by pred + * + * @param {Function} pred - predicate function + * @return {WrappedRange} + */ + + }, { + key: "expand", + value: function expand(pred) { + var startAncestor = dom.ancestor(this.sc, pred); + var endAncestor = dom.ancestor(this.ec, pred); + + if (!startAncestor && !endAncestor) { + return new WrappedRange(this.sc, this.so, this.ec, this.eo); + } + + var boundaryPoints = this.getPoints(); + + if (startAncestor) { + boundaryPoints.sc = startAncestor; + boundaryPoints.so = 0; + } + + if (endAncestor) { + boundaryPoints.ec = endAncestor; + boundaryPoints.eo = dom.nodeLength(endAncestor); + } + + return new WrappedRange(boundaryPoints.sc, boundaryPoints.so, boundaryPoints.ec, boundaryPoints.eo); + } + /** + * @param {Boolean} isCollapseToStart + * @return {WrappedRange} + */ + + }, { + key: "collapse", + value: function collapse(isCollapseToStart) { + if (isCollapseToStart) { + return new WrappedRange(this.sc, this.so, this.sc, this.so); + } else { + return new WrappedRange(this.ec, this.eo, this.ec, this.eo); + } + } + /** + * splitText on range + */ + + }, { + key: "splitText", + value: function splitText() { + var isSameContainer = this.sc === this.ec; + var boundaryPoints = this.getPoints(); + + if (dom.isText(this.ec) && !dom.isEdgePoint(this.getEndPoint())) { + this.ec.splitText(this.eo); + } + + if (dom.isText(this.sc) && !dom.isEdgePoint(this.getStartPoint())) { + boundaryPoints.sc = this.sc.splitText(this.so); + boundaryPoints.so = 0; + + if (isSameContainer) { + boundaryPoints.ec = boundaryPoints.sc; + boundaryPoints.eo = this.eo - this.so; + } + } + + return new WrappedRange(boundaryPoints.sc, boundaryPoints.so, boundaryPoints.ec, boundaryPoints.eo); + } + /** + * delete contents on range + * @return {WrappedRange} + */ + + }, { + key: "deleteContents", + value: function deleteContents() { + if (this.isCollapsed()) { + return this; + } + + var rng = this.splitText(); + var nodes = rng.nodes(null, { + fullyContains: true + }); // find new cursor point + + var point = dom.prevPointUntil(rng.getStartPoint(), function (point) { + return !lists.contains(nodes, point.node); + }); + var emptyParents = []; + external_jQuery_default().each(nodes, function (idx, node) { + // find empty parents + var parent = node.parentNode; + + if (point.node !== parent && dom.nodeLength(parent) === 1) { + emptyParents.push(parent); + } + + dom.remove(node, false); + }); // remove empty parents + + external_jQuery_default().each(emptyParents, function (idx, node) { + dom.remove(node, false); + }); + return new WrappedRange(point.node, point.offset, point.node, point.offset).normalize(); + } + /** + * makeIsOn: return isOn(pred) function + */ + + }, { + key: "makeIsOn", + value: function makeIsOn(pred) { + return function () { + var ancestor = dom.ancestor(this.sc, pred); + return !!ancestor && ancestor === dom.ancestor(this.ec, pred); + }; + } + /** + * @param {Function} pred + * @return {Boolean} + */ + + }, { + key: "isLeftEdgeOf", + value: function isLeftEdgeOf(pred) { + if (!dom.isLeftEdgePoint(this.getStartPoint())) { + return false; + } + + var node = dom.ancestor(this.sc, pred); + return node && dom.isLeftEdgeOf(this.sc, node); + } + /** + * returns whether range was collapsed or not + */ + + }, { + key: "isCollapsed", + value: function isCollapsed() { + return this.sc === this.ec && this.so === this.eo; + } + /** + * wrap inline nodes which children of body with paragraph + * + * @return {WrappedRange} + */ + + }, { + key: "wrapBodyInlineWithPara", + value: function wrapBodyInlineWithPara() { + if (dom.isBodyContainer(this.sc) && dom.isEmpty(this.sc)) { + this.sc.innerHTML = dom.emptyPara; + return new WrappedRange(this.sc.firstChild, 0, this.sc.firstChild, 0); + } + /** + * [workaround] firefox often create range on not visible point. so normalize here. + * - firefox: |text
| + * - chrome:|text|
+ */ + + + var rng = this.normalize(); + + if (dom.isParaInline(this.sc) || dom.isPara(this.sc)) { + return rng; + } // find inline top ancestor + + + var topAncestor; + + if (dom.isInline(rng.sc)) { + var ancestors = dom.listAncestor(rng.sc, func.not(dom.isInline)); + topAncestor = lists.last(ancestors); + + if (!dom.isInline(topAncestor)) { + topAncestor = ancestors[ancestors.length - 2] || rng.sc.childNodes[rng.so]; + } + } else { + topAncestor = rng.sc.childNodes[rng.so > 0 ? rng.so - 1 : 0]; + } + + if (topAncestor) { + // siblings not in paragraph + var inlineSiblings = dom.listPrev(topAncestor, dom.isParaInline).reverse(); + inlineSiblings = inlineSiblings.concat(dom.listNext(topAncestor.nextSibling, dom.isParaInline)); // wrap with paragraph + + if (inlineSiblings.length) { + var para = dom.wrap(lists.head(inlineSiblings), 'p'); + dom.appendChildNodes(para, lists.tail(inlineSiblings)); + } + } + + return this.normalize(); + } + /** + * insert node at current cursor + * + * @param {Node} node + * @return {Node} + */ + + }, { + key: "insertNode", + value: function insertNode(node) { + var rng = this; + + if (dom.isText(node) || dom.isInline(node)) { + rng = this.wrapBodyInlineWithPara().deleteContents(); + } + + var info = dom.splitPoint(rng.getStartPoint(), dom.isInline(node)); + + if (info.rightNode) { + info.rightNode.parentNode.insertBefore(node, info.rightNode); + + if (dom.isEmpty(info.rightNode) && dom.isPara(node)) { + info.rightNode.parentNode.removeChild(info.rightNode); + } + } else { + info.container.appendChild(node); + } + + return node; + } + /** + * insert html at current cursor + */ + + }, { + key: "pasteHTML", + value: function pasteHTML(markup) { + markup = external_jQuery_default().trim(markup); + var contentsContainer = external_jQuery_default()('').html(markup)[0]; + var childNodes = lists.from(contentsContainer.childNodes); // const rng = this.wrapBodyInlineWithPara().deleteContents(); + + var rng = this; + var reversed = false; + + if (rng.so >= 0) { + childNodes = childNodes.reverse(); + reversed = true; + } + + childNodes = childNodes.map(function (childNode) { + return rng.insertNode(childNode); + }); + + if (reversed) { + childNodes = childNodes.reverse(); + } + + return childNodes; + } + /** + * returns text in range + * + * @return {String} + */ + + }, { + key: "toString", + value: function toString() { + var nativeRng = this.nativeRange(); + return env.isW3CRangeSupport ? nativeRng.toString() : nativeRng.text; + } + /** + * returns range for word before cursor + * + * @param {Boolean} [findAfter] - find after cursor, default: false + * @return {WrappedRange} + */ + + }, { + key: "getWordRange", + value: function getWordRange(findAfter) { + var endPoint = this.getEndPoint(); + + if (!dom.isCharPoint(endPoint)) { + return this; + } + + var startPoint = dom.prevPointUntil(endPoint, function (point) { + return !dom.isCharPoint(point); + }); + + if (findAfter) { + endPoint = dom.nextPointUntil(endPoint, function (point) { + return !dom.isCharPoint(point); + }); + } + + return new WrappedRange(startPoint.node, startPoint.offset, endPoint.node, endPoint.offset); + } + /** + * returns range for words before cursor + * + * @param {Boolean} [findAfter] - find after cursor, default: false + * @return {WrappedRange} + */ + + }, { + key: "getWordsRange", + value: function getWordsRange(findAfter) { + var endPoint = this.getEndPoint(); + + var isNotTextPoint = function isNotTextPoint(point) { + return !dom.isCharPoint(point) && !dom.isSpacePoint(point); + }; + + if (isNotTextPoint(endPoint)) { + return this; + } + + var startPoint = dom.prevPointUntil(endPoint, isNotTextPoint); + + if (findAfter) { + endPoint = dom.nextPointUntil(endPoint, isNotTextPoint); + } + + return new WrappedRange(startPoint.node, startPoint.offset, endPoint.node, endPoint.offset); + } + /** + * returns range for words before cursor that match with a Regex + * + * example: + * range: 'hi @Peter Pan' + * regex: '/@[a-z ]+/i' + * return range: '@Peter Pan' + * + * @param {RegExp} [regex] + * @return {WrappedRange|null} + */ + + }, { + key: "getWordsMatchRange", + value: function getWordsMatchRange(regex) { + var endPoint = this.getEndPoint(); + var startPoint = dom.prevPointUntil(endPoint, function (point) { + if (!dom.isCharPoint(point) && !dom.isSpacePoint(point)) { + return true; + } + + var rng = new WrappedRange(point.node, point.offset, endPoint.node, endPoint.offset); + var result = regex.exec(rng.toString()); + return result && result.index === 0; + }); + var rng = new WrappedRange(startPoint.node, startPoint.offset, endPoint.node, endPoint.offset); + var text = rng.toString(); + var result = regex.exec(text); + + if (result && result[0].length === text.length) { + return rng; + } else { + return null; + } + } + /** + * create offsetPath bookmark + * + * @param {Node} editable + */ + + }, { + key: "bookmark", + value: function bookmark(editable) { + return { + s: { + path: dom.makeOffsetPath(editable, this.sc), + offset: this.so + }, + e: { + path: dom.makeOffsetPath(editable, this.ec), + offset: this.eo + } + }; + } + /** + * create offsetPath bookmark base on paragraph + * + * @param {Node[]} paras + */ + + }, { + key: "paraBookmark", + value: function paraBookmark(paras) { + return { + s: { + path: lists.tail(dom.makeOffsetPath(lists.head(paras), this.sc)), + offset: this.so + }, + e: { + path: lists.tail(dom.makeOffsetPath(lists.last(paras), this.ec)), + offset: this.eo + } + }; + } + /** + * getClientRects + * @return {Rect[]} + */ + + }, { + key: "getClientRects", + value: function getClientRects() { + var nativeRng = this.nativeRange(); + return nativeRng.getClientRects(); + } + }]); + + return WrappedRange; +}(); +/** + * Data structure + * * BoundaryPoint: a point of dom tree + * * BoundaryPoints: two boundaryPoints corresponding to the start and the end of the Range + * + * See to http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html#Level-2-Range-Position + */ + + +/* harmony default export */ const range = ({ + /** + * create Range Object From arguments or Browser Selection + * + * @param {Node} sc - start container + * @param {Number} so - start offset + * @param {Node} ec - end container + * @param {Number} eo - end offset + * @return {WrappedRange} + */ + create: function create(sc, so, ec, eo) { + if (arguments.length === 4) { + return new WrappedRange(sc, so, ec, eo); + } else if (arguments.length === 2) { + // collapsed + ec = sc; + eo = so; + return new WrappedRange(sc, so, ec, eo); + } else { + var wrappedRange = this.createFromSelection(); + + if (!wrappedRange && arguments.length === 1) { + var bodyElement = arguments[0]; + + if (dom.isEditable(bodyElement)) { + bodyElement = bodyElement.lastChild; + } + + return this.createFromBodyElement(bodyElement, dom.emptyPara === arguments[0].innerHTML); + } + + return wrappedRange; + } + }, + createFromBodyElement: function createFromBodyElement(bodyElement) { + var isCollapseToStart = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + var wrappedRange = this.createFromNode(bodyElement); + return wrappedRange.collapse(isCollapseToStart); + }, + createFromSelection: function createFromSelection() { + var sc, so, ec, eo; + + if (env.isW3CRangeSupport) { + var selection = document.getSelection(); + + if (!selection || selection.rangeCount === 0) { + return null; + } else if (dom.isBody(selection.anchorNode)) { + // Firefox: returns entire body as range on initialization. + // We won't never need it. + return null; + } + + var nativeRng = selection.getRangeAt(0); + sc = nativeRng.startContainer; + so = nativeRng.startOffset; + ec = nativeRng.endContainer; + eo = nativeRng.endOffset; + } else { + // IE8: TextRange + var textRange = document.selection.createRange(); + var textRangeEnd = textRange.duplicate(); + textRangeEnd.collapse(false); + var textRangeStart = textRange; + textRangeStart.collapse(true); + var startPoint = textRangeToPoint(textRangeStart, true); + var endPoint = textRangeToPoint(textRangeEnd, false); // same visible point case: range was collapsed. + + if (dom.isText(startPoint.node) && dom.isLeftEdgePoint(startPoint) && dom.isTextNode(endPoint.node) && dom.isRightEdgePoint(endPoint) && endPoint.node.nextSibling === startPoint.node) { + startPoint = endPoint; + } + + sc = startPoint.cont; + so = startPoint.offset; + ec = endPoint.cont; + eo = endPoint.offset; + } + + return new WrappedRange(sc, so, ec, eo); + }, + + /** + * @method + * + * create WrappedRange from node + * + * @param {Node} node + * @return {WrappedRange} + */ + createFromNode: function createFromNode(node) { + var sc = node; + var so = 0; + var ec = node; + var eo = dom.nodeLength(ec); // browsers can't target a picture or void node + + if (dom.isVoid(sc)) { + so = dom.listPrev(sc).length - 1; + sc = sc.parentNode; + } + + if (dom.isBR(ec)) { + eo = dom.listPrev(ec).length - 1; + ec = ec.parentNode; + } else if (dom.isVoid(ec)) { + eo = dom.listPrev(ec).length; + ec = ec.parentNode; + } + + return this.create(sc, so, ec, eo); + }, + + /** + * create WrappedRange from node after position + * + * @param {Node} node + * @return {WrappedRange} + */ + createFromNodeBefore: function createFromNodeBefore(node) { + return this.createFromNode(node).collapse(true); + }, + + /** + * create WrappedRange from node after position + * + * @param {Node} node + * @return {WrappedRange} + */ + createFromNodeAfter: function createFromNodeAfter(node) { + return this.createFromNode(node).collapse(); + }, + + /** + * @method + * + * create WrappedRange from bookmark + * + * @param {Node} editable + * @param {Object} bookmark + * @return {WrappedRange} + */ + createFromBookmark: function createFromBookmark(editable, bookmark) { + var sc = dom.fromOffsetPath(editable, bookmark.s.path); + var so = bookmark.s.offset; + var ec = dom.fromOffsetPath(editable, bookmark.e.path); + var eo = bookmark.e.offset; + return new WrappedRange(sc, so, ec, eo); + }, + + /** + * @method + * + * create WrappedRange from paraBookmark + * + * @param {Object} bookmark + * @param {Node[]} paras + * @return {WrappedRange} + */ + createFromParaBookmark: function createFromParaBookmark(bookmark, paras) { + var so = bookmark.s.offset; + var eo = bookmark.e.offset; + var sc = dom.fromOffsetPath(lists.head(paras), bookmark.s.path); + var ec = dom.fromOffsetPath(lists.last(paras), bookmark.e.path); + return new WrappedRange(sc, so, ec, eo); + } +}); +;// CONCATENATED MODULE: ./src/js/core/key.js + + +var KEY_MAP = { + 'BACKSPACE': 8, + 'TAB': 9, + 'ENTER': 13, + 'ESCAPE': 27, + 'SPACE': 32, + 'DELETE': 46, + // Arrow + 'LEFT': 37, + 'UP': 38, + 'RIGHT': 39, + 'DOWN': 40, + // Number: 0-9 + 'NUM0': 48, + 'NUM1': 49, + 'NUM2': 50, + 'NUM3': 51, + 'NUM4': 52, + 'NUM5': 53, + 'NUM6': 54, + 'NUM7': 55, + 'NUM8': 56, + // Alphabet: a-z + 'B': 66, + 'E': 69, + 'I': 73, + 'J': 74, + 'K': 75, + 'L': 76, + 'R': 82, + 'S': 83, + 'U': 85, + 'V': 86, + 'Y': 89, + 'Z': 90, + 'SLASH': 191, + 'LEFTBRACKET': 219, + 'BACKSLASH': 220, + 'RIGHTBRACKET': 221, + // Navigation + 'HOME': 36, + 'END': 35, + 'PAGEUP': 33, + 'PAGEDOWN': 34 +}; +/** + * @class core.key + * + * Object for keycodes. + * + * @singleton + * @alternateClassName key + */ + +/* harmony default export */ const key = ({ + /** + * @method isEdit + * + * @param {Number} keyCode + * @return {Boolean} + */ + isEdit: function isEdit(keyCode) { + return lists.contains([KEY_MAP.BACKSPACE, KEY_MAP.TAB, KEY_MAP.ENTER, KEY_MAP.SPACE, KEY_MAP.DELETE], keyCode); + }, + + /** + * @method isMove + * + * @param {Number} keyCode + * @return {Boolean} + */ + isMove: function isMove(keyCode) { + return lists.contains([KEY_MAP.LEFT, KEY_MAP.UP, KEY_MAP.RIGHT, KEY_MAP.DOWN], keyCode); + }, + + /** + * @method isNavigation + * + * @param {Number} keyCode + * @return {Boolean} + */ + isNavigation: function isNavigation(keyCode) { + return lists.contains([KEY_MAP.HOME, KEY_MAP.END, KEY_MAP.PAGEUP, KEY_MAP.PAGEDOWN], keyCode); + }, + + /** + * @property {Object} nameFromCode + * @property {String} nameFromCode.8 "BACKSPACE" + */ + nameFromCode: func.invertObject(KEY_MAP), + code: KEY_MAP +}); +;// CONCATENATED MODULE: ./src/js/core/async.js + +/** + * @method readFileAsDataURL + * + * read contents of file as representing URL + * + * @param {File} file + * @return {Promise} - then: dataUrl + */ + +function readFileAsDataURL(file) { + return external_jQuery_default().Deferred(function (deferred) { + external_jQuery_default().extend(new FileReader(), { + onload: function onload(e) { + var dataURL = e.target.result; + deferred.resolve(dataURL); + }, + onerror: function onerror(err) { + deferred.reject(err); + } + }).readAsDataURL(file); + }).promise(); +} +/** + * @method createImage + * + * create `- ,
- )
+
+ dom.appendChildNodes(listNode, paras);
+
+ if (nextList) {
+ dom.appendChildNodes(listNode, lists.from(nextList.childNodes));
+ dom.remove(nextList);
+ }
+
+ return paras;
+ }
+ /**
+ * @method releaseList
+ *
+ * @param {Array[]} clustereds
+ * @param {Boolean} isEscapseToBody
+ * @return {Node[]}
+ */
+
+ }, {
+ key: "releaseList",
+ value: function releaseList(clustereds, isEscapseToBody) {
+ var _this4 = this;
+
+ var releasedParas = [];
+ external_jQuery_default().each(clustereds, function (idx, paras) {
+ var head = lists.head(paras);
+ var last = lists.last(paras);
+ var headList = isEscapseToBody ? dom.lastAncestor(head, dom.isList) : head.parentNode;
+ var parentItem = headList.parentNode;
+
+ if (headList.parentNode.nodeName === 'LI') {
+ paras.map(function (para) {
+ var newList = _this4.findNextSiblings(para);
+
+ if (parentItem.nextSibling) {
+ parentItem.parentNode.insertBefore(para, parentItem.nextSibling);
+ } else {
+ parentItem.parentNode.appendChild(para);
+ }
+
+ if (newList.length) {
+ _this4.wrapList(newList, headList.nodeName);
+
+ para.appendChild(newList[0].parentNode);
+ }
+ });
+
+ if (headList.children.length === 0) {
+ parentItem.removeChild(headList);
+ }
+
+ if (parentItem.childNodes.length === 0) {
+ parentItem.parentNode.removeChild(parentItem);
+ }
+ } else {
+ var lastList = headList.childNodes.length > 1 ? dom.splitTree(headList, {
+ node: last.parentNode,
+ offset: dom.position(last) + 1
+ }, {
+ isSkipPaddingBlankHTML: true
+ }) : null;
+ var middleList = dom.splitTree(headList, {
+ node: head.parentNode,
+ offset: dom.position(head)
+ }, {
+ isSkipPaddingBlankHTML: true
+ });
+ paras = isEscapseToBody ? dom.listDescendant(middleList, dom.isLi) : lists.from(middleList.childNodes).filter(dom.isLi); // LI to P
+
+ if (isEscapseToBody || !dom.isList(headList.parentNode)) {
+ paras = paras.map(function (para) {
+ return dom.replace(para, 'P');
+ });
+ }
+
+ external_jQuery_default().each(lists.from(paras).reverse(), function (idx, para) {
+ dom.insertAfter(para, headList);
+ }); // remove empty lists
+
+ var rootLists = lists.compact([headList, middleList, lastList]);
+ external_jQuery_default().each(rootLists, function (idx, rootList) {
+ var listNodes = [rootList].concat(dom.listDescendant(rootList, dom.isList));
+ external_jQuery_default().each(listNodes.reverse(), function (idx, listNode) {
+ if (!dom.nodeLength(listNode)) {
+ dom.remove(listNode, true);
+ }
+ });
+ });
+ }
+
+ releasedParas = releasedParas.concat(paras);
+ });
+ return releasedParas;
+ }
+ /**
+ * @method appendToPrevious
+ *
+ * Appends list to previous list item, if
+ * none exist it wraps the list in a new list item.
+ *
+ * @param {HTMLNode} ListItem
+ * @return {HTMLNode}
+ */
+
+ }, {
+ key: "appendToPrevious",
+ value: function appendToPrevious(node) {
+ return node.previousSibling ? dom.appendChildNodes(node.previousSibling, [node]) : this.wrapList([node], 'LI');
+ }
+ /**
+ * @method findList
+ *
+ * Finds an existing list in list item
+ *
+ * @param {HTMLNode} ListItem
+ * @return {Array[]}
+ */
+
+ }, {
+ key: "findList",
+ value: function findList(node) {
+ return node ? lists.find(node.children, function (child) {
+ return ['OL', 'UL'].indexOf(child.nodeName) > -1;
+ }) : null;
+ }
+ /**
+ * @method findNextSiblings
+ *
+ * Finds all list item siblings that follow it
+ *
+ * @param {HTMLNode} ListItem
+ * @return {HTMLNode}
+ */
+
+ }, {
+ key: "findNextSiblings",
+ value: function findNextSiblings(node) {
+ var siblings = [];
+
+ while (node.nextSibling) {
+ siblings.push(node.nextSibling);
+ node = node.nextSibling;
+ }
+
+ return siblings;
+ }
+ }]);
+
+ return Bullet;
+}();
+
+
+;// CONCATENATED MODULE: ./src/js/editing/Typing.js
+function Typing_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function Typing_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function Typing_createClass(Constructor, protoProps, staticProps) { if (protoProps) Typing_defineProperties(Constructor.prototype, protoProps); if (staticProps) Typing_defineProperties(Constructor, staticProps); return Constructor; }
+
+
+
+
+
+/**
+ * @class editing.Typing
+ *
+ * Typing
+ *
+ */
+
+var Typing = /*#__PURE__*/function () {
+ function Typing(context) {
+ Typing_classCallCheck(this, Typing);
+
+ // a Bullet instance to toggle lists off
+ this.bullet = new Bullet();
+ this.options = context.options;
+ }
+ /**
+ * insert tab
+ *
+ * @param {WrappedRange} rng
+ * @param {Number} tabsize
+ */
+
+
+ Typing_createClass(Typing, [{
+ key: "insertTab",
+ value: function insertTab(rng, tabsize) {
+ var tab = dom.createText(new Array(tabsize + 1).join(dom.NBSP_CHAR));
+ rng = rng.deleteContents();
+ rng.insertNode(tab, true);
+ rng = range.create(tab, tabsize);
+ rng.select();
+ }
+ /**
+ * insert paragraph
+ *
+ * @param {jQuery} $editable
+ * @param {WrappedRange} rng Can be used in unit tests to "mock" the range
+ *
+ * blockquoteBreakingLevel
+ * 0 - No break, the new paragraph remains inside the quote
+ * 1 - Break the first blockquote in the ancestors list
+ * 2 - Break all blockquotes, so that the new paragraph is not quoted (this is the default)
+ */
+
+ }, {
+ key: "insertParagraph",
+ value: function insertParagraph(editable, rng) {
+ rng = rng || range.create(editable); // deleteContents on range.
+
+ rng = rng.deleteContents(); // Wrap range if it needs to be wrapped by paragraph
+
+ rng = rng.wrapBodyInlineWithPara(); // finding paragraph
+
+ var splitRoot = dom.ancestor(rng.sc, dom.isPara);
+ var nextPara; // on paragraph: split paragraph
+
+ if (splitRoot) {
+ // if it is an empty line with li
+ if (dom.isLi(splitRoot) && (dom.isEmpty(splitRoot) || dom.deepestChildIsEmpty(splitRoot))) {
+ // toggle UL/OL and escape
+ this.bullet.toggleList(splitRoot.parentNode.nodeName);
+ return;
+ } else {
+ var blockquote = null;
+
+ if (this.options.blockquoteBreakingLevel === 1) {
+ blockquote = dom.ancestor(splitRoot, dom.isBlockquote);
+ } else if (this.options.blockquoteBreakingLevel === 2) {
+ blockquote = dom.lastAncestor(splitRoot, dom.isBlockquote);
+ }
+
+ if (blockquote) {
+ // We're inside a blockquote and options ask us to break it
+ nextPara = external_jQuery_default()(dom.emptyPara)[0]; // If the split is right before a
, remove it so that there's no "empty line" + // after the split in the new blockquote created + + if (dom.isRightEdgePoint(rng.getStartPoint()) && dom.isBR(rng.sc.nextSibling)) { + external_jQuery_default()(rng.sc.nextSibling).remove(); + } + + var split = dom.splitTree(blockquote, rng.getStartPoint(), { + isDiscardEmptySplits: true + }); + + if (split) { + split.parentNode.insertBefore(nextPara, split); + } else { + dom.insertAfter(nextPara, blockquote); // There's no split if we were at the end of the blockquote + } + } else { + nextPara = dom.splitTree(splitRoot, rng.getStartPoint()); // not a blockquote, just insert the paragraph + + var emptyAnchors = dom.listDescendant(splitRoot, dom.isEmptyAnchor); + emptyAnchors = emptyAnchors.concat(dom.listDescendant(nextPara, dom.isEmptyAnchor)); + external_jQuery_default().each(emptyAnchors, function (idx, anchor) { + dom.remove(anchor); + }); // replace empty heading, pre or custom-made styleTag with P tag + + if ((dom.isHeading(nextPara) || dom.isPre(nextPara) || dom.isCustomStyleTag(nextPara)) && dom.isEmpty(nextPara)) { + nextPara = dom.replace(nextPara, 'p'); + } + } + } // no paragraph: insert empty paragraph + + } else { + var next = rng.sc.childNodes[rng.so]; + nextPara = external_jQuery_default()(dom.emptyPara)[0]; + + if (next) { + rng.sc.insertBefore(nextPara, next); + } else { + rng.sc.appendChild(nextPara); + } + } + + range.create(nextPara, 0).normalize().select().scrollIntoView(editable); + } + }]); + + return Typing; +}(); + + +;// CONCATENATED MODULE: ./src/js/editing/Table.js +function Table_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function Table_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function Table_createClass(Constructor, protoProps, staticProps) { if (protoProps) Table_defineProperties(Constructor.prototype, protoProps); if (staticProps) Table_defineProperties(Constructor, staticProps); return Constructor; } + + + + + +/** + * @class Create a virtual table to create what actions to do in change. + * @param {object} startPoint Cell selected to apply change. + * @param {enum} where Where change will be applied Row or Col. Use enum: TableResultAction.where + * @param {enum} action Action to be applied. Use enum: TableResultAction.requestAction + * @param {object} domTable Dom element of table to make changes. + */ + +var TableResultAction = function TableResultAction(startPoint, where, action, domTable) { + var _startPoint = { + 'colPos': 0, + 'rowPos': 0 + }; + var _virtualTable = []; + var _actionCellList = []; /// /////////////////////////////////////////// + // Private functions + /// /////////////////////////////////////////// + + /** + * Set the startPoint of action. + */ + + function setStartPoint() { + if (!startPoint || !startPoint.tagName || startPoint.tagName.toLowerCase() !== 'td' && startPoint.tagName.toLowerCase() !== 'th') { + // Impossible to identify start Cell point + return; + } + + _startPoint.colPos = startPoint.cellIndex; + + if (!startPoint.parentElement || !startPoint.parentElement.tagName || startPoint.parentElement.tagName.toLowerCase() !== 'tr') { + // Impossible to identify start Row point + return; + } + + _startPoint.rowPos = startPoint.parentElement.rowIndex; + } + /** + * Define virtual table position info object. + * + * @param {int} rowIndex Index position in line of virtual table. + * @param {int} cellIndex Index position in column of virtual table. + * @param {object} baseRow Row affected by this position. + * @param {object} baseCell Cell affected by this position. + * @param {bool} isSpan Inform if it is an span cell/row. + */ + + + function setVirtualTablePosition(rowIndex, cellIndex, baseRow, baseCell, isRowSpan, isColSpan, isVirtualCell) { + var objPosition = { + 'baseRow': baseRow, + 'baseCell': baseCell, + 'isRowSpan': isRowSpan, + 'isColSpan': isColSpan, + 'isVirtual': isVirtualCell + }; + + if (!_virtualTable[rowIndex]) { + _virtualTable[rowIndex] = []; + } + + _virtualTable[rowIndex][cellIndex] = objPosition; + } + /** + * Create action cell object. + * + * @param {object} virtualTableCellObj Object of specific position on virtual table. + * @param {enum} resultAction Action to be applied in that item. + */ + + + function getActionCell(virtualTableCellObj, resultAction, virtualRowPosition, virtualColPosition) { + return { + 'baseCell': virtualTableCellObj.baseCell, + 'action': resultAction, + 'virtualTable': { + 'rowIndex': virtualRowPosition, + 'cellIndex': virtualColPosition + } + }; + } + /** + * Recover free index of row to append Cell. + * + * @param {int} rowIndex Index of row to find free space. + * @param {int} cellIndex Index of cell to find free space in table. + */ + + + function recoverCellIndex(rowIndex, cellIndex) { + if (!_virtualTable[rowIndex]) { + return cellIndex; + } + + if (!_virtualTable[rowIndex][cellIndex]) { + return cellIndex; + } + + var newCellIndex = cellIndex; + + while (_virtualTable[rowIndex][newCellIndex]) { + newCellIndex++; + + if (!_virtualTable[rowIndex][newCellIndex]) { + return newCellIndex; + } + } + } + /** + * Recover info about row and cell and add information to virtual table. + * + * @param {object} row Row to recover information. + * @param {object} cell Cell to recover information. + */ + + + function addCellInfoToVirtual(row, cell) { + var cellIndex = recoverCellIndex(row.rowIndex, cell.cellIndex); + var cellHasColspan = cell.colSpan > 1; + var cellHasRowspan = cell.rowSpan > 1; + var isThisSelectedCell = row.rowIndex === _startPoint.rowPos && cell.cellIndex === _startPoint.colPos; + setVirtualTablePosition(row.rowIndex, cellIndex, row, cell, cellHasRowspan, cellHasColspan, false); // Add span rows to virtual Table. + + var rowspanNumber = cell.attributes.rowSpan ? parseInt(cell.attributes.rowSpan.value, 10) : 0; + + if (rowspanNumber > 1) { + for (var rp = 1; rp < rowspanNumber; rp++) { + var rowspanIndex = row.rowIndex + rp; + adjustStartPoint(rowspanIndex, cellIndex, cell, isThisSelectedCell); + setVirtualTablePosition(rowspanIndex, cellIndex, row, cell, true, cellHasColspan, true); + } + } // Add span cols to virtual table. + + + var colspanNumber = cell.attributes.colSpan ? parseInt(cell.attributes.colSpan.value, 10) : 0; + + if (colspanNumber > 1) { + for (var cp = 1; cp < colspanNumber; cp++) { + var cellspanIndex = recoverCellIndex(row.rowIndex, cellIndex + cp); + adjustStartPoint(row.rowIndex, cellspanIndex, cell, isThisSelectedCell); + setVirtualTablePosition(row.rowIndex, cellspanIndex, row, cell, cellHasRowspan, true, true); + } + } + } + /** + * Process validation and adjust of start point if needed + * + * @param {int} rowIndex + * @param {int} cellIndex + * @param {object} cell + * @param {bool} isSelectedCell + */ + + + function adjustStartPoint(rowIndex, cellIndex, cell, isSelectedCell) { + if (rowIndex === _startPoint.rowPos && _startPoint.colPos >= cell.cellIndex && cell.cellIndex <= cellIndex && !isSelectedCell) { + _startPoint.colPos++; + } + } + /** + * Create virtual table of cells with all cells, including span cells. + */ + + + function createVirtualTable() { + var rows = domTable.rows; + + for (var rowIndex = 0; rowIndex < rows.length; rowIndex++) { + var cells = rows[rowIndex].cells; + + for (var cellIndex = 0; cellIndex < cells.length; cellIndex++) { + addCellInfoToVirtual(rows[rowIndex], cells[cellIndex]); + } + } + } + /** + * Get action to be applied on the cell. + * + * @param {object} cell virtual table cell to apply action + */ + + + function getDeleteResultActionToCell(cell) { + switch (where) { + case TableResultAction.where.Column: + if (cell.isColSpan) { + return TableResultAction.resultAction.SubtractSpanCount; + } + + break; + + case TableResultAction.where.Row: + if (!cell.isVirtual && cell.isRowSpan) { + return TableResultAction.resultAction.AddCell; + } else if (cell.isRowSpan) { + return TableResultAction.resultAction.SubtractSpanCount; + } + + break; + } + + return TableResultAction.resultAction.RemoveCell; + } + /** + * Get action to be applied on the cell. + * + * @param {object} cell virtual table cell to apply action + */ + + + function getAddResultActionToCell(cell) { + switch (where) { + case TableResultAction.where.Column: + if (cell.isColSpan) { + return TableResultAction.resultAction.SumSpanCount; + } else if (cell.isRowSpan && cell.isVirtual) { + return TableResultAction.resultAction.Ignore; + } + + break; + + case TableResultAction.where.Row: + if (cell.isRowSpan) { + return TableResultAction.resultAction.SumSpanCount; + } else if (cell.isColSpan && cell.isVirtual) { + return TableResultAction.resultAction.Ignore; + } + + break; + } + + return TableResultAction.resultAction.AddCell; + } + + function init() { + setStartPoint(); + createVirtualTable(); + } /// /////////////////////////////////////////// + // Public functions + /// /////////////////////////////////////////// + + /** + * Recover array os what to do in table. + */ + + + this.getActionList = function () { + var fixedRow = where === TableResultAction.where.Row ? _startPoint.rowPos : -1; + var fixedCol = where === TableResultAction.where.Column ? _startPoint.colPos : -1; + var actualPosition = 0; + var canContinue = true; + + while (canContinue) { + var rowPosition = fixedRow >= 0 ? fixedRow : actualPosition; + var colPosition = fixedCol >= 0 ? fixedCol : actualPosition; + var row = _virtualTable[rowPosition]; + + if (!row) { + canContinue = false; + return _actionCellList; + } + + var cell = row[colPosition]; + + if (!cell) { + canContinue = false; + return _actionCellList; + } // Define action to be applied in this cell + + + var resultAction = TableResultAction.resultAction.Ignore; + + switch (action) { + case TableResultAction.requestAction.Add: + resultAction = getAddResultActionToCell(cell); + break; + + case TableResultAction.requestAction.Delete: + resultAction = getDeleteResultActionToCell(cell); + break; + } + + _actionCellList.push(getActionCell(cell, resultAction, rowPosition, colPosition)); + + actualPosition++; + } + + return _actionCellList; + }; + + init(); +}; +/** +* +* Where action occours enum. +*/ + + +TableResultAction.where = { + 'Row': 0, + 'Column': 1 +}; +/** +* +* Requested action to apply enum. +*/ + +TableResultAction.requestAction = { + 'Add': 0, + 'Delete': 1 +}; +/** +* +* Result action to be executed enum. +*/ + +TableResultAction.resultAction = { + 'Ignore': 0, + 'SubtractSpanCount': 1, + 'RemoveCell': 2, + 'AddCell': 3, + 'SumSpanCount': 4 +}; +/** + * + * @class editing.Table + * + * Table + * + */ + +var Table = /*#__PURE__*/function () { + function Table() { + Table_classCallCheck(this, Table); + } + + Table_createClass(Table, [{ + key: "tab", + value: + /** + * handle tab key + * + * @param {WrappedRange} rng + * @param {Boolean} isShift + */ + function tab(rng, isShift) { + var cell = dom.ancestor(rng.commonAncestor(), dom.isCell); + var table = dom.ancestor(cell, dom.isTable); + var cells = dom.listDescendant(table, dom.isCell); + var nextCell = lists[isShift ? 'prev' : 'next'](cells, cell); + + if (nextCell) { + range.create(nextCell, 0).select(); + } + } + /** + * Add a new row + * + * @param {WrappedRange} rng + * @param {String} position (top/bottom) + * @return {Node} + */ + + }, { + key: "addRow", + value: function addRow(rng, position) { + var cell = dom.ancestor(rng.commonAncestor(), dom.isCell); + var currentTr = external_jQuery_default()(cell).closest('tr'); + var trAttributes = this.recoverAttributes(currentTr); + var html = external_jQuery_default()('
' + this.lang.output.noSelection + '
');
+ setTimeout(function () {
+ external_jQuery_default()('#note-status-output-' + noteStatusOutput).remove();
+ }, 5000);
+ }
+ }
+ /**
+ * unlink
+ *
+ * @type command
+ */
+
+ }, {
+ key: "unlink",
+ value: function unlink() {
+ var rng = this.getLastRange();
+
+ if (rng.isOnAnchor()) {
+ var anchor = dom.ancestor(rng.sc, dom.isAnchor);
+ rng = range.createFromNode(anchor);
+ rng.select();
+ this.setLastRange();
+ this.beforeCommand();
+ document.execCommand('unlink');
+ this.afterCommand();
+ }
+ }
+ /**
+ * returns link info
+ *
+ * @return {Object}
+ * @return {WrappedRange} return.range
+ * @return {String} return.text
+ * @return {Boolean} [return.isNewWindow=true]
+ * @return {String} [return.url=""]
+ */
+
+ }, {
+ key: "getLinkInfo",
+ value: function getLinkInfo() {
+ var rng = this.getLastRange().expand(dom.isAnchor); // Get the first anchor on range(for edit).
+
+ var $anchor = external_jQuery_default()(lists.head(rng.nodes(dom.isAnchor)));
+ var linkInfo = {
+ range: rng,
+ text: rng.toString(),
+ url: $anchor.length ? $anchor.attr('href') : ''
+ }; // When anchor exists,
+
+ if ($anchor.length) {
+ // Set isNewWindow by checking its target.
+ linkInfo.isNewWindow = $anchor.attr('target') === '_blank';
+ }
+
+ return linkInfo;
+ }
+ }, {
+ key: "addRow",
+ value: function addRow(position) {
+ var rng = this.getLastRange(this.$editable);
+
+ if (rng.isCollapsed() && rng.isOnCell()) {
+ this.beforeCommand();
+ this.table.addRow(rng, position);
+ this.afterCommand();
+ }
+ }
+ }, {
+ key: "addCol",
+ value: function addCol(position) {
+ var rng = this.getLastRange(this.$editable);
+
+ if (rng.isCollapsed() && rng.isOnCell()) {
+ this.beforeCommand();
+ this.table.addCol(rng, position);
+ this.afterCommand();
+ }
+ }
+ }, {
+ key: "deleteRow",
+ value: function deleteRow() {
+ var rng = this.getLastRange(this.$editable);
+
+ if (rng.isCollapsed() && rng.isOnCell()) {
+ this.beforeCommand();
+ this.table.deleteRow(rng);
+ this.afterCommand();
+ }
+ }
+ }, {
+ key: "deleteCol",
+ value: function deleteCol() {
+ var rng = this.getLastRange(this.$editable);
+
+ if (rng.isCollapsed() && rng.isOnCell()) {
+ this.beforeCommand();
+ this.table.deleteCol(rng);
+ this.afterCommand();
+ }
+ }
+ }, {
+ key: "deleteTable",
+ value: function deleteTable() {
+ var rng = this.getLastRange(this.$editable);
+
+ if (rng.isCollapsed() && rng.isOnCell()) {
+ this.beforeCommand();
+ this.table.deleteTable(rng);
+ this.afterCommand();
+ }
+ }
+ /**
+ * @param {Position} pos
+ * @param {jQuery} $target - target element
+ * @param {Boolean} [bKeepRatio] - keep ratio
+ */
+
+ }, {
+ key: "resizeTo",
+ value: function resizeTo(pos, $target, bKeepRatio) {
+ var imageSize;
+
+ if (bKeepRatio) {
+ var newRatio = pos.y / pos.x;
+ var ratio = $target.data('ratio');
+ imageSize = {
+ width: ratio > newRatio ? pos.x : pos.y / ratio,
+ height: ratio > newRatio ? pos.x * ratio : pos.y
+ };
+ } else {
+ imageSize = {
+ width: pos.x,
+ height: pos.y
+ };
+ }
+
+ $target.css(imageSize);
+ }
+ /**
+ * returns whether editable area has focus or not.
+ */
+
+ }, {
+ key: "hasFocus",
+ value: function hasFocus() {
+ return this.$editable.is(':focus');
+ }
+ /**
+ * set focus
+ */
+
+ }, {
+ key: "focus",
+ value: function focus() {
+ // [workaround] Screen will move when page is scolled in IE.
+ // - do focus when not focused
+ if (!this.hasFocus()) {
+ this.$editable.focus();
+ }
+ }
+ /**
+ * returns whether contents is empty or not.
+ * @return {Boolean}
+ */
+
+ }, {
+ key: "isEmpty",
+ value: function isEmpty() {
+ return dom.isEmpty(this.$editable[0]) || dom.emptyPara === this.$editable.html();
+ }
+ /**
+ * Removes all contents and restores the editable instance to an _emptyPara_.
+ */
+
+ }, {
+ key: "empty",
+ value: function empty() {
+ this.context.invoke('code', dom.emptyPara);
+ }
+ /**
+ * normalize content
+ */
+
+ }, {
+ key: "normalizeContent",
+ value: function normalizeContent() {
+ this.$editable[0].normalize();
+ }
+ }]);
+
+ return Editor;
+}();
+
+
+;// CONCATENATED MODULE: ./src/js/module/Clipboard.js
+function Clipboard_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function Clipboard_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function Clipboard_createClass(Constructor, protoProps, staticProps) { if (protoProps) Clipboard_defineProperties(Constructor.prototype, protoProps); if (staticProps) Clipboard_defineProperties(Constructor, staticProps); return Constructor; }
+
+
+
+var Clipboard = /*#__PURE__*/function () {
+ function Clipboard(context) {
+ Clipboard_classCallCheck(this, Clipboard);
+
+ this.context = context;
+ this.$editable = context.layoutInfo.editable;
+ }
+
+ Clipboard_createClass(Clipboard, [{
+ key: "initialize",
+ value: function initialize() {
+ this.$editable.on('paste', this.pasteByEvent.bind(this));
+ }
+ /**
+ * paste by clipboard event
+ *
+ * @param {Event} event
+ */
+
+ }, {
+ key: "pasteByEvent",
+ value: function pasteByEvent(event) {
+ var _this = this;
+
+ var clipboardData = event.originalEvent.clipboardData;
+
+ if (clipboardData && clipboardData.items && clipboardData.items.length) {
+ var item = clipboardData.items.length > 1 ? clipboardData.items[1] : lists.head(clipboardData.items);
+
+ if (item.kind === 'file' && item.type.indexOf('image/') !== -1) {
+ // paste img file
+ this.context.invoke('editor.insertImagesOrCallback', [item.getAsFile()]);
+ event.preventDefault();
+ } else if (item.kind === 'string') {
+ // paste text with maxTextLength check
+ if (this.context.invoke('editor.isLimited', clipboardData.getData('Text').length)) {
+ event.preventDefault();
+ }
+ }
+ } else if (window.clipboardData) {
+ // for IE
+ var text = window.clipboardData.getData('text');
+
+ if (this.context.invoke('editor.isLimited', text.length)) {
+ event.preventDefault();
+ }
+ } // Call editor.afterCommand after proceeding default event handler
+
+
+ setTimeout(function () {
+ _this.context.invoke('editor.afterCommand');
+ }, 10);
+ }
+ }]);
+
+ return Clipboard;
+}();
+
+
+;// CONCATENATED MODULE: ./src/js/module/Dropzone.js
+function Dropzone_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function Dropzone_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function Dropzone_createClass(Constructor, protoProps, staticProps) { if (protoProps) Dropzone_defineProperties(Constructor.prototype, protoProps); if (staticProps) Dropzone_defineProperties(Constructor, staticProps); return Constructor; }
+
+
+
+var Dropzone = /*#__PURE__*/function () {
+ function Dropzone(context) {
+ Dropzone_classCallCheck(this, Dropzone);
+
+ this.context = context;
+ this.$eventListener = external_jQuery_default()(document);
+ this.$editor = context.layoutInfo.editor;
+ this.$editable = context.layoutInfo.editable;
+ this.options = context.options;
+ this.lang = this.options.langInfo;
+ this.documentEventHandlers = {};
+ this.$dropzone = external_jQuery_default()(['', '', '
'].join('')).prependTo(this.$editor);
+ }
+ /**
+ * attach Drag and Drop Events
+ */
+
+
+ Dropzone_createClass(Dropzone, [{
+ key: "initialize",
+ value: function initialize() {
+ if (this.options.disableDragAndDrop) {
+ // prevent default drop event
+ this.documentEventHandlers.onDrop = function (e) {
+ e.preventDefault();
+ }; // do not consider outside of dropzone
+
+
+ this.$eventListener = this.$dropzone;
+ this.$eventListener.on('drop', this.documentEventHandlers.onDrop);
+ } else {
+ this.attachDragAndDropEvent();
+ }
+ }
+ /**
+ * attach Drag and Drop Events
+ */
+
+ }, {
+ key: "attachDragAndDropEvent",
+ value: function attachDragAndDropEvent() {
+ var _this = this;
+
+ var collection = external_jQuery_default()();
+ var $dropzoneMessage = this.$dropzone.find('.note-dropzone-message');
+
+ this.documentEventHandlers.onDragenter = function (e) {
+ var isCodeview = _this.context.invoke('codeview.isActivated');
+
+ var hasEditorSize = _this.$editor.width() > 0 && _this.$editor.height() > 0;
+
+ if (!isCodeview && !collection.length && hasEditorSize) {
+ _this.$editor.addClass('dragover');
+
+ _this.$dropzone.width(_this.$editor.width());
+
+ _this.$dropzone.height(_this.$editor.height());
+
+ $dropzoneMessage.text(_this.lang.image.dragImageHere);
+ }
+
+ collection = collection.add(e.target);
+ };
+
+ this.documentEventHandlers.onDragleave = function (e) {
+ collection = collection.not(e.target); // If nodeName is BODY, then just make it over (fix for IE)
+
+ if (!collection.length || e.target.nodeName === 'BODY') {
+ collection = external_jQuery_default()();
+
+ _this.$editor.removeClass('dragover');
+ }
+ };
+
+ this.documentEventHandlers.onDrop = function () {
+ collection = external_jQuery_default()();
+
+ _this.$editor.removeClass('dragover');
+ }; // show dropzone on dragenter when dragging a object to document
+ // -but only if the editor is visible, i.e. has a positive width and height
+
+
+ this.$eventListener.on('dragenter', this.documentEventHandlers.onDragenter).on('dragleave', this.documentEventHandlers.onDragleave).on('drop', this.documentEventHandlers.onDrop); // change dropzone's message on hover.
+
+ this.$dropzone.on('dragenter', function () {
+ _this.$dropzone.addClass('hover');
+
+ $dropzoneMessage.text(_this.lang.image.dropImage);
+ }).on('dragleave', function () {
+ _this.$dropzone.removeClass('hover');
+
+ $dropzoneMessage.text(_this.lang.image.dragImageHere);
+ }); // attach dropImage
+
+ this.$dropzone.on('drop', function (event) {
+ var dataTransfer = event.originalEvent.dataTransfer; // stop the browser from opening the dropped content
+
+ event.preventDefault();
+
+ if (dataTransfer && dataTransfer.files && dataTransfer.files.length) {
+ _this.$editable.focus();
+
+ _this.context.invoke('editor.insertImagesOrCallback', dataTransfer.files);
+ } else {
+ external_jQuery_default().each(dataTransfer.types, function (idx, type) {
+ // skip moz-specific types
+ if (type.toLowerCase().indexOf('_moz_') > -1) {
+ return;
+ }
+
+ var content = dataTransfer.getData(type);
+
+ if (type.toLowerCase().indexOf('text') > -1) {
+ _this.context.invoke('editor.pasteHTML', content);
+ } else {
+ external_jQuery_default()(content).each(function (idx, item) {
+ _this.context.invoke('editor.insertNode', item);
+ });
+ }
+ });
+ }
+ }).on('dragover', false); // prevent default dragover event
+ }
+ }, {
+ key: "destroy",
+ value: function destroy() {
+ var _this2 = this;
+
+ Object.keys(this.documentEventHandlers).forEach(function (key) {
+ _this2.$eventListener.off(key.substr(2).toLowerCase(), _this2.documentEventHandlers[key]);
+ });
+ this.documentEventHandlers = {};
+ }
+ }]);
+
+ return Dropzone;
+}();
+
+
+;// CONCATENATED MODULE: ./src/js/module/Codeview.js
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function Codeview_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function Codeview_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function Codeview_createClass(Constructor, protoProps, staticProps) { if (protoProps) Codeview_defineProperties(Constructor.prototype, protoProps); if (staticProps) Codeview_defineProperties(Constructor, staticProps); return Constructor; }
+
+
+
+/**
+ * @class Codeview
+ */
+
+var CodeView = /*#__PURE__*/function () {
+ function CodeView(context) {
+ Codeview_classCallCheck(this, CodeView);
+
+ this.context = context;
+ this.$editor = context.layoutInfo.editor;
+ this.$editable = context.layoutInfo.editable;
+ this.$codable = context.layoutInfo.codable;
+ this.options = context.options;
+ this.CodeMirrorConstructor = window.CodeMirror;
+
+ if (this.options.codemirror.CodeMirrorConstructor) {
+ this.CodeMirrorConstructor = this.options.codemirror.CodeMirrorConstructor;
+ }
+ }
+
+ Codeview_createClass(CodeView, [{
+ key: "sync",
+ value: function sync(html) {
+ var isCodeview = this.isActivated();
+ var CodeMirror = this.CodeMirrorConstructor;
+
+ if (isCodeview) {
+ if (html) {
+ if (CodeMirror) {
+ this.$codable.data('cmEditor').getDoc().setValue(html);
+ } else {
+ this.$codable.val(html);
+ }
+ } else {
+ if (CodeMirror) {
+ this.$codable.data('cmEditor').save();
+ }
+ }
+ }
+ }
+ }, {
+ key: "initialize",
+ value: function initialize() {
+ var _this = this;
+
+ this.$codable.on('keyup', function (event) {
+ if (event.keyCode === key.code.ESCAPE) {
+ _this.deactivate();
+ }
+ });
+ }
+ /**
+ * @return {Boolean}
+ */
+
+ }, {
+ key: "isActivated",
+ value: function isActivated() {
+ return this.$editor.hasClass('codeview');
+ }
+ /**
+ * toggle codeview
+ */
+
+ }, {
+ key: "toggle",
+ value: function toggle() {
+ if (this.isActivated()) {
+ this.deactivate();
+ } else {
+ this.activate();
+ }
+
+ this.context.triggerEvent('codeview.toggled');
+ }
+ /**
+ * purify input value
+ * @param value
+ * @returns {*}
+ */
+
+ }, {
+ key: "purify",
+ value: function purify(value) {
+ if (this.options.codeviewFilter) {
+ // filter code view regex
+ value = value.replace(this.options.codeviewFilterRegex, ''); // allow specific iframe tag
+
+ if (this.options.codeviewIframeFilter) {
+ var whitelist = this.options.codeviewIframeWhitelistSrc.concat(this.options.codeviewIframeWhitelistSrcBase);
+ value = value.replace(/(', '
'].join('')).prependTo(this.$editingArea);
+ this.$handle.on('mousedown', function (event) {
+ if (dom.isControlSizing(event.target)) {
+ event.preventDefault();
+ event.stopPropagation();
+
+ var $target = _this2.$handle.find('.note-control-selection').data('target');
+
+ var posStart = $target.offset();
+
+ var scrollTop = _this2.$document.scrollTop();
+
+ var onMouseMove = function onMouseMove(event) {
+ _this2.context.invoke('editor.resizeTo', {
+ x: event.clientX - posStart.left,
+ y: event.clientY - (posStart.top - scrollTop)
+ }, $target, !event.shiftKey);
+
+ _this2.update($target[0], event);
+ };
+
+ _this2.$document.on('mousemove', onMouseMove).one('mouseup', function (e) {
+ e.preventDefault();
+
+ _this2.$document.off('mousemove', onMouseMove);
+
+ _this2.context.invoke('editor.afterCommand');
+ });
+
+ if (!$target.data('ratio')) {
+ // original ratio.
+ $target.data('ratio', $target.height() / $target.width());
+ }
+ }
+ }); // Listen for scrolling on the handle overlay.
+
+ this.$handle.on('wheel', function (e) {
+ e.preventDefault();
+
+ _this2.update();
+ });
+ }
+ }, {
+ key: "destroy",
+ value: function destroy() {
+ this.$handle.remove();
+ }
+ }, {
+ key: "update",
+ value: function update(target, event) {
+ if (this.context.isDisabled()) {
+ return false;
+ }
+
+ var isImage = dom.isImg(target);
+ var $selection = this.$handle.find('.note-control-selection');
+ this.context.invoke('imagePopover.update', target, event);
+
+ if (isImage) {
+ var $image = external_jQuery_default()(target);
+ var position = $image.position();
+ var pos = {
+ left: position.left + parseInt($image.css('marginLeft'), 10),
+ top: position.top + parseInt($image.css('marginTop'), 10)
+ }; // exclude margin
+
+ var imageSize = {
+ w: $image.outerWidth(false),
+ h: $image.outerHeight(false)
+ };
+ $selection.css({
+ display: 'block',
+ left: pos.left,
+ top: pos.top,
+ width: imageSize.w,
+ height: imageSize.h
+ }).data('target', $image); // save current image element.
+
+ var origImageObj = new Image();
+ origImageObj.src = $image.attr('src');
+ var sizingText = imageSize.w + 'x' + imageSize.h + ' (' + this.lang.image.original + ': ' + origImageObj.width + 'x' + origImageObj.height + ')';
+ $selection.find('.note-control-selection-info').text(sizingText);
+ this.context.invoke('editor.saveTarget', target);
+ } else {
+ this.hide();
+ }
+
+ return isImage;
+ }
+ /**
+ * hide
+ *
+ * @param {jQuery} $handle
+ */
+
+ }, {
+ key: "hide",
+ value: function hide() {
+ this.context.invoke('editor.clearTarget');
+ this.$handle.children().hide();
+ }
+ }]);
+
+ return Handle;
+}();
+
+
+;// CONCATENATED MODULE: ./src/js/module/AutoLink.js
+function AutoLink_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function AutoLink_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function AutoLink_createClass(Constructor, protoProps, staticProps) { if (protoProps) AutoLink_defineProperties(Constructor.prototype, protoProps); if (staticProps) AutoLink_defineProperties(Constructor, staticProps); return Constructor; }
+
+
+
+
+var defaultScheme = 'http://';
+var linkPattern = /^([A-Za-z][A-Za-z0-9+-.]*\:[\/]{2}|tel:|mailto:[A-Z0-9._%+-]+@|xmpp:[A-Z0-9._%+-]+@)?(www\.)?(.+)$/i;
+
+var AutoLink = /*#__PURE__*/function () {
+ function AutoLink(context) {
+ var _this = this;
+
+ AutoLink_classCallCheck(this, AutoLink);
+
+ this.context = context;
+ this.options = context.options;
+ this.events = {
+ 'summernote.keyup': function summernoteKeyup(we, e) {
+ if (!e.isDefaultPrevented()) {
+ _this.handleKeyup(e);
+ }
+ },
+ 'summernote.keydown': function summernoteKeydown(we, e) {
+ _this.handleKeydown(e);
+ }
+ };
+ }
+
+ AutoLink_createClass(AutoLink, [{
+ key: "initialize",
+ value: function initialize() {
+ this.lastWordRange = null;
+ }
+ }, {
+ key: "destroy",
+ value: function destroy() {
+ this.lastWordRange = null;
+ }
+ }, {
+ key: "replace",
+ value: function replace() {
+ if (!this.lastWordRange) {
+ return;
+ }
+
+ var keyword = this.lastWordRange.toString();
+ var match = keyword.match(linkPattern);
+
+ if (match && (match[1] || match[2])) {
+ var link = match[1] ? keyword : defaultScheme + keyword;
+ var urlText = this.options.showDomainOnlyForAutolink ? keyword.replace(/^(?:https?:\/\/)?(?:tel?:?)?(?:mailto?:?)?(?:xmpp?:?)?(?:www\.)?/i, '').split('/')[0] : keyword;
+ var node = external_jQuery_default()('').html(urlText).attr('href', link)[0];
+
+ if (this.context.options.linkTargetBlank) {
+ external_jQuery_default()(node).attr('target', '_blank');
+ }
+
+ this.lastWordRange.insertNode(node);
+ this.lastWordRange = null;
+ this.context.invoke('editor.focus');
+ }
+ }
+ }, {
+ key: "handleKeydown",
+ value: function handleKeydown(e) {
+ if (lists.contains([key.code.ENTER, key.code.SPACE], e.keyCode)) {
+ var wordRange = this.context.invoke('editor.createRange').getWordRange();
+ this.lastWordRange = wordRange;
+ }
+ }
+ }, {
+ key: "handleKeyup",
+ value: function handleKeyup(e) {
+ if (lists.contains([key.code.ENTER, key.code.SPACE], e.keyCode)) {
+ this.replace();
+ }
+ }
+ }]);
+
+ return AutoLink;
+}();
+
+
+;// CONCATENATED MODULE: ./src/js/module/AutoSync.js
+function AutoSync_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function AutoSync_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function AutoSync_createClass(Constructor, protoProps, staticProps) { if (protoProps) AutoSync_defineProperties(Constructor.prototype, protoProps); if (staticProps) AutoSync_defineProperties(Constructor, staticProps); return Constructor; }
+
+
+/**
+ * textarea auto sync.
+ */
+
+var AutoSync = /*#__PURE__*/function () {
+ function AutoSync(context) {
+ var _this = this;
+
+ AutoSync_classCallCheck(this, AutoSync);
+
+ this.$note = context.layoutInfo.note;
+ this.events = {
+ 'summernote.change': function summernoteChange() {
+ _this.$note.val(context.invoke('code'));
+ }
+ };
+ }
+
+ AutoSync_createClass(AutoSync, [{
+ key: "shouldInitialize",
+ value: function shouldInitialize() {
+ return dom.isTextarea(this.$note[0]);
+ }
+ }]);
+
+ return AutoSync;
+}();
+
+
+;// CONCATENATED MODULE: ./src/js/module/AutoReplace.js
+function AutoReplace_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function AutoReplace_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function AutoReplace_createClass(Constructor, protoProps, staticProps) { if (protoProps) AutoReplace_defineProperties(Constructor.prototype, protoProps); if (staticProps) AutoReplace_defineProperties(Constructor, staticProps); return Constructor; }
+
+
+
+
+
+var AutoReplace = /*#__PURE__*/function () {
+ function AutoReplace(context) {
+ var _this = this;
+
+ AutoReplace_classCallCheck(this, AutoReplace);
+
+ this.context = context;
+ this.options = context.options.replace || {};
+ this.keys = [key.code.ENTER, key.code.SPACE, key.code.PERIOD, key.code.COMMA, key.code.SEMICOLON, key.code.SLASH];
+ this.previousKeydownCode = null;
+ this.events = {
+ 'summernote.keyup': function summernoteKeyup(we, e) {
+ if (!e.isDefaultPrevented()) {
+ _this.handleKeyup(e);
+ }
+ },
+ 'summernote.keydown': function summernoteKeydown(we, e) {
+ _this.handleKeydown(e);
+ }
+ };
+ }
+
+ AutoReplace_createClass(AutoReplace, [{
+ key: "shouldInitialize",
+ value: function shouldInitialize() {
+ return !!this.options.match;
+ }
+ }, {
+ key: "initialize",
+ value: function initialize() {
+ this.lastWord = null;
+ }
+ }, {
+ key: "destroy",
+ value: function destroy() {
+ this.lastWord = null;
+ }
+ }, {
+ key: "replace",
+ value: function replace() {
+ if (!this.lastWord) {
+ return;
+ }
+
+ var self = this;
+ var keyword = this.lastWord.toString();
+ this.options.match(keyword, function (match) {
+ if (match) {
+ var node = '';
+
+ if (typeof match === 'string') {
+ node = dom.createText(match);
+ } else if (match instanceof jQuery) {
+ node = match[0];
+ } else if (match instanceof Node) {
+ node = match;
+ }
+
+ if (!node) return;
+ self.lastWord.insertNode(node);
+ self.lastWord = null;
+ self.context.invoke('editor.focus');
+ }
+ });
+ }
+ }, {
+ key: "handleKeydown",
+ value: function handleKeydown(e) {
+ // this forces it to remember the last whole word, even if multiple termination keys are pressed
+ // before the previous key is let go.
+ if (this.previousKeydownCode && lists.contains(this.keys, this.previousKeydownCode)) {
+ this.previousKeydownCode = e.keyCode;
+ return;
+ }
+
+ if (lists.contains(this.keys, e.keyCode)) {
+ var wordRange = this.context.invoke('editor.createRange').getWordRange();
+ this.lastWord = wordRange;
+ }
+
+ this.previousKeydownCode = e.keyCode;
+ }
+ }, {
+ key: "handleKeyup",
+ value: function handleKeyup(e) {
+ if (lists.contains(this.keys, e.keyCode)) {
+ this.replace();
+ }
+ }
+ }]);
+
+ return AutoReplace;
+}();
+
+
+;// CONCATENATED MODULE: ./src/js/module/Placeholder.js
+function Placeholder_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function Placeholder_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function Placeholder_createClass(Constructor, protoProps, staticProps) { if (protoProps) Placeholder_defineProperties(Constructor.prototype, protoProps); if (staticProps) Placeholder_defineProperties(Constructor, staticProps); return Constructor; }
+
+
+
+var Placeholder = /*#__PURE__*/function () {
+ function Placeholder(context) {
+ var _this = this;
+
+ Placeholder_classCallCheck(this, Placeholder);
+
+ this.context = context;
+ this.$editingArea = context.layoutInfo.editingArea;
+ this.options = context.options;
+
+ if (this.options.inheritPlaceholder === true) {
+ // get placeholder value from the original element
+ this.options.placeholder = this.context.$note.attr('placeholder') || this.options.placeholder;
+ }
+
+ this.events = {
+ 'summernote.init summernote.change': function summernoteInitSummernoteChange() {
+ _this.update();
+ },
+ 'summernote.codeview.toggled': function summernoteCodeviewToggled() {
+ _this.update();
+ }
+ };
+ }
+
+ Placeholder_createClass(Placeholder, [{
+ key: "shouldInitialize",
+ value: function shouldInitialize() {
+ return !!this.options.placeholder;
+ }
+ }, {
+ key: "initialize",
+ value: function initialize() {
+ var _this2 = this;
+
+ this.$placeholder = external_jQuery_default()('');
+ this.$placeholder.on('click', function () {
+ _this2.context.invoke('focus');
+ }).html(this.options.placeholder).prependTo(this.$editingArea);
+ this.update();
+ }
+ }, {
+ key: "destroy",
+ value: function destroy() {
+ this.$placeholder.remove();
+ }
+ }, {
+ key: "update",
+ value: function update() {
+ var isShow = !this.context.invoke('codeview.isActivated') && this.context.invoke('editor.isEmpty');
+ this.$placeholder.toggle(isShow);
+ }
+ }]);
+
+ return Placeholder;
+}();
+
+
+;// CONCATENATED MODULE: ./src/js/module/Buttons.js
+function Buttons_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function Buttons_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function Buttons_createClass(Constructor, protoProps, staticProps) { if (protoProps) Buttons_defineProperties(Constructor.prototype, protoProps); if (staticProps) Buttons_defineProperties(Constructor, staticProps); return Constructor; }
+
+
+
+
+
+
+var Buttons = /*#__PURE__*/function () {
+ function Buttons(context) {
+ Buttons_classCallCheck(this, Buttons);
+
+ this.ui = (external_jQuery_default()).summernote.ui;
+ this.context = context;
+ this.$toolbar = context.layoutInfo.toolbar;
+ this.options = context.options;
+ this.lang = this.options.langInfo;
+ this.invertedKeyMap = func.invertObject(this.options.keyMap[env.isMac ? 'mac' : 'pc']);
+ }
+
+ Buttons_createClass(Buttons, [{
+ key: "representShortcut",
+ value: function representShortcut(editorMethod) {
+ var shortcut = this.invertedKeyMap[editorMethod];
+
+ if (!this.options.shortcuts || !shortcut) {
+ return '';
+ }
+
+ if (env.isMac) {
+ shortcut = shortcut.replace('CMD', '⌘').replace('SHIFT', '⇧');
+ }
+
+ shortcut = shortcut.replace('BACKSLASH', '\\').replace('SLASH', '/').replace('LEFTBRACKET', '[').replace('RIGHTBRACKET', ']');
+ return ' (' + shortcut + ')';
+ }
+ }, {
+ key: "button",
+ value: function button(o) {
+ if (!this.options.tooltip && o.tooltip) {
+ delete o.tooltip;
+ }
+
+ o.container = this.options.container;
+ return this.ui.button(o);
+ }
+ }, {
+ key: "initialize",
+ value: function initialize() {
+ this.addToolbarButtons();
+ this.addImagePopoverButtons();
+ this.addLinkPopoverButtons();
+ this.addTablePopoverButtons();
+ this.fontInstalledMap = {};
+ }
+ }, {
+ key: "destroy",
+ value: function destroy() {
+ delete this.fontInstalledMap;
+ }
+ }, {
+ key: "isFontInstalled",
+ value: function isFontInstalled(name) {
+ if (!Object.prototype.hasOwnProperty.call(this.fontInstalledMap, name)) {
+ this.fontInstalledMap[name] = env.isFontInstalled(name) || lists.contains(this.options.fontNamesIgnoreCheck, name);
+ }
+
+ return this.fontInstalledMap[name];
+ }
+ }, {
+ key: "isFontDeservedToAdd",
+ value: function isFontDeservedToAdd(name) {
+ name = name.toLowerCase();
+ return name !== '' && this.isFontInstalled(name) && env.genericFontFamilies.indexOf(name) === -1;
+ }
+ }, {
+ key: "colorPalette",
+ value: function colorPalette(className, tooltip, backColor, foreColor) {
+ var _this = this;
+
+ return this.ui.buttonGroup({
+ className: 'note-color ' + className,
+ children: [this.button({
+ className: 'note-current-color-button',
+ contents: this.ui.icon(this.options.icons.font + ' note-recent-color'),
+ tooltip: tooltip,
+ click: function click(e) {
+ var $button = external_jQuery_default()(e.currentTarget);
+
+ if (backColor && foreColor) {
+ _this.context.invoke('editor.color', {
+ backColor: $button.attr('data-backColor'),
+ foreColor: $button.attr('data-foreColor')
+ });
+ } else if (backColor) {
+ _this.context.invoke('editor.color', {
+ backColor: $button.attr('data-backColor')
+ });
+ } else if (foreColor) {
+ _this.context.invoke('editor.color', {
+ foreColor: $button.attr('data-foreColor')
+ });
+ }
+ },
+ callback: function callback($button) {
+ var $recentColor = $button.find('.note-recent-color');
+
+ if (backColor) {
+ $recentColor.css('background-color', _this.options.colorButton.backColor);
+ $button.attr('data-backColor', _this.options.colorButton.backColor);
+ }
+
+ if (foreColor) {
+ $recentColor.css('color', _this.options.colorButton.foreColor);
+ $button.attr('data-foreColor', _this.options.colorButton.foreColor);
+ } else {
+ $recentColor.css('color', 'transparent');
+ }
+ }
+ }), this.button({
+ className: 'dropdown-toggle',
+ contents: this.ui.dropdownButtonContents('', this.options),
+ tooltip: this.lang.color.more,
+ data: {
+ toggle: 'dropdown'
+ }
+ }), this.ui.dropdown({
+ items: (backColor ? ['', '', '', '', '', '', this.options.disableResizeImage ? '' : '', '
', '', '
'].join('') : '') + (foreColor ? ['' + this.lang.color.background + '
', '', '', '
', '', '', '', '', '
', '', '', '
'].join('') : ''),
+ callback: function callback($dropdown) {
+ $dropdown.find('.note-holder').each(function (idx, item) {
+ var $holder = external_jQuery_default()(item);
+ $holder.append(_this.ui.palette({
+ colors: _this.options.colors,
+ colorsName: _this.options.colorsName,
+ eventName: $holder.data('event'),
+ container: _this.options.container,
+ tooltip: _this.options.tooltip
+ }).render());
+ });
+ /* TODO: do we have to record recent custom colors within cookies? */
+
+ var customColors = [['#FFFFFF', '#FFFFFF', '#FFFFFF', '#FFFFFF', '#FFFFFF', '#FFFFFF', '#FFFFFF', '#FFFFFF']];
+ $dropdown.find('.note-holder-custom').each(function (idx, item) {
+ var $holder = external_jQuery_default()(item);
+ $holder.append(_this.ui.palette({
+ colors: customColors,
+ colorsName: customColors,
+ eventName: $holder.data('event'),
+ container: _this.options.container,
+ tooltip: _this.options.tooltip
+ }).render());
+ });
+ $dropdown.find('input[type=color]').each(function (idx, item) {
+ external_jQuery_default()(item).change(function () {
+ var $chip = $dropdown.find('#' + external_jQuery_default()(this).data('event')).find('.note-color-btn').first();
+ var color = this.value.toUpperCase();
+ $chip.css('background-color', color).attr('aria-label', color).attr('data-value', color).attr('data-original-title', color);
+ $chip.click();
+ });
+ });
+ },
+ click: function click(event) {
+ event.stopPropagation();
+ var $parent = external_jQuery_default()('.' + className).find('.note-dropdown-menu');
+ var $button = external_jQuery_default()(event.target);
+ var eventName = $button.data('event');
+ var value = $button.attr('data-value');
+
+ if (eventName === 'openPalette') {
+ var $picker = $parent.find('#' + value);
+ var $palette = external_jQuery_default()($parent.find('#' + $picker.data('event')).find('.note-color-row')[0]); // Shift palette chips
+
+ var $chip = $palette.find('.note-color-btn').last().detach(); // Set chip attributes
+
+ var color = $picker.val();
+ $chip.css('background-color', color).attr('aria-label', color).attr('data-value', color).attr('data-original-title', color);
+ $palette.prepend($chip);
+ $picker.click();
+ } else {
+ if (lists.contains(['backColor', 'foreColor'], eventName)) {
+ var key = eventName === 'backColor' ? 'background-color' : 'color';
+ var $color = $button.closest('.note-color').find('.note-recent-color');
+ var $currentButton = $button.closest('.note-color').find('.note-current-color-button');
+ $color.css(key, value);
+ $currentButton.attr('data-' + eventName, value);
+ }
+
+ _this.context.invoke('editor.' + eventName, value);
+ }
+ }
+ })]
+ }).render();
+ }
+ }, {
+ key: "addToolbarButtons",
+ value: function addToolbarButtons() {
+ var _this2 = this;
+
+ this.context.memo('button.style', function () {
+ return _this2.ui.buttonGroup([_this2.button({
+ className: 'dropdown-toggle',
+ contents: _this2.ui.dropdownButtonContents(_this2.ui.icon(_this2.options.icons.magic), _this2.options),
+ tooltip: _this2.lang.style.style,
+ data: {
+ toggle: 'dropdown'
+ }
+ }), _this2.ui.dropdown({
+ className: 'dropdown-style',
+ items: _this2.options.styleTags,
+ title: _this2.lang.style.style,
+ template: function template(item) {
+ // TBD: need to be simplified
+ if (typeof item === 'string') {
+ item = {
+ tag: item,
+ title: Object.prototype.hasOwnProperty.call(_this2.lang.style, item) ? _this2.lang.style[item] : item
+ };
+ }
+
+ var tag = item.tag;
+ var title = item.title;
+ var style = item.style ? ' style="' + item.style + '" ' : '';
+ var className = item.className ? ' class="' + item.className + '"' : '';
+ return '<' + tag + style + className + '>' + title + '';
+ },
+ click: _this2.context.createInvokeHandler('editor.formatBlock')
+ })]).render();
+ });
+
+ var _loop = function _loop(styleIdx, styleLen) {
+ var item = _this2.options.styleTags[styleIdx];
+
+ _this2.context.memo('button.style.' + item, function () {
+ return _this2.button({
+ className: 'note-btn-style-' + item,
+ contents: '' + this.lang.color.foreground + '
', '', '', '
', '', '', '', '', '
', // Fix missing Div, Commented to find easily if it's wrong
+ '', '' + item.toUpperCase() + '
',
+ tooltip: _this2.lang.style[item],
+ click: _this2.context.createInvokeHandler('editor.formatBlock')
+ }).render();
+ });
+ };
+
+ for (var styleIdx = 0, styleLen = this.options.styleTags.length; styleIdx < styleLen; styleIdx++) {
+ _loop(styleIdx, styleLen);
+ }
+
+ this.context.memo('button.bold', function () {
+ return _this2.button({
+ className: 'note-btn-bold',
+ contents: _this2.ui.icon(_this2.options.icons.bold),
+ tooltip: _this2.lang.font.bold + _this2.representShortcut('bold'),
+ click: _this2.context.createInvokeHandlerAndUpdateState('editor.bold')
+ }).render();
+ });
+ this.context.memo('button.italic', function () {
+ return _this2.button({
+ className: 'note-btn-italic',
+ contents: _this2.ui.icon(_this2.options.icons.italic),
+ tooltip: _this2.lang.font.italic + _this2.representShortcut('italic'),
+ click: _this2.context.createInvokeHandlerAndUpdateState('editor.italic')
+ }).render();
+ });
+ this.context.memo('button.underline', function () {
+ return _this2.button({
+ className: 'note-btn-underline',
+ contents: _this2.ui.icon(_this2.options.icons.underline),
+ tooltip: _this2.lang.font.underline + _this2.representShortcut('underline'),
+ click: _this2.context.createInvokeHandlerAndUpdateState('editor.underline')
+ }).render();
+ });
+ this.context.memo('button.clear', function () {
+ return _this2.button({
+ contents: _this2.ui.icon(_this2.options.icons.eraser),
+ tooltip: _this2.lang.font.clear + _this2.representShortcut('removeFormat'),
+ click: _this2.context.createInvokeHandler('editor.removeFormat')
+ }).render();
+ });
+ this.context.memo('button.strikethrough', function () {
+ return _this2.button({
+ className: 'note-btn-strikethrough',
+ contents: _this2.ui.icon(_this2.options.icons.strikethrough),
+ tooltip: _this2.lang.font.strikethrough + _this2.representShortcut('strikethrough'),
+ click: _this2.context.createInvokeHandlerAndUpdateState('editor.strikethrough')
+ }).render();
+ });
+ this.context.memo('button.superscript', function () {
+ return _this2.button({
+ className: 'note-btn-superscript',
+ contents: _this2.ui.icon(_this2.options.icons.superscript),
+ tooltip: _this2.lang.font.superscript,
+ click: _this2.context.createInvokeHandlerAndUpdateState('editor.superscript')
+ }).render();
+ });
+ this.context.memo('button.subscript', function () {
+ return _this2.button({
+ className: 'note-btn-subscript',
+ contents: _this2.ui.icon(_this2.options.icons.subscript),
+ tooltip: _this2.lang.font.subscript,
+ click: _this2.context.createInvokeHandlerAndUpdateState('editor.subscript')
+ }).render();
+ });
+ this.context.memo('button.fontname', function () {
+ var styleInfo = _this2.context.invoke('editor.currentStyle');
+
+ if (_this2.options.addDefaultFonts) {
+ // Add 'default' fonts into the fontnames array if not exist
+ external_jQuery_default().each(styleInfo['font-family'].split(','), function (idx, fontname) {
+ fontname = fontname.trim().replace(/['"]+/g, '');
+
+ if (_this2.isFontDeservedToAdd(fontname)) {
+ if (_this2.options.fontNames.indexOf(fontname) === -1) {
+ _this2.options.fontNames.push(fontname);
+ }
+ }
+ });
+ }
+
+ return _this2.ui.buttonGroup([_this2.button({
+ className: 'dropdown-toggle',
+ contents: _this2.ui.dropdownButtonContents('', _this2.options),
+ tooltip: _this2.lang.font.name,
+ data: {
+ toggle: 'dropdown'
+ }
+ }), _this2.ui.dropdownCheck({
+ className: 'dropdown-fontname',
+ checkClassName: _this2.options.icons.menuCheck,
+ items: _this2.options.fontNames.filter(_this2.isFontInstalled.bind(_this2)),
+ title: _this2.lang.font.name,
+ template: function template(item) {
+ return '' + item + '';
+ },
+ click: _this2.context.createInvokeHandlerAndUpdateState('editor.fontName')
+ })]).render();
+ });
+ this.context.memo('button.fontsize', function () {
+ return _this2.ui.buttonGroup([_this2.button({
+ className: 'dropdown-toggle',
+ contents: _this2.ui.dropdownButtonContents('', _this2.options),
+ tooltip: _this2.lang.font.size,
+ data: {
+ toggle: 'dropdown'
+ }
+ }), _this2.ui.dropdownCheck({
+ className: 'dropdown-fontsize',
+ checkClassName: _this2.options.icons.menuCheck,
+ items: _this2.options.fontSizes,
+ title: _this2.lang.font.size,
+ click: _this2.context.createInvokeHandlerAndUpdateState('editor.fontSize')
+ })]).render();
+ });
+ this.context.memo('button.fontsizeunit', function () {
+ return _this2.ui.buttonGroup([_this2.button({
+ className: 'dropdown-toggle',
+ contents: _this2.ui.dropdownButtonContents('', _this2.options),
+ tooltip: _this2.lang.font.sizeunit,
+ data: {
+ toggle: 'dropdown'
+ }
+ }), _this2.ui.dropdownCheck({
+ className: 'dropdown-fontsizeunit',
+ checkClassName: _this2.options.icons.menuCheck,
+ items: _this2.options.fontSizeUnits,
+ title: _this2.lang.font.sizeunit,
+ click: _this2.context.createInvokeHandlerAndUpdateState('editor.fontSizeUnit')
+ })]).render();
+ });
+ this.context.memo('button.color', function () {
+ return _this2.colorPalette('note-color-all', _this2.lang.color.recent, true, true);
+ });
+ this.context.memo('button.forecolor', function () {
+ return _this2.colorPalette('note-color-fore', _this2.lang.color.foreground, false, true);
+ });
+ this.context.memo('button.backcolor', function () {
+ return _this2.colorPalette('note-color-back', _this2.lang.color.background, true, false);
+ });
+ this.context.memo('button.ul', function () {
+ return _this2.button({
+ contents: _this2.ui.icon(_this2.options.icons.unorderedlist),
+ tooltip: _this2.lang.lists.unordered + _this2.representShortcut('insertUnorderedList'),
+ click: _this2.context.createInvokeHandler('editor.insertUnorderedList')
+ }).render();
+ });
+ this.context.memo('button.ol', function () {
+ return _this2.button({
+ contents: _this2.ui.icon(_this2.options.icons.orderedlist),
+ tooltip: _this2.lang.lists.ordered + _this2.representShortcut('insertOrderedList'),
+ click: _this2.context.createInvokeHandler('editor.insertOrderedList')
+ }).render();
+ });
+ var justifyLeft = this.button({
+ contents: this.ui.icon(this.options.icons.alignLeft),
+ tooltip: this.lang.paragraph.left + this.representShortcut('justifyLeft'),
+ click: this.context.createInvokeHandler('editor.justifyLeft')
+ });
+ var justifyCenter = this.button({
+ contents: this.ui.icon(this.options.icons.alignCenter),
+ tooltip: this.lang.paragraph.center + this.representShortcut('justifyCenter'),
+ click: this.context.createInvokeHandler('editor.justifyCenter')
+ });
+ var justifyRight = this.button({
+ contents: this.ui.icon(this.options.icons.alignRight),
+ tooltip: this.lang.paragraph.right + this.representShortcut('justifyRight'),
+ click: this.context.createInvokeHandler('editor.justifyRight')
+ });
+ var justifyFull = this.button({
+ contents: this.ui.icon(this.options.icons.alignJustify),
+ tooltip: this.lang.paragraph.justify + this.representShortcut('justifyFull'),
+ click: this.context.createInvokeHandler('editor.justifyFull')
+ });
+ var outdent = this.button({
+ contents: this.ui.icon(this.options.icons.outdent),
+ tooltip: this.lang.paragraph.outdent + this.representShortcut('outdent'),
+ click: this.context.createInvokeHandler('editor.outdent')
+ });
+ var indent = this.button({
+ contents: this.ui.icon(this.options.icons.indent),
+ tooltip: this.lang.paragraph.indent + this.representShortcut('indent'),
+ click: this.context.createInvokeHandler('editor.indent')
+ });
+ this.context.memo('button.justifyLeft', func.invoke(justifyLeft, 'render'));
+ this.context.memo('button.justifyCenter', func.invoke(justifyCenter, 'render'));
+ this.context.memo('button.justifyRight', func.invoke(justifyRight, 'render'));
+ this.context.memo('button.justifyFull', func.invoke(justifyFull, 'render'));
+ this.context.memo('button.outdent', func.invoke(outdent, 'render'));
+ this.context.memo('button.indent', func.invoke(indent, 'render'));
+ this.context.memo('button.paragraph', function () {
+ return _this2.ui.buttonGroup([_this2.button({
+ className: 'dropdown-toggle',
+ contents: _this2.ui.dropdownButtonContents(_this2.ui.icon(_this2.options.icons.alignLeft), _this2.options),
+ tooltip: _this2.lang.paragraph.paragraph,
+ data: {
+ toggle: 'dropdown'
+ }
+ }), _this2.ui.dropdown([_this2.ui.buttonGroup({
+ className: 'note-align',
+ children: [justifyLeft, justifyCenter, justifyRight, justifyFull]
+ }), _this2.ui.buttonGroup({
+ className: 'note-list',
+ children: [outdent, indent]
+ })])]).render();
+ });
+ this.context.memo('button.height', function () {
+ return _this2.ui.buttonGroup([_this2.button({
+ className: 'dropdown-toggle',
+ contents: _this2.ui.dropdownButtonContents(_this2.ui.icon(_this2.options.icons.textHeight), _this2.options),
+ tooltip: _this2.lang.font.height,
+ data: {
+ toggle: 'dropdown'
+ }
+ }), _this2.ui.dropdownCheck({
+ items: _this2.options.lineHeights,
+ checkClassName: _this2.options.icons.menuCheck,
+ className: 'dropdown-line-height',
+ title: _this2.lang.font.height,
+ click: _this2.context.createInvokeHandler('editor.lineHeight')
+ })]).render();
+ });
+ this.context.memo('button.table', function () {
+ return _this2.ui.buttonGroup([_this2.button({
+ className: 'dropdown-toggle',
+ contents: _this2.ui.dropdownButtonContents(_this2.ui.icon(_this2.options.icons.table), _this2.options),
+ tooltip: _this2.lang.table.table,
+ data: {
+ toggle: 'dropdown'
+ }
+ }), _this2.ui.dropdown({
+ title: _this2.lang.table.table,
+ className: 'note-table',
+ items: ['', '', '', '', '
', '1 x 1
'].join('')
+ })], {
+ callback: function callback($node) {
+ var $catcher = $node.find('.note-dimension-picker-mousecatcher');
+ $catcher.css({
+ width: _this2.options.insertTableMaxSize.col + 'em',
+ height: _this2.options.insertTableMaxSize.row + 'em'
+ }).mouseup(_this2.context.createInvokeHandler('editor.insertTable')).on('mousemove', _this2.tableMoveHandler.bind(_this2));
+ }
+ }).render();
+ });
+ this.context.memo('button.link', function () {
+ return _this2.button({
+ contents: _this2.ui.icon(_this2.options.icons.link),
+ tooltip: _this2.lang.link.link + _this2.representShortcut('linkDialog.show'),
+ click: _this2.context.createInvokeHandler('linkDialog.show')
+ }).render();
+ });
+ this.context.memo('button.picture', function () {
+ return _this2.button({
+ contents: _this2.ui.icon(_this2.options.icons.picture),
+ tooltip: _this2.lang.image.image,
+ click: _this2.context.createInvokeHandler('imageDialog.show')
+ }).render();
+ });
+ this.context.memo('button.video', function () {
+ return _this2.button({
+ contents: _this2.ui.icon(_this2.options.icons.video),
+ tooltip: _this2.lang.video.video,
+ click: _this2.context.createInvokeHandler('videoDialog.show')
+ }).render();
+ });
+ this.context.memo('button.hr', function () {
+ return _this2.button({
+ contents: _this2.ui.icon(_this2.options.icons.minus),
+ tooltip: _this2.lang.hr.insert + _this2.representShortcut('insertHorizontalRule'),
+ click: _this2.context.createInvokeHandler('editor.insertHorizontalRule')
+ }).render();
+ });
+ this.context.memo('button.fullscreen', function () {
+ return _this2.button({
+ className: 'btn-fullscreen note-codeview-keep',
+ contents: _this2.ui.icon(_this2.options.icons.arrowsAlt),
+ tooltip: _this2.lang.options.fullscreen,
+ click: _this2.context.createInvokeHandler('fullscreen.toggle')
+ }).render();
+ });
+ this.context.memo('button.codeview', function () {
+ return _this2.button({
+ className: 'btn-codeview note-codeview-keep',
+ contents: _this2.ui.icon(_this2.options.icons.code),
+ tooltip: _this2.lang.options.codeview,
+ click: _this2.context.createInvokeHandler('codeview.toggle')
+ }).render();
+ });
+ this.context.memo('button.redo', function () {
+ return _this2.button({
+ contents: _this2.ui.icon(_this2.options.icons.redo),
+ tooltip: _this2.lang.history.redo + _this2.representShortcut('redo'),
+ click: _this2.context.createInvokeHandler('editor.redo')
+ }).render();
+ });
+ this.context.memo('button.undo', function () {
+ return _this2.button({
+ contents: _this2.ui.icon(_this2.options.icons.undo),
+ tooltip: _this2.lang.history.undo + _this2.representShortcut('undo'),
+ click: _this2.context.createInvokeHandler('editor.undo')
+ }).render();
+ });
+ this.context.memo('button.help', function () {
+ return _this2.button({
+ contents: _this2.ui.icon(_this2.options.icons.question),
+ tooltip: _this2.lang.options.help,
+ click: _this2.context.createInvokeHandler('helpDialog.show')
+ }).render();
+ });
+ }
+ /**
+ * image: [
+ * ['imageResize', ['resizeFull', 'resizeHalf', 'resizeQuarter', 'resizeNone']],
+ * ['float', ['floatLeft', 'floatRight', 'floatNone']],
+ * ['remove', ['removeMedia']],
+ * ],
+ */
+
+ }, {
+ key: "addImagePopoverButtons",
+ value: function addImagePopoverButtons() {
+ var _this3 = this;
+
+ // Image Size Buttons
+ this.context.memo('button.resizeFull', function () {
+ return _this3.button({
+ contents: '100%',
+ tooltip: _this3.lang.image.resizeFull,
+ click: _this3.context.createInvokeHandler('editor.resize', '1')
+ }).render();
+ });
+ this.context.memo('button.resizeHalf', function () {
+ return _this3.button({
+ contents: '50%',
+ tooltip: _this3.lang.image.resizeHalf,
+ click: _this3.context.createInvokeHandler('editor.resize', '0.5')
+ }).render();
+ });
+ this.context.memo('button.resizeQuarter', function () {
+ return _this3.button({
+ contents: '25%',
+ tooltip: _this3.lang.image.resizeQuarter,
+ click: _this3.context.createInvokeHandler('editor.resize', '0.25')
+ }).render();
+ });
+ this.context.memo('button.resizeNone', function () {
+ return _this3.button({
+ contents: _this3.ui.icon(_this3.options.icons.rollback),
+ tooltip: _this3.lang.image.resizeNone,
+ click: _this3.context.createInvokeHandler('editor.resize', '0')
+ }).render();
+ }); // Float Buttons
+
+ this.context.memo('button.floatLeft', function () {
+ return _this3.button({
+ contents: _this3.ui.icon(_this3.options.icons.floatLeft),
+ tooltip: _this3.lang.image.floatLeft,
+ click: _this3.context.createInvokeHandler('editor.floatMe', 'left')
+ }).render();
+ });
+ this.context.memo('button.floatRight', function () {
+ return _this3.button({
+ contents: _this3.ui.icon(_this3.options.icons.floatRight),
+ tooltip: _this3.lang.image.floatRight,
+ click: _this3.context.createInvokeHandler('editor.floatMe', 'right')
+ }).render();
+ });
+ this.context.memo('button.floatNone', function () {
+ return _this3.button({
+ contents: _this3.ui.icon(_this3.options.icons.rollback),
+ tooltip: _this3.lang.image.floatNone,
+ click: _this3.context.createInvokeHandler('editor.floatMe', 'none')
+ }).render();
+ }); // Remove Buttons
+
+ this.context.memo('button.removeMedia', function () {
+ return _this3.button({
+ contents: _this3.ui.icon(_this3.options.icons.trash),
+ tooltip: _this3.lang.image.remove,
+ click: _this3.context.createInvokeHandler('editor.removeMedia')
+ }).render();
+ });
+ }
+ }, {
+ key: "addLinkPopoverButtons",
+ value: function addLinkPopoverButtons() {
+ var _this4 = this;
+
+ this.context.memo('button.linkDialogShow', function () {
+ return _this4.button({
+ contents: _this4.ui.icon(_this4.options.icons.link),
+ tooltip: _this4.lang.link.edit,
+ click: _this4.context.createInvokeHandler('linkDialog.show')
+ }).render();
+ });
+ this.context.memo('button.unlink', function () {
+ return _this4.button({
+ contents: _this4.ui.icon(_this4.options.icons.unlink),
+ tooltip: _this4.lang.link.unlink,
+ click: _this4.context.createInvokeHandler('editor.unlink')
+ }).render();
+ });
+ }
+ /**
+ * table : [
+ * ['add', ['addRowDown', 'addRowUp', 'addColLeft', 'addColRight']],
+ * ['delete', ['deleteRow', 'deleteCol', 'deleteTable']]
+ * ],
+ */
+
+ }, {
+ key: "addTablePopoverButtons",
+ value: function addTablePopoverButtons() {
+ var _this5 = this;
+
+ this.context.memo('button.addRowUp', function () {
+ return _this5.button({
+ className: 'btn-md',
+ contents: _this5.ui.icon(_this5.options.icons.rowAbove),
+ tooltip: _this5.lang.table.addRowAbove,
+ click: _this5.context.createInvokeHandler('editor.addRow', 'top')
+ }).render();
+ });
+ this.context.memo('button.addRowDown', function () {
+ return _this5.button({
+ className: 'btn-md',
+ contents: _this5.ui.icon(_this5.options.icons.rowBelow),
+ tooltip: _this5.lang.table.addRowBelow,
+ click: _this5.context.createInvokeHandler('editor.addRow', 'bottom')
+ }).render();
+ });
+ this.context.memo('button.addColLeft', function () {
+ return _this5.button({
+ className: 'btn-md',
+ contents: _this5.ui.icon(_this5.options.icons.colBefore),
+ tooltip: _this5.lang.table.addColLeft,
+ click: _this5.context.createInvokeHandler('editor.addCol', 'left')
+ }).render();
+ });
+ this.context.memo('button.addColRight', function () {
+ return _this5.button({
+ className: 'btn-md',
+ contents: _this5.ui.icon(_this5.options.icons.colAfter),
+ tooltip: _this5.lang.table.addColRight,
+ click: _this5.context.createInvokeHandler('editor.addCol', 'right')
+ }).render();
+ });
+ this.context.memo('button.deleteRow', function () {
+ return _this5.button({
+ className: 'btn-md',
+ contents: _this5.ui.icon(_this5.options.icons.rowRemove),
+ tooltip: _this5.lang.table.delRow,
+ click: _this5.context.createInvokeHandler('editor.deleteRow')
+ }).render();
+ });
+ this.context.memo('button.deleteCol', function () {
+ return _this5.button({
+ className: 'btn-md',
+ contents: _this5.ui.icon(_this5.options.icons.colRemove),
+ tooltip: _this5.lang.table.delCol,
+ click: _this5.context.createInvokeHandler('editor.deleteCol')
+ }).render();
+ });
+ this.context.memo('button.deleteTable', function () {
+ return _this5.button({
+ className: 'btn-md',
+ contents: _this5.ui.icon(_this5.options.icons.trash),
+ tooltip: _this5.lang.table.delTable,
+ click: _this5.context.createInvokeHandler('editor.deleteTable')
+ }).render();
+ });
+ }
+ }, {
+ key: "build",
+ value: function build($container, groups) {
+ for (var groupIdx = 0, groupLen = groups.length; groupIdx < groupLen; groupIdx++) {
+ var group = groups[groupIdx];
+ var groupName = Array.isArray(group) ? group[0] : group;
+ var buttons = Array.isArray(group) ? group.length === 1 ? [group[0]] : group[1] : [group];
+ var $group = this.ui.buttonGroup({
+ className: 'note-' + groupName
+ }).render();
+
+ for (var idx = 0, len = buttons.length; idx < len; idx++) {
+ var btn = this.context.memo('button.' + buttons[idx]);
+
+ if (btn) {
+ $group.append(typeof btn === 'function' ? btn(this.context) : btn);
+ }
+ }
+
+ $group.appendTo($container);
+ }
+ }
+ /**
+ * @param {jQuery} [$container]
+ */
+
+ }, {
+ key: "updateCurrentStyle",
+ value: function updateCurrentStyle($container) {
+ var $cont = $container || this.$toolbar;
+ var styleInfo = this.context.invoke('editor.currentStyle');
+ this.updateBtnStates($cont, {
+ '.note-btn-bold': function noteBtnBold() {
+ return styleInfo['font-bold'] === 'bold';
+ },
+ '.note-btn-italic': function noteBtnItalic() {
+ return styleInfo['font-italic'] === 'italic';
+ },
+ '.note-btn-underline': function noteBtnUnderline() {
+ return styleInfo['font-underline'] === 'underline';
+ },
+ '.note-btn-subscript': function noteBtnSubscript() {
+ return styleInfo['font-subscript'] === 'subscript';
+ },
+ '.note-btn-superscript': function noteBtnSuperscript() {
+ return styleInfo['font-superscript'] === 'superscript';
+ },
+ '.note-btn-strikethrough': function noteBtnStrikethrough() {
+ return styleInfo['font-strikethrough'] === 'strikethrough';
+ }
+ });
+
+ if (styleInfo['font-family']) {
+ var fontNames = styleInfo['font-family'].split(',').map(function (name) {
+ return name.replace(/[\'\"]/g, '').replace(/\s+$/, '').replace(/^\s+/, '');
+ });
+ var fontName = lists.find(fontNames, this.isFontInstalled.bind(this));
+ $cont.find('.dropdown-fontname a').each(function (idx, item) {
+ var $item = external_jQuery_default()(item); // always compare string to avoid creating another func.
+
+ var isChecked = $item.data('value') + '' === fontName + '';
+ $item.toggleClass('checked', isChecked);
+ });
+ $cont.find('.note-current-fontname').text(fontName).css('font-family', fontName);
+ }
+
+ if (styleInfo['font-size']) {
+ var fontSize = styleInfo['font-size'];
+ $cont.find('.dropdown-fontsize a').each(function (idx, item) {
+ var $item = external_jQuery_default()(item); // always compare with string to avoid creating another func.
+
+ var isChecked = $item.data('value') + '' === fontSize + '';
+ $item.toggleClass('checked', isChecked);
+ });
+ $cont.find('.note-current-fontsize').text(fontSize);
+ var fontSizeUnit = styleInfo['font-size-unit'];
+ $cont.find('.dropdown-fontsizeunit a').each(function (idx, item) {
+ var $item = external_jQuery_default()(item);
+ var isChecked = $item.data('value') + '' === fontSizeUnit + '';
+ $item.toggleClass('checked', isChecked);
+ });
+ $cont.find('.note-current-fontsizeunit').text(fontSizeUnit);
+ }
+
+ if (styleInfo['line-height']) {
+ var lineHeight = styleInfo['line-height'];
+ $cont.find('.dropdown-line-height a').each(function (idx, item) {
+ var $item = external_jQuery_default()(item); // always compare with string to avoid creating another func.
+
+ var isChecked = external_jQuery_default()(item).data('value') + '' === lineHeight + '';
+ $item.toggleClass('checked', isChecked);
+ });
+ $cont.find('.note-current-line-height').text(lineHeight);
+ }
+ }
+ }, {
+ key: "updateBtnStates",
+ value: function updateBtnStates($container, infos) {
+ var _this6 = this;
+
+ external_jQuery_default().each(infos, function (selector, pred) {
+ _this6.ui.toggleBtnActive($container.find(selector), pred());
+ });
+ }
+ }, {
+ key: "tableMoveHandler",
+ value: function tableMoveHandler(event) {
+ var PX_PER_EM = 18;
+ var $picker = external_jQuery_default()(event.target.parentNode); // target is mousecatcher
+
+ var $dimensionDisplay = $picker.next();
+ var $catcher = $picker.find('.note-dimension-picker-mousecatcher');
+ var $highlighted = $picker.find('.note-dimension-picker-highlighted');
+ var $unhighlighted = $picker.find('.note-dimension-picker-unhighlighted');
+ var posOffset; // HTML5 with jQuery - e.offsetX is undefined in Firefox
+
+ if (event.offsetX === undefined) {
+ var posCatcher = external_jQuery_default()(event.target).offset();
+ posOffset = {
+ x: event.pageX - posCatcher.left,
+ y: event.pageY - posCatcher.top
+ };
+ } else {
+ posOffset = {
+ x: event.offsetX,
+ y: event.offsetY
+ };
+ }
+
+ var dim = {
+ c: Math.ceil(posOffset.x / PX_PER_EM) || 1,
+ r: Math.ceil(posOffset.y / PX_PER_EM) || 1
+ };
+ $highlighted.css({
+ width: dim.c + 'em',
+ height: dim.r + 'em'
+ });
+ $catcher.data('value', dim.c + 'x' + dim.r);
+
+ if (dim.c > 3 && dim.c < this.options.insertTableMaxSize.col) {
+ $unhighlighted.css({
+ width: dim.c + 1 + 'em'
+ });
+ }
+
+ if (dim.r > 3 && dim.r < this.options.insertTableMaxSize.row) {
+ $unhighlighted.css({
+ height: dim.r + 1 + 'em'
+ });
+ }
+
+ $dimensionDisplay.html(dim.c + ' x ' + dim.r);
+ }
+ }]);
+
+ return Buttons;
+}();
+
+
+;// CONCATENATED MODULE: ./src/js/module/Toolbar.js
+function Toolbar_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function Toolbar_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function Toolbar_createClass(Constructor, protoProps, staticProps) { if (protoProps) Toolbar_defineProperties(Constructor.prototype, protoProps); if (staticProps) Toolbar_defineProperties(Constructor, staticProps); return Constructor; }
+
+
+
+var Toolbar = /*#__PURE__*/function () {
+ function Toolbar(context) {
+ Toolbar_classCallCheck(this, Toolbar);
+
+ this.context = context;
+ this.$window = external_jQuery_default()(window);
+ this.$document = external_jQuery_default()(document);
+ this.ui = (external_jQuery_default()).summernote.ui;
+ this.$note = context.layoutInfo.note;
+ this.$editor = context.layoutInfo.editor;
+ this.$toolbar = context.layoutInfo.toolbar;
+ this.$editable = context.layoutInfo.editable;
+ this.$statusbar = context.layoutInfo.statusbar;
+ this.options = context.options;
+ this.isFollowing = false;
+ this.followScroll = this.followScroll.bind(this);
+ }
+
+ Toolbar_createClass(Toolbar, [{
+ key: "shouldInitialize",
+ value: function shouldInitialize() {
+ return !this.options.airMode;
+ }
+ }, {
+ key: "initialize",
+ value: function initialize() {
+ var _this = this;
+
+ this.options.toolbar = this.options.toolbar || [];
+
+ if (!this.options.toolbar.length) {
+ this.$toolbar.hide();
+ } else {
+ this.context.invoke('buttons.build', this.$toolbar, this.options.toolbar);
+ }
+
+ if (this.options.toolbarContainer) {
+ this.$toolbar.appendTo(this.options.toolbarContainer);
+ }
+
+ this.changeContainer(false);
+ this.$note.on('summernote.keyup summernote.mouseup summernote.change', function () {
+ _this.context.invoke('buttons.updateCurrentStyle');
+ });
+ this.context.invoke('buttons.updateCurrentStyle');
+
+ if (this.options.followingToolbar) {
+ this.$window.on('scroll resize', this.followScroll);
+ }
+ }
+ }, {
+ key: "destroy",
+ value: function destroy() {
+ this.$toolbar.children().remove();
+
+ if (this.options.followingToolbar) {
+ this.$window.off('scroll resize', this.followScroll);
+ }
+ }
+ }, {
+ key: "followScroll",
+ value: function followScroll() {
+ if (this.$editor.hasClass('fullscreen')) {
+ return false;
+ }
+
+ var editorHeight = this.$editor.outerHeight();
+ var editorWidth = this.$editor.width();
+ var toolbarHeight = this.$toolbar.height();
+ var statusbarHeight = this.$statusbar.height(); // check if the web app is currently using another static bar
+
+ var otherBarHeight = 0;
+
+ if (this.options.otherStaticBar) {
+ otherBarHeight = external_jQuery_default()(this.options.otherStaticBar).outerHeight();
+ }
+
+ var currentOffset = this.$document.scrollTop();
+ var editorOffsetTop = this.$editor.offset().top;
+ var editorOffsetBottom = editorOffsetTop + editorHeight;
+ var activateOffset = editorOffsetTop - otherBarHeight;
+ var deactivateOffsetBottom = editorOffsetBottom - otherBarHeight - toolbarHeight - statusbarHeight;
+
+ if (!this.isFollowing && currentOffset > activateOffset && currentOffset < deactivateOffsetBottom - toolbarHeight) {
+ this.isFollowing = true;
+ this.$editable.css({
+ marginTop: this.$toolbar.outerHeight()
+ });
+ this.$toolbar.css({
+ position: 'fixed',
+ top: otherBarHeight,
+ width: editorWidth,
+ zIndex: 1000
+ });
+ } else if (this.isFollowing && (currentOffset < activateOffset || currentOffset > deactivateOffsetBottom)) {
+ this.isFollowing = false;
+ this.$toolbar.css({
+ position: 'relative',
+ top: 0,
+ width: '100%',
+ zIndex: 'auto'
+ });
+ this.$editable.css({
+ marginTop: ''
+ });
+ }
+ }
+ }, {
+ key: "changeContainer",
+ value: function changeContainer(isFullscreen) {
+ if (isFullscreen) {
+ this.$toolbar.prependTo(this.$editor);
+ } else {
+ if (this.options.toolbarContainer) {
+ this.$toolbar.appendTo(this.options.toolbarContainer);
+ }
+ }
+
+ if (this.options.followingToolbar) {
+ this.followScroll();
+ }
+ }
+ }, {
+ key: "updateFullscreen",
+ value: function updateFullscreen(isFullscreen) {
+ this.ui.toggleBtnActive(this.$toolbar.find('.btn-fullscreen'), isFullscreen);
+ this.changeContainer(isFullscreen);
+ }
+ }, {
+ key: "updateCodeview",
+ value: function updateCodeview(isCodeview) {
+ this.ui.toggleBtnActive(this.$toolbar.find('.btn-codeview'), isCodeview);
+
+ if (isCodeview) {
+ this.deactivate();
+ } else {
+ this.activate();
+ }
+ }
+ }, {
+ key: "activate",
+ value: function activate(isIncludeCodeview) {
+ var $btn = this.$toolbar.find('button');
+
+ if (!isIncludeCodeview) {
+ $btn = $btn.not('.note-codeview-keep');
+ }
+
+ this.ui.toggleBtn($btn, true);
+ }
+ }, {
+ key: "deactivate",
+ value: function deactivate(isIncludeCodeview) {
+ var $btn = this.$toolbar.find('button');
+
+ if (!isIncludeCodeview) {
+ $btn = $btn.not('.note-codeview-keep');
+ }
+
+ this.ui.toggleBtn($btn, false);
+ }
+ }]);
+
+ return Toolbar;
+}();
+
+
+;// CONCATENATED MODULE: ./src/js/module/LinkDialog.js
+function LinkDialog_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function LinkDialog_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function LinkDialog_createClass(Constructor, protoProps, staticProps) { if (protoProps) LinkDialog_defineProperties(Constructor.prototype, protoProps); if (staticProps) LinkDialog_defineProperties(Constructor, staticProps); return Constructor; }
+
+
+
+
+
+
+var LinkDialog = /*#__PURE__*/function () {
+ function LinkDialog(context) {
+ LinkDialog_classCallCheck(this, LinkDialog);
+
+ this.context = context;
+ this.ui = (external_jQuery_default()).summernote.ui;
+ this.$body = external_jQuery_default()(document.body);
+ this.$editor = context.layoutInfo.editor;
+ this.options = context.options;
+ this.lang = this.options.langInfo;
+ context.memo('help.linkDialog.show', this.options.langInfo.help['linkDialog.show']);
+ }
+
+ LinkDialog_createClass(LinkDialog, [{
+ key: "initialize",
+ value: function initialize() {
+ var $container = this.options.dialogsInBody ? this.$body : this.options.container;
+ var body = ['', ""), ""), '
', '', ""), ""), '
', !this.options.disableLinkTarget ? external_jQuery_default()('').append(this.ui.checkbox({
+ className: 'sn-checkbox-open-in-new-window',
+ text: this.lang.link.openInNewWindow,
+ checked: true
+ }).render()).html() : '', external_jQuery_default()('').append(this.ui.checkbox({
+ className: 'sn-checkbox-use-protocol',
+ text: this.lang.link.useProtocol,
+ checked: true
+ }).render()).html()].join('');
+ var buttonClass = 'btn btn-primary note-btn note-btn-primary note-link-btn';
+ var footer = "");
+ this.$dialog = this.ui.dialog({
+ className: 'link-dialog',
+ title: this.lang.link.insert,
+ fade: this.options.dialogsFade,
+ body: body,
+ footer: footer
+ }).render().appendTo($container);
+ }
+ }, {
+ key: "destroy",
+ value: function destroy() {
+ this.ui.hideDialog(this.$dialog);
+ this.$dialog.remove();
+ }
+ }, {
+ key: "bindEnterKey",
+ value: function bindEnterKey($input, $btn) {
+ $input.on('keypress', function (event) {
+ if (event.keyCode === key.code.ENTER) {
+ event.preventDefault();
+ $btn.trigger('click');
+ }
+ });
+ }
+ /**
+ * toggle update button
+ */
+
+ }, {
+ key: "toggleLinkBtn",
+ value: function toggleLinkBtn($linkBtn, $linkText, $linkUrl) {
+ this.ui.toggleBtn($linkBtn, $linkText.val() && $linkUrl.val());
+ }
+ /**
+ * Show link dialog and set event handlers on dialog controls.
+ *
+ * @param {Object} linkInfo
+ * @return {Promise}
+ */
+
+ }, {
+ key: "showLinkDialog",
+ value: function showLinkDialog(linkInfo) {
+ var _this = this;
+
+ return external_jQuery_default().Deferred(function (deferred) {
+ var $linkText = _this.$dialog.find('.note-link-text');
+
+ var $linkUrl = _this.$dialog.find('.note-link-url');
+
+ var $linkBtn = _this.$dialog.find('.note-link-btn');
+
+ var $openInNewWindow = _this.$dialog.find('.sn-checkbox-open-in-new-window input[type=checkbox]');
+
+ var $useProtocol = _this.$dialog.find('.sn-checkbox-use-protocol input[type=checkbox]');
+
+ _this.ui.onDialogShown(_this.$dialog, function () {
+ _this.context.triggerEvent('dialog.shown'); // If no url was given and given text is valid URL then copy that into URL Field
+
+
+ if (!linkInfo.url && func.isValidUrl(linkInfo.text)) {
+ linkInfo.url = linkInfo.text;
+ }
+
+ $linkText.on('input paste propertychange', function () {
+ // If linktext was modified by input events,
+ // cloning text from linkUrl will be stopped.
+ linkInfo.text = $linkText.val();
+
+ _this.toggleLinkBtn($linkBtn, $linkText, $linkUrl);
+ }).val(linkInfo.text);
+ $linkUrl.on('input paste propertychange', function () {
+ // Display same text on `Text to display` as default
+ // when linktext has no text
+ if (!linkInfo.text) {
+ $linkText.val($linkUrl.val());
+ }
+
+ _this.toggleLinkBtn($linkBtn, $linkText, $linkUrl);
+ }).val(linkInfo.url);
+
+ if (!env.isSupportTouch) {
+ $linkUrl.trigger('focus');
+ }
+
+ _this.toggleLinkBtn($linkBtn, $linkText, $linkUrl);
+
+ _this.bindEnterKey($linkUrl, $linkBtn);
+
+ _this.bindEnterKey($linkText, $linkBtn);
+
+ var isNewWindowChecked = linkInfo.isNewWindow !== undefined ? linkInfo.isNewWindow : _this.context.options.linkTargetBlank;
+ $openInNewWindow.prop('checked', isNewWindowChecked);
+ var useProtocolChecked = linkInfo.url ? false : _this.context.options.useProtocol;
+ $useProtocol.prop('checked', useProtocolChecked);
+ $linkBtn.one('click', function (event) {
+ event.preventDefault();
+ deferred.resolve({
+ range: linkInfo.range,
+ url: $linkUrl.val(),
+ text: $linkText.val(),
+ isNewWindow: $openInNewWindow.is(':checked'),
+ checkProtocol: $useProtocol.is(':checked')
+ });
+
+ _this.ui.hideDialog(_this.$dialog);
+ });
+ });
+
+ _this.ui.onDialogHidden(_this.$dialog, function () {
+ // detach events
+ $linkText.off();
+ $linkUrl.off();
+ $linkBtn.off();
+
+ if (deferred.state() === 'pending') {
+ deferred.reject();
+ }
+ });
+
+ _this.ui.showDialog(_this.$dialog);
+ }).promise();
+ }
+ /**
+ * @param {Object} layoutInfo
+ */
+
+ }, {
+ key: "show",
+ value: function show() {
+ var _this2 = this;
+
+ var linkInfo = this.context.invoke('editor.getLinkInfo');
+ this.context.invoke('editor.saveRange');
+ this.showLinkDialog(linkInfo).then(function (linkInfo) {
+ _this2.context.invoke('editor.restoreRange');
+
+ _this2.context.invoke('editor.createLink', linkInfo);
+ }).fail(function () {
+ _this2.context.invoke('editor.restoreRange');
+ });
+ }
+ }]);
+
+ return LinkDialog;
+}();
+
+
+;// CONCATENATED MODULE: ./src/js/module/LinkPopover.js
+function LinkPopover_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function LinkPopover_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function LinkPopover_createClass(Constructor, protoProps, staticProps) { if (protoProps) LinkPopover_defineProperties(Constructor.prototype, protoProps); if (staticProps) LinkPopover_defineProperties(Constructor, staticProps); return Constructor; }
+
+
+
+
+
+var LinkPopover = /*#__PURE__*/function () {
+ function LinkPopover(context) {
+ var _this = this;
+
+ LinkPopover_classCallCheck(this, LinkPopover);
+
+ this.context = context;
+ this.ui = (external_jQuery_default()).summernote.ui;
+ this.options = context.options;
+ this.events = {
+ 'summernote.keyup summernote.mouseup summernote.change summernote.scroll': function summernoteKeyupSummernoteMouseupSummernoteChangeSummernoteScroll() {
+ _this.update();
+ },
+ 'summernote.disable summernote.dialog.shown': function summernoteDisableSummernoteDialogShown() {
+ _this.hide();
+ },
+ 'summernote.blur': function summernoteBlur(we, e) {
+ if (e.originalEvent && e.originalEvent.relatedTarget) {
+ if (!_this.$popover[0].contains(e.originalEvent.relatedTarget)) {
+ _this.hide();
+ }
+ } else {
+ _this.hide();
+ }
+ }
+ };
+ }
+
+ LinkPopover_createClass(LinkPopover, [{
+ key: "shouldInitialize",
+ value: function shouldInitialize() {
+ return !lists.isEmpty(this.options.popover.link);
+ }
+ }, {
+ key: "initialize",
+ value: function initialize() {
+ this.$popover = this.ui.popover({
+ className: 'note-link-popover',
+ callback: function callback($node) {
+ var $content = $node.find('.popover-content,.note-popover-content');
+ $content.prepend(' ');
+ }
+ }).render().appendTo(this.options.container);
+ var $content = this.$popover.find('.popover-content,.note-popover-content');
+ this.context.invoke('buttons.build', $content, this.options.popover.link);
+ this.$popover.on('mousedown', function (e) {
+ e.preventDefault();
+ });
+ }
+ }, {
+ key: "destroy",
+ value: function destroy() {
+ this.$popover.remove();
+ }
+ }, {
+ key: "update",
+ value: function update() {
+ // Prevent focusing on editable when invoke('code') is executed
+ if (!this.context.invoke('editor.hasFocus')) {
+ this.hide();
+ return;
+ }
+
+ var rng = this.context.invoke('editor.getLastRange');
+
+ if (rng.isCollapsed() && rng.isOnAnchor()) {
+ var anchor = dom.ancestor(rng.sc, dom.isAnchor);
+ var href = external_jQuery_default()(anchor).attr('href');
+ this.$popover.find('a').attr('href', href).text(href);
+ var pos = dom.posFromPlaceholder(anchor);
+ var containerOffset = external_jQuery_default()(this.options.container).offset();
+ pos.top -= containerOffset.top;
+ pos.left -= containerOffset.left;
+ this.$popover.css({
+ display: 'block',
+ left: pos.left,
+ top: pos.top
+ });
+ } else {
+ this.hide();
+ }
+ }
+ }, {
+ key: "hide",
+ value: function hide() {
+ this.$popover.hide();
+ }
+ }]);
+
+ return LinkPopover;
+}();
+
+
+;// CONCATENATED MODULE: ./src/js/module/ImageDialog.js
+function ImageDialog_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function ImageDialog_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function ImageDialog_createClass(Constructor, protoProps, staticProps) { if (protoProps) ImageDialog_defineProperties(Constructor.prototype, protoProps); if (staticProps) ImageDialog_defineProperties(Constructor, staticProps); return Constructor; }
+
+
+
+
+
+var ImageDialog = /*#__PURE__*/function () {
+ function ImageDialog(context) {
+ ImageDialog_classCallCheck(this, ImageDialog);
+
+ this.context = context;
+ this.ui = (external_jQuery_default()).summernote.ui;
+ this.$body = external_jQuery_default()(document.body);
+ this.$editor = context.layoutInfo.editor;
+ this.options = context.options;
+ this.lang = this.options.langInfo;
+ }
+
+ ImageDialog_createClass(ImageDialog, [{
+ key: "initialize",
+ value: function initialize() {
+ var imageLimitation = '';
+
+ if (this.options.maximumImageFileSize) {
+ var unit = Math.floor(Math.log(this.options.maximumImageFileSize) / Math.log(1024));
+ var readableSize = (this.options.maximumImageFileSize / Math.pow(1024, unit)).toFixed(2) * 1 + ' ' + ' KMGTP'[unit] + 'B';
+ imageLimitation = "".concat(this.lang.image.maximumFileSize + ' : ' + readableSize, "");
+ }
+
+ var $container = this.options.dialogsInBody ? this.$body : this.options.container;
+ var body = ['', '', '', imageLimitation, '
', '', '', '', '
'].join('');
+ var buttonClass = 'btn btn-primary note-btn note-btn-primary note-image-btn';
+ var footer = "");
+ this.$dialog = this.ui.dialog({
+ title: this.lang.image.insert,
+ fade: this.options.dialogsFade,
+ body: body,
+ footer: footer
+ }).render().appendTo($container);
+ }
+ }, {
+ key: "destroy",
+ value: function destroy() {
+ this.ui.hideDialog(this.$dialog);
+ this.$dialog.remove();
+ }
+ }, {
+ key: "bindEnterKey",
+ value: function bindEnterKey($input, $btn) {
+ $input.on('keypress', function (event) {
+ if (event.keyCode === key.code.ENTER) {
+ event.preventDefault();
+ $btn.trigger('click');
+ }
+ });
+ }
+ }, {
+ key: "show",
+ value: function show() {
+ var _this = this;
+
+ this.context.invoke('editor.saveRange');
+ this.showImageDialog().then(function (data) {
+ // [workaround] hide dialog before restore range for IE range focus
+ _this.ui.hideDialog(_this.$dialog);
+
+ _this.context.invoke('editor.restoreRange');
+
+ if (typeof data === 'string') {
+ // image url
+ // If onImageLinkInsert set,
+ if (_this.options.callbacks.onImageLinkInsert) {
+ _this.context.triggerEvent('image.link.insert', data);
+ } else {
+ _this.context.invoke('editor.insertImage', data);
+ }
+ } else {
+ // array of files
+ _this.context.invoke('editor.insertImagesOrCallback', data);
+ }
+ }).fail(function () {
+ _this.context.invoke('editor.restoreRange');
+ });
+ }
+ /**
+ * show image dialog
+ *
+ * @param {jQuery} $dialog
+ * @return {Promise}
+ */
+
+ }, {
+ key: "showImageDialog",
+ value: function showImageDialog() {
+ var _this2 = this;
+
+ return external_jQuery_default().Deferred(function (deferred) {
+ var $imageInput = _this2.$dialog.find('.note-image-input');
+
+ var $imageUrl = _this2.$dialog.find('.note-image-url');
+
+ var $imageBtn = _this2.$dialog.find('.note-image-btn');
+
+ _this2.ui.onDialogShown(_this2.$dialog, function () {
+ _this2.context.triggerEvent('dialog.shown'); // Cloning imageInput to clear element.
+
+
+ $imageInput.replaceWith($imageInput.clone().on('change', function (event) {
+ deferred.resolve(event.target.files || event.target.value);
+ }).val(''));
+ $imageUrl.on('input paste propertychange', function () {
+ _this2.ui.toggleBtn($imageBtn, $imageUrl.val());
+ }).val('');
+
+ if (!env.isSupportTouch) {
+ $imageUrl.trigger('focus');
+ }
+
+ $imageBtn.click(function (event) {
+ event.preventDefault();
+ deferred.resolve($imageUrl.val());
+ });
+
+ _this2.bindEnterKey($imageUrl, $imageBtn);
+ });
+
+ _this2.ui.onDialogHidden(_this2.$dialog, function () {
+ $imageInput.off();
+ $imageUrl.off();
+ $imageBtn.off();
+
+ if (deferred.state() === 'pending') {
+ deferred.reject();
+ }
+ });
+
+ _this2.ui.showDialog(_this2.$dialog);
+ });
+ }
+ }]);
+
+ return ImageDialog;
+}();
+
+
+;// CONCATENATED MODULE: ./src/js/module/ImagePopover.js
+function ImagePopover_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function ImagePopover_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function ImagePopover_createClass(Constructor, protoProps, staticProps) { if (protoProps) ImagePopover_defineProperties(Constructor.prototype, protoProps); if (staticProps) ImagePopover_defineProperties(Constructor, staticProps); return Constructor; }
+
+
+
+
+/**
+ * Image popover module
+ * mouse events that show/hide popover will be handled by Handle.js.
+ * Handle.js will receive the events and invoke 'imagePopover.update'.
+ */
+
+var ImagePopover = /*#__PURE__*/function () {
+ function ImagePopover(context) {
+ var _this = this;
+
+ ImagePopover_classCallCheck(this, ImagePopover);
+
+ this.context = context;
+ this.ui = (external_jQuery_default()).summernote.ui;
+ this.editable = context.layoutInfo.editable[0];
+ this.options = context.options;
+ this.events = {
+ 'summernote.disable summernote.dialog.shown': function summernoteDisableSummernoteDialogShown() {
+ _this.hide();
+ },
+ 'summernote.blur': function summernoteBlur(we, e) {
+ if (e.originalEvent && e.originalEvent.relatedTarget) {
+ if (!_this.$popover[0].contains(e.originalEvent.relatedTarget)) {
+ _this.hide();
+ }
+ } else {
+ _this.hide();
+ }
+ }
+ };
+ }
+
+ ImagePopover_createClass(ImagePopover, [{
+ key: "shouldInitialize",
+ value: function shouldInitialize() {
+ return !lists.isEmpty(this.options.popover.image);
+ }
+ }, {
+ key: "initialize",
+ value: function initialize() {
+ this.$popover = this.ui.popover({
+ className: 'note-image-popover'
+ }).render().appendTo(this.options.container);
+ var $content = this.$popover.find('.popover-content,.note-popover-content');
+ this.context.invoke('buttons.build', $content, this.options.popover.image);
+ this.$popover.on('mousedown', function (e) {
+ e.preventDefault();
+ });
+ }
+ }, {
+ key: "destroy",
+ value: function destroy() {
+ this.$popover.remove();
+ }
+ }, {
+ key: "update",
+ value: function update(target, event) {
+ if (dom.isImg(target)) {
+ var position = external_jQuery_default()(target).offset();
+ var containerOffset = external_jQuery_default()(this.options.container).offset();
+ var pos = {};
+
+ if (this.options.popatmouse) {
+ pos.left = event.pageX - 20;
+ pos.top = event.pageY;
+ } else {
+ pos = position;
+ }
+
+ pos.top -= containerOffset.top;
+ pos.left -= containerOffset.left;
+ this.$popover.css({
+ display: 'block',
+ left: pos.left,
+ top: pos.top
+ });
+ } else {
+ this.hide();
+ }
+ }
+ }, {
+ key: "hide",
+ value: function hide() {
+ this.$popover.hide();
+ }
+ }]);
+
+ return ImagePopover;
+}();
+
+
+;// CONCATENATED MODULE: ./src/js/module/TablePopover.js
+function TablePopover_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function TablePopover_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function TablePopover_createClass(Constructor, protoProps, staticProps) { if (protoProps) TablePopover_defineProperties(Constructor.prototype, protoProps); if (staticProps) TablePopover_defineProperties(Constructor, staticProps); return Constructor; }
+
+
+
+
+
+
+var TablePopover = /*#__PURE__*/function () {
+ function TablePopover(context) {
+ var _this = this;
+
+ TablePopover_classCallCheck(this, TablePopover);
+
+ this.context = context;
+ this.ui = (external_jQuery_default()).summernote.ui;
+ this.options = context.options;
+ this.events = {
+ 'summernote.mousedown': function summernoteMousedown(we, e) {
+ _this.update(e.target);
+ },
+ 'summernote.keyup summernote.scroll summernote.change': function summernoteKeyupSummernoteScrollSummernoteChange() {
+ _this.update();
+ },
+ 'summernote.disable summernote.dialog.shown': function summernoteDisableSummernoteDialogShown() {
+ _this.hide();
+ },
+ 'summernote.blur': function summernoteBlur(we, e) {
+ if (e.originalEvent && e.originalEvent.relatedTarget) {
+ if (!_this.$popover[0].contains(e.originalEvent.relatedTarget)) {
+ _this.hide();
+ }
+ } else {
+ _this.hide();
+ }
+ }
+ };
+ }
+
+ TablePopover_createClass(TablePopover, [{
+ key: "shouldInitialize",
+ value: function shouldInitialize() {
+ return !lists.isEmpty(this.options.popover.table);
+ }
+ }, {
+ key: "initialize",
+ value: function initialize() {
+ this.$popover = this.ui.popover({
+ className: 'note-table-popover'
+ }).render().appendTo(this.options.container);
+ var $content = this.$popover.find('.popover-content,.note-popover-content');
+ this.context.invoke('buttons.build', $content, this.options.popover.table); // [workaround] Disable Firefox's default table editor
+
+ if (env.isFF) {
+ document.execCommand('enableInlineTableEditing', false, false);
+ }
+
+ this.$popover.on('mousedown', function (e) {
+ e.preventDefault();
+ });
+ }
+ }, {
+ key: "destroy",
+ value: function destroy() {
+ this.$popover.remove();
+ }
+ }, {
+ key: "update",
+ value: function update(target) {
+ if (this.context.isDisabled()) {
+ return false;
+ }
+
+ var isCell = dom.isCell(target) || dom.isCell(target === null || target === void 0 ? void 0 : target.parentElement);
+
+ if (isCell) {
+ var pos = dom.posFromPlaceholder(target);
+ var containerOffset = external_jQuery_default()(this.options.container).offset();
+ pos.top -= containerOffset.top;
+ pos.left -= containerOffset.left;
+ this.$popover.css({
+ display: 'block',
+ left: pos.left,
+ top: pos.top
+ });
+ } else {
+ this.hide();
+ }
+
+ return isCell;
+ }
+ }, {
+ key: "hide",
+ value: function hide() {
+ this.$popover.hide();
+ }
+ }]);
+
+ return TablePopover;
+}();
+
+
+;// CONCATENATED MODULE: ./src/js/module/VideoDialog.js
+function VideoDialog_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function VideoDialog_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function VideoDialog_createClass(Constructor, protoProps, staticProps) { if (protoProps) VideoDialog_defineProperties(Constructor.prototype, protoProps); if (staticProps) VideoDialog_defineProperties(Constructor, staticProps); return Constructor; }
+
+
+
+
+
+var VideoDialog = /*#__PURE__*/function () {
+ function VideoDialog(context) {
+ VideoDialog_classCallCheck(this, VideoDialog);
+
+ this.context = context;
+ this.ui = (external_jQuery_default()).summernote.ui;
+ this.$body = external_jQuery_default()(document.body);
+ this.$editor = context.layoutInfo.editor;
+ this.options = context.options;
+ this.lang = this.options.langInfo;
+ }
+
+ VideoDialog_createClass(VideoDialog, [{
+ key: "initialize",
+ value: function initialize() {
+ var $container = this.options.dialogsInBody ? this.$body : this.options.container;
+ var body = ['', ""), ""), '
'].join('');
+ var buttonClass = 'btn btn-primary note-btn note-btn-primary note-video-btn';
+ var footer = "");
+ this.$dialog = this.ui.dialog({
+ title: this.lang.video.insert,
+ fade: this.options.dialogsFade,
+ body: body,
+ footer: footer
+ }).render().appendTo($container);
+ }
+ }, {
+ key: "destroy",
+ value: function destroy() {
+ this.ui.hideDialog(this.$dialog);
+ this.$dialog.remove();
+ }
+ }, {
+ key: "bindEnterKey",
+ value: function bindEnterKey($input, $btn) {
+ $input.on('keypress', function (event) {
+ if (event.keyCode === key.code.ENTER) {
+ event.preventDefault();
+ $btn.trigger('click');
+ }
+ });
+ }
+ }, {
+ key: "createVideoNode",
+ value: function createVideoNode(url) {
+ // video url patterns(youtube, instagram, vimeo, dailymotion, youku, peertube, mp4, ogg, webm)
+ var ytRegExp = /\/\/(?:(?:www|m)\.)?(?:youtu\.be\/|youtube\.com\/(?:embed\/|v\/|watch\?v=|watch\?.+&v=))([\w|-]{11})(?:(?:[\?&]t=)(\S+))?$/;
+ var ytRegExpForStart = /^(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$/;
+ var ytMatch = url.match(ytRegExp);
+ var gdRegExp = /(?:\.|\/\/)drive\.google\.com\/file\/d\/(.[a-zA-Z0-9_-]*)\/view/;
+ var gdMatch = url.match(gdRegExp);
+ var igRegExp = /(?:www\.|\/\/)instagram\.com\/p\/(.[a-zA-Z0-9_-]*)/;
+ var igMatch = url.match(igRegExp);
+ var vRegExp = /\/\/vine\.co\/v\/([a-zA-Z0-9]+)/;
+ var vMatch = url.match(vRegExp);
+ var vimRegExp = /\/\/(player\.)?vimeo\.com\/([a-z]*\/)*(\d+)[?]?.*/;
+ var vimMatch = url.match(vimRegExp);
+ var dmRegExp = /.+dailymotion.com\/(video|hub)\/([^_]+)[^#]*(#video=([^_&]+))?/;
+ var dmMatch = url.match(dmRegExp);
+ var youkuRegExp = /\/\/v\.youku\.com\/v_show\/id_(\w+)=*\.html/;
+ var youkuMatch = url.match(youkuRegExp);
+ var peerTubeRegExp = /\/\/(.*)\/videos\/watch\/([^?]*)(?:\?(?:start=(\w*))?(?:&stop=(\w*))?(?:&loop=([10]))?(?:&autoplay=([10]))?(?:&muted=([10]))?)?/;
+ var peerTubeMatch = url.match(peerTubeRegExp);
+ var qqRegExp = /\/\/v\.qq\.com.*?vid=(.+)/;
+ var qqMatch = url.match(qqRegExp);
+ var qqRegExp2 = /\/\/v\.qq\.com\/x?\/?(page|cover).*?\/([^\/]+)\.html\??.*/;
+ var qqMatch2 = url.match(qqRegExp2);
+ var mp4RegExp = /^.+.(mp4|m4v)$/;
+ var mp4Match = url.match(mp4RegExp);
+ var oggRegExp = /^.+.(ogg|ogv)$/;
+ var oggMatch = url.match(oggRegExp);
+ var webmRegExp = /^.+.(webm)$/;
+ var webmMatch = url.match(webmRegExp);
+ var fbRegExp = /(?:www\.|\/\/)facebook\.com\/([^\/]+)\/videos\/([0-9]+)/;
+ var fbMatch = url.match(fbRegExp);
+ var $video;
+
+ if (ytMatch && ytMatch[1].length === 11) {
+ var youtubeId = ytMatch[1];
+ var start = 0;
+
+ if (typeof ytMatch[2] !== 'undefined') {
+ var ytMatchForStart = ytMatch[2].match(ytRegExpForStart);
+
+ if (ytMatchForStart) {
+ for (var n = [3600, 60, 1], i = 0, r = n.length; i < r; i++) {
+ start += typeof ytMatchForStart[i + 1] !== 'undefined' ? n[i] * parseInt(ytMatchForStart[i + 1], 10) : 0;
+ }
+ }
+ }
+
+ $video = external_jQuery_default()('