] const 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 ? dom_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 const pred = isInline ? isPara : isBodyContainer; const ancestors = listAncestor(point.node, pred); const topAncestor = lists.last(ancestors) || point.node; let 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 let 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); } const parent = node.parentNode; if (!isRemoveChild) { const nodes = []; for (let i = 0, len = node.childNodes.length; i < len; i++) { nodes.push(node.childNodes[i]); } for (let 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; } const 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; } const 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; } const isTextarea = makePredByNodeName('TEXTAREA'); /** * @param {jQuery} $node * @param {Boolean} [stripLinebreaks] - default: false */ function dom_value($node, stripLinebreaks) { const 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 dom_html($node, isNewlineOnBlock) { let markup = dom_value($node); if (isNewlineOnBlock) { const regexTag = /<(\/?)(\b(?!!)[^>\s]*)(.*?)(\s*\/?>)/g; markup = markup.replace(regexTag, function (match, endSlash, name) { name = name.toUpperCase(); const isEndOfInlineContainer = /^DIV|^TD|^TH|^P|^LI|^H[1-7]/.test(name) && !!endSlash; const isBlockNode = /^BLOCKQUOTE|^TABLE|^TBODY|^TR|^HR|^UL|^OL/.test(name); return match + (isEndOfInlineContainer || isBlockNode ? '\n' : ''); }); markup = markup.trim(); } return markup; } function posFromPlaceholder(placeholder) { const $placeholder = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(placeholder); const pos = $placeholder.offset(); const 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 */ var dom = ({ /** @property {String} NBSP_CHAR */ NBSP_CHAR, /** @property {String} ZERO_WIDTH_NBSP_CHAR */ ZERO_WIDTH_NBSP_CHAR, /** @property {String} blank */ blank: blankHTML, /** @property {String} emptyPara */ emptyPara: `
${blankHTML}
`, makePredByNodeName, isEditable, isControlSizing, isText, isElement, isVoid, isPara, isPurePara, isHeading, isInline: dom_isInline, isBlock: func.not(dom_isInline), isBodyInline, isBody, isParaInline, isPre, isList, isTable, isData, isCell: dom_isCell, isBlockquote, isBodyContainer, isAnchor, isDiv: makePredByNodeName('DIV'), isLi, isBR: makePredByNodeName('BR'), isSpan: makePredByNodeName('SPAN'), isB: makePredByNodeName('B'), isU: makePredByNodeName('U'), isS: makePredByNodeName('S'), isI: makePredByNodeName('I'), isImg: makePredByNodeName('IMG'), isTextarea, deepestChildIsEmpty, isEmpty: dom_isEmpty, isEmptyAnchor: func.and(isAnchor, dom_isEmpty), isClosestSibling, withClosestSiblings, nodeLength, isLeftEdgePoint, isRightEdgePoint, isEdgePoint, isLeftEdgeOf, isRightEdgeOf, isLeftEdgePointOf, isRightEdgePointOf, prevPoint: dom_prevPoint, nextPoint: dom_nextPoint, isSamePoint, isVisiblePoint, prevPointUntil, nextPointUntil, isCharPoint, isSpacePoint, walkPoint, ancestor: dom_ancestor, singleChildAncestor, listAncestor, lastAncestor, listNext, listPrev, listDescendant, commonAncestor, wrap, insertAfter, appendChildNodes, position: dom_position, hasChildren, makeOffsetPath, fromOffsetPath, splitTree, splitPoint, create, createText, remove, removeWhile, replace, html: dom_html, value: dom_value, posFromPlaceholder, attachEvents, detachEvents, isCustomStyleTag }); // CONCATENATED MODULE: ./src/js/base/Context.js class Context_Context { /** * @param {jQuery} $note * @param {Object} options */ constructor($note, options) { this.$note = $note; this.memos = {}; this.modules = {}; this.layoutInfo = {}; this.options = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.extend(true, {}, options); // init ui with options external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui_template(this.options); this.ui = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui; this.initialize(); } /** * create layout and initialize modules and other resources */ initialize() { this.layoutInfo = this.ui.createLayout(this.$note); this._initialize(); this.$note.hide(); return this; } /** * destroy modules and other resources and remove layout */ destroy() { this._destroy(); this.$note.removeData('summernote'); this.ui.removeLayout(this.$note, this.layoutInfo); } /** * destory modules and other resources and initialize it again */ reset() { const disabled = this.isDisabled(); this.code(dom.emptyPara); this._destroy(); this._initialize(); if (disabled) { this.disable(); } } _initialize() { // set own id this.options.id = func.uniqueId(external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.now()); // set default container for tooltips, popovers, and dialogs this.options.container = this.options.container || this.layoutInfo.editor; // add optional buttons const buttons = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.extend({}, this.options.buttons); Object.keys(buttons).forEach(key => { this.memo('button.' + key, buttons[key]); }); const modules = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.extend({}, this.options.modules, external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.plugins || {}); // add and initialize modules Object.keys(modules).forEach(key => { this.module(key, modules[key], true); }); Object.keys(this.modules).forEach(key => { this.initializeModule(key); }); } _destroy() { // destroy modules with reversed order Object.keys(this.modules).reverse().forEach(key => { this.removeModule(key); }); Object.keys(this.memos).forEach(key => { this.removeMemo(key); }); // trigger custom onDestroy callback this.triggerEvent('destroy', this); } code(html) { const 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.layoutInfo.codable.val(html); } else { this.layoutInfo.editable.html(html); } this.$note.val(html); this.triggerEvent('change', html, this.layoutInfo.editable); } } isDisabled() { return this.layoutInfo.editable.attr('contenteditable') === 'false'; } enable() { this.layoutInfo.editable.attr('contenteditable', true); this.invoke('toolbar.activate', true); this.triggerEvent('disable', false); this.options.editing = true; } 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); } triggerEvent() { const namespace = lists.head(arguments); const args = lists.tail(lists.from(arguments)); const callback = this.options.callbacks[func.namespaceToCamel(namespace, 'on')]; if (callback) { callback.apply(this.$note[0], args); } this.$note.trigger('summernote.' + namespace, args); } initializeModule(key) { const 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); } } module(key, ModuleClass, withoutIntialize) { if (arguments.length === 1) { return this.modules[key]; } this.modules[key] = new ModuleClass(this); if (!withoutIntialize) { this.initializeModule(key); } } removeModule(key) { const 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]; } memo(key, obj) { if (arguments.length === 1) { return this.memos[key]; } this.memos[key] = obj; } 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 */ createInvokeHandlerAndUpdateState(namespace, value) { return event => { this.createInvokeHandler(namespace, value)(event); this.invoke('buttons.updateCurrentStyle'); }; } createInvokeHandler(namespace, value) { return event => { event.preventDefault(); const $target = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(event.target); this.invoke(namespace, value || $target.closest('[data-value]').data('value'), $target); }; } invoke() { const namespace = lists.head(arguments); const args = lists.tail(lists.from(arguments)); const splits = namespace.split('.'); const hasSeparator = splits.length > 1; const moduleName = hasSeparator && lists.head(splits); const methodName = hasSeparator ? lists.last(splits) : lists.head(splits); const 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); } } } // CONCATENATED MODULE: ./src/js/summernote.js external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.fn.extend({ /** * Summernote API * * @param {Object|String} * @return {this} */ summernote: function () { const type = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.type(lists.head(arguments)); const isExternalAPICalled = type === 'string'; const hasInitOptions = type === 'object'; const options = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.extend({}, external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.options, hasInitOptions ? lists.head(arguments) : {}); // Update options options.langInfo = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.extend(true, {}, external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.lang['en-US'], external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.lang[options.lang]); options.icons = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.extend(true, {}, external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.options.icons, options.icons); options.tooltip = options.tooltip === 'auto' ? !env.isSupportTouch : options.tooltip; this.each((idx, note) => { const $note = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(note); if (!$note.data('summernote')) { const context = new Context_Context($note, options); $note.data('summernote', context); $note.data('summernote').triggerEvent('init', context.layoutInfo); } }); const $note = this.first(); if ($note.length) { const 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/base/core/range.js /** * 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) { let container = textRange.parentElement(); let offset; const tester = document.body.createTextRange(); let prevContainer; const 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])) { const textRangeStart = document.body.createTextRange(); let curTextNode = null; textRangeStart.moveToElementText(prevContainer || container); textRangeStart.collapse(!prevContainer); curTextNode = prevContainer ? prevContainer.nextSibling : container.firstChild; const pointTester = textRange.duplicate(); pointTester.setEndPoint('StartToStart', textRangeStart); let 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 const 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) { const textRangeInfo = function (container, offset) { let node, isCollapseToStart; if (dom.isText(container)) { const prevTextNodes = dom.listPrev(container, func.not(dom.isText)); const 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 }; }; const textRange = document.body.createTextRange(); const 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 */ class range_WrappedRange { constructor(sc, so, ec, eo) { 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 nativeRange() { if (env.isW3CRangeSupport) { const w3cRange = document.createRange(); w3cRange.setStart(this.sc, this.sc.data && this.so > this.sc.data.length ? 0 : this.so); w3cRange.setEnd(this.ec, this.sc.data ? Math.min(this.eo, this.sc.data.length) : this.eo); return w3cRange; } else { const textRange = pointToTextRange({ node: this.sc, offset: this.so }); textRange.setEndPoint('EndToEnd', pointToTextRange({ node: this.ec, offset: this.eo })); return textRange; } } getPoints() { return { sc: this.sc, so: this.so, ec: this.ec, eo: this.eo }; } getStartPoint() { return { node: this.sc, offset: this.so }; } getEndPoint() { return { node: this.ec, offset: this.eo }; } /** * select update visible range */ select() { const nativeRng = this.nativeRange(); if (env.isW3CRangeSupport) { const 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} */ scrollIntoView(container) { const height = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_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} */ normalize() { /** * @param {BoundaryPoint} point * @param {Boolean} isLeftToRight - true: prefer to choose right node * - false: prefer to choose left node * @return {BoundaryPoint} */ const getVisiblePoint = function (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 const block = dom.ancestor(point.node, dom.isBlock); let hasRightNode = false; if (!hasRightNode) { const prevPoint = dom.prevPoint(point) || { node: null }; hasRightNode = (dom.isLeftEdgePointOf(point, block) || dom.isVoid(prevPoint.node)) && !isLeftToRight; } let hasLeftNode = false; if (!hasLeftNode) { const 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; } const nextPoint = isLeftToRight ? dom.nextPointUntil(dom.nextPoint(point), dom.isVisiblePoint) : dom.prevPointUntil(dom.prevPoint(point), dom.isVisiblePoint); return nextPoint || point; }; const endPoint = getVisiblePoint(this.getEndPoint(), false); const startPoint = this.isCollapsed() ? endPoint : getVisiblePoint(this.getStartPoint(), true); return new range_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[]} */ nodes(pred, options) { pred = pred || func.ok; const includeAncestor = options && options.includeAncestor; const fullyContains = options && options.fullyContains; // TODO compare points and sort const startPoint = this.getStartPoint(); const endPoint = this.getEndPoint(); const nodes = []; const leftEdgeNodes = []; dom.walkPoint(startPoint, endPoint, function (point) { if (dom.isEditable(point.node)) { return; } let 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 */ commonAncestor() { return dom.commonAncestor(this.sc, this.ec); } /** * returns expanded range by pred * * @param {Function} pred - predicate function * @return {WrappedRange} */ expand(pred) { const startAncestor = dom.ancestor(this.sc, pred); const endAncestor = dom.ancestor(this.ec, pred); if (!startAncestor && !endAncestor) { return new range_WrappedRange(this.sc, this.so, this.ec, this.eo); } const boundaryPoints = this.getPoints(); if (startAncestor) { boundaryPoints.sc = startAncestor; boundaryPoints.so = 0; } if (endAncestor) { boundaryPoints.ec = endAncestor; boundaryPoints.eo = dom.nodeLength(endAncestor); } return new range_WrappedRange(boundaryPoints.sc, boundaryPoints.so, boundaryPoints.ec, boundaryPoints.eo); } /** * @param {Boolean} isCollapseToStart * @return {WrappedRange} */ collapse(isCollapseToStart) { if (isCollapseToStart) { return new range_WrappedRange(this.sc, this.so, this.sc, this.so); } else { return new range_WrappedRange(this.ec, this.eo, this.ec, this.eo); } } /** * splitText on range */ splitText() { const isSameContainer = this.sc === this.ec; const 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 range_WrappedRange(boundaryPoints.sc, boundaryPoints.so, boundaryPoints.ec, boundaryPoints.eo); } /** * delete contents on range * @return {WrappedRange} */ deleteContents() { if (this.isCollapsed()) { return this; } const rng = this.splitText(); const nodes = rng.nodes(null, { fullyContains: true }); // find new cursor point const point = dom.prevPointUntil(rng.getStartPoint(), function (point) { return !lists.contains(nodes, point.node); }); const emptyParents = []; external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each(nodes, function (idx, node) { // find empty parents const parent = node.parentNode; if (point.node !== parent && dom.nodeLength(parent) === 1) { emptyParents.push(parent); } dom.remove(node, false); }); // remove empty parents external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each(emptyParents, function (idx, node) { dom.remove(node, false); }); return new range_WrappedRange(point.node, point.offset, point.node, point.offset).normalize(); } /** * makeIsOn: return isOn(pred) function */ makeIsOn(pred) { return function () { const ancestor = dom.ancestor(this.sc, pred); return !!ancestor && ancestor === dom.ancestor(this.ec, pred); }; } /** * @param {Function} pred * @return {Boolean} */ isLeftEdgeOf(pred) { if (!dom.isLeftEdgePoint(this.getStartPoint())) { return false; } const node = dom.ancestor(this.sc, pred); return node && dom.isLeftEdgeOf(this.sc, node); } /** * returns whether range was collapsed or not */ isCollapsed() { return this.sc === this.ec && this.so === this.eo; } /** * wrap inline nodes which children of body with paragraph * * @return {WrappedRange} */ wrapBodyInlineWithPara() { if (dom.isBodyContainer(this.sc) && dom.isEmpty(this.sc)) { this.sc.innerHTML = dom.emptyPara; return new range_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|
*/ const rng = this.normalize(); if (dom.isParaInline(this.sc) || dom.isPara(this.sc)) { return rng; } // find inline top ancestor let topAncestor; if (dom.isInline(rng.sc)) { const 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 let inlineSiblings = dom.listPrev(topAncestor, dom.isParaInline).reverse(); inlineSiblings = inlineSiblings.concat(dom.listNext(topAncestor.nextSibling, dom.isParaInline)); // wrap with paragraph if (inlineSiblings.length) { const 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} */ insertNode(node) { let rng = this; if (dom.isText(node) || dom.isInline(node)) { rng = this.wrapBodyInlineWithPara().deleteContents(); } const info = dom.splitPoint(rng.getStartPoint(), dom.isInline(node)); if (info.rightNode) { info.rightNode.parentNode.insertBefore(node, info.rightNode); } else { info.container.appendChild(node); } return node; } /** * insert html at current cursor */ pasteHTML(markup) { markup = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.trim(markup); const contentsContainer = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()('').html(markup)[0]; let childNodes = lists.from(contentsContainer.childNodes); // const rng = this.wrapBodyInlineWithPara().deleteContents(); const rng = this; if (rng.so >= 0) { childNodes = childNodes.reverse(); } childNodes = childNodes.map(function (childNode) { return rng.insertNode(childNode); }); if (rng.so > 0) { childNodes = childNodes.reverse(); } return childNodes; } /** * returns text in range * * @return {String} */ toString() { const 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} */ getWordRange(findAfter) { let endPoint = this.getEndPoint(); if (!dom.isCharPoint(endPoint)) { return this; } const startPoint = dom.prevPointUntil(endPoint, function (point) { return !dom.isCharPoint(point); }); if (findAfter) { endPoint = dom.nextPointUntil(endPoint, function (point) { return !dom.isCharPoint(point); }); } return new range_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} */ getWordsRange(findAfter) { var endPoint = this.getEndPoint(); var isNotTextPoint = function (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 range_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} */ 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 range_WrappedRange(point.node, point.offset, endPoint.node, endPoint.offset); var result = regex.exec(rng.toString()); return result && result.index === 0; }); var rng = new range_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 */ 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 */ 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[]} */ getClientRects() { const nativeRng = this.nativeRange(); return nativeRng.getClientRects(); } } /** * 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 */ var core_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 (sc, so, ec, eo) { if (arguments.length === 4) { return new range_WrappedRange(sc, so, ec, eo); } else if (arguments.length === 2) { // collapsed ec = sc; eo = so; return new range_WrappedRange(sc, so, ec, eo); } else { let wrappedRange = this.createFromSelection(); if (!wrappedRange && arguments.length === 1) { let bodyElement = arguments[0]; if (dom.isEditable(bodyElement)) { bodyElement = bodyElement.lastChild; } return this.createFromBodyElement(bodyElement, dom.emptyPara === arguments[0].innerHTML); } return wrappedRange; } }, createFromBodyElement: function (bodyElement, isCollapseToStart = false) { var wrappedRange = this.createFromNode(bodyElement); return wrappedRange.collapse(isCollapseToStart); }, createFromSelection: function () { let sc, so, ec, eo; if (env.isW3CRangeSupport) { const 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; } const nativeRng = selection.getRangeAt(0); sc = nativeRng.startContainer; so = nativeRng.startOffset; ec = nativeRng.endContainer; eo = nativeRng.endOffset; } else { // IE8: TextRange const textRange = document.selection.createRange(); const textRangeEnd = textRange.duplicate(); textRangeEnd.collapse(false); const textRangeStart = textRange; textRangeStart.collapse(true); let startPoint = textRangeToPoint(textRangeStart, true); let 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 range_WrappedRange(sc, so, ec, eo); }, /** * @method * * create WrappedRange from node * * @param {Node} node * @return {WrappedRange} */ createFromNode: function (node) { let sc = node; let so = 0; let ec = node; let 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 (node) { return this.createFromNode(node).collapse(true); }, /** * create WrappedRange from node after position * * @param {Node} node * @return {WrappedRange} */ createFromNodeAfter: function (node) { return this.createFromNode(node).collapse(); }, /** * @method * * create WrappedRange from bookmark * * @param {Node} editable * @param {Object} bookmark * @return {WrappedRange} */ createFromBookmark: function (editable, bookmark) { const sc = dom.fromOffsetPath(editable, bookmark.s.path); const so = bookmark.s.offset; const ec = dom.fromOffsetPath(editable, bookmark.e.path); const eo = bookmark.e.offset; return new range_WrappedRange(sc, so, ec, eo); }, /** * @method * * create WrappedRange from paraBookmark * * @param {Object} bookmark * @param {Node[]} paras * @return {WrappedRange} */ createFromParaBookmark: function (bookmark, paras) { const so = bookmark.s.offset; const eo = bookmark.e.offset; const sc = dom.fromOffsetPath(lists.head(paras), bookmark.s.path); const ec = dom.fromOffsetPath(lists.last(paras), bookmark.e.path); return new range_WrappedRange(sc, so, ec, eo); } }); // CONCATENATED MODULE: ./src/js/base/core/key.js const KEY_MAP = { 'BACKSPACE': 8, 'TAB': 9, 'ENTER': 13, '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 */ var core_key = ({ /** * @method isEdit * * @param {Number} keyCode * @return {Boolean} */ 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: 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: 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/base/core/async.js /** * @method readFileAsDataURL * * read contents of file as representing URL * * @param {File} file * @return {Promise} - then: dataUrl */ function readFileAsDataURL(file) { return external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.Deferred(deferred => { external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.extend(new FileReader(), { onload: e => { const dataURL = e.target.result; deferred.resolve(dataURL); }, 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[]}
*/
releaseList(clustereds, isEscapseToBody) {
let releasedParas = [];
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each(clustereds, (idx, paras) => {
const head = lists.head(paras);
const last = lists.last(paras);
const headList = isEscapseToBody ? dom.lastAncestor(head, dom.isList) : head.parentNode;
const parentItem = headList.parentNode;
if (headList.parentNode.nodeName === 'LI') {
paras.map(para => {
const newList = this.findNextSiblings(para);
if (parentItem.nextSibling) {
parentItem.parentNode.insertBefore(para, parentItem.nextSibling);
} else {
parentItem.parentNode.appendChild(para);
}
if (newList.length) {
this.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 {
const lastList = headList.childNodes.length > 1 ? dom.splitTree(headList, {
node: last.parentNode,
offset: dom.position(last) + 1
}, {
isSkipPaddingBlankHTML: true
}) : null;
const 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(para => {
return dom.replace(para, 'P');
});
}
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each(lists.from(paras).reverse(), (idx, para) => {
dom.insertAfter(para, headList);
}); // remove empty lists
const rootLists = lists.compact([headList, middleList, lastList]);
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each(rootLists, (idx, rootList) => {
const listNodes = [rootList].concat(dom.listDescendant(rootList, dom.isList));
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each(listNodes.reverse(), (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}
*/
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[]}
*/
findList(node) {
return node ? lists.find(node.children, child => ['OL', 'UL'].indexOf(child.nodeName) > -1) : null;
}
/**
* @method findNextSiblings
*
* Finds all list item siblings that follow it
*
* @param {HTMLNode} ListItem
* @return {HTMLNode}
*/
findNextSiblings(node) {
const siblings = [];
while (node.nextSibling) {
siblings.push(node.nextSibling);
node = node.nextSibling;
}
return siblings;
}
}
// CONCATENATED MODULE: ./src/js/base/editing/Typing.js
/**
* @class editing.Typing
*
* Typing
*
*/
class Typing_Typing {
constructor(context) {
// a Bullet instance to toggle lists off
this.bullet = new Bullet_Bullet();
this.options = context.options;
}
/**
* insert tab
*
* @param {WrappedRange} rng
* @param {Number} tabsize
*/
insertTab(rng, tabsize) {
const tab = dom.createText(new Array(tabsize + 1).join(dom.NBSP_CHAR));
rng = rng.deleteContents();
rng.insertNode(tab, true);
rng = core_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)
*/
insertParagraph(editable, rng) {
rng = rng || core_range.create(editable); // deleteContents on range.
rng = rng.deleteContents(); // Wrap range if it needs to be wrapped by paragraph
rng = rng.wrapBodyInlineWithPara(); // finding paragraph
const splitRoot = dom.ancestor(rng.sc, dom.isPara);
let 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))) {
// toogle UL/OL and escape
this.bullet.toggleList(splitRoot.parentNode.nodeName);
return;
} else {
let 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_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_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_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(rng.sc.nextSibling).remove(); } const 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 let emptyAnchors = dom.listDescendant(splitRoot, dom.isEmptyAnchor); emptyAnchors = emptyAnchors.concat(dom.listDescendant(nextPara, dom.isEmptyAnchor)); external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each(emptyAnchors, (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 { const next = rng.sc.childNodes[rng.so]; nextPara = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(dom.emptyPara)[0]; if (next) { rng.sc.insertBefore(nextPara, next); } else { rng.sc.appendChild(nextPara); } } core_range.create(nextPara, 0).normalize().select().scrollIntoView(editable); } } // CONCATENATED MODULE: ./src/js/base/editing/Table.js /** * @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. */ const TableResultAction = function (startPoint, where, action, domTable) { const _startPoint = { 'colPos': 0, 'rowPos': 0 }; const _virtualTable = []; const _actionCellList = []; /// /////////////////////////////////////////// // Private functions /// /////////////////////////////////////////// /** * Set the startPoint of action. */ function setStartPoint() { if (!startPoint || !startPoint.tagName || startPoint.tagName.toLowerCase() !== 'td' && startPoint.tagName.toLowerCase() !== 'th') { console.error('Impossible to identify start Cell point.', startPoint); return; } _startPoint.colPos = startPoint.cellIndex; if (!startPoint.parentElement || !startPoint.parentElement.tagName || startPoint.parentElement.tagName.toLowerCase() !== 'tr') { console.error('Impossible to identify start Row point.', startPoint); 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) { const 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; } let 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) { const cellIndex = recoverCellIndex(row.rowIndex, cell.cellIndex); const cellHasColspan = cell.colSpan > 1; const cellHasRowspan = cell.rowSpan > 1; const isThisSelectedCell = row.rowIndex === _startPoint.rowPos && cell.cellIndex === _startPoint.colPos; setVirtualTablePosition(row.rowIndex, cellIndex, row, cell, cellHasRowspan, cellHasColspan, false); // Add span rows to virtual Table. const rowspanNumber = cell.attributes.rowSpan ? parseInt(cell.attributes.rowSpan.value, 10) : 0; if (rowspanNumber > 1) { for (let rp = 1; rp < rowspanNumber; rp++) { const rowspanIndex = row.rowIndex + rp; adjustStartPoint(rowspanIndex, cellIndex, cell, isThisSelectedCell); setVirtualTablePosition(rowspanIndex, cellIndex, row, cell, true, cellHasColspan, true); } } // Add span cols to virtual table. const colspanNumber = cell.attributes.colSpan ? parseInt(cell.attributes.colSpan.value, 10) : 0; if (colspanNumber > 1) { for (let cp = 1; cp < colspanNumber; cp++) { const 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() { const rows = domTable.rows; for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) { const cells = rows[rowIndex].cells; for (let 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 () { const fixedRow = where === TableResultAction.where.Row ? _startPoint.rowPos : -1; const fixedCol = where === TableResultAction.where.Column ? _startPoint.colPos : -1; let actualPosition = 0; let canContinue = true; while (canContinue) { const rowPosition = fixedRow >= 0 ? fixedRow : actualPosition; const colPosition = fixedCol >= 0 ? fixedCol : actualPosition; const row = _virtualTable[rowPosition]; if (!row) { canContinue = false; return _actionCellList; } const cell = row[colPosition]; if (!cell) { canContinue = false; return _actionCellList; } // Define action to be applied in this cell let 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 * */ class Table_Table { /** * handle tab key * * @param {WrappedRange} rng * @param {Boolean} isShift */ tab(rng, isShift) { const cell = dom.ancestor(rng.commonAncestor(), dom.isCell); const table = dom.ancestor(cell, dom.isTable); const cells = dom.listDescendant(table, dom.isCell); const nextCell = lists[isShift ? 'prev' : 'next'](cells, cell); if (nextCell) { core_range.create(nextCell, 0).select(); } } /** * Add a new row * * @param {WrappedRange} rng * @param {String} position (top/bottom) * @return {Node} */ addRow(rng, position) { const cell = dom.ancestor(rng.commonAncestor(), dom.isCell); const currentTr = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(cell).closest('tr'); const trAttributes = this.recoverAttributes(currentTr); const html = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()('
' + this.lang.output.noSelection + '
');
setTimeout(function () {
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()('#note-status-output-' + noteStatusOutput).remove();
}, 5000);
}
}
/**
* unlink
*
* @type command
*/
unlink() {
let rng = this.getLastRange();
if (rng.isOnAnchor()) {
const anchor = dom.ancestor(rng.sc, dom.isAnchor);
rng = core_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=""]
*/
getLinkInfo() {
const rng = this.getLastRange().expand(dom.isAnchor); // Get the first anchor on range(for edit).
const $anchor = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(lists.head(rng.nodes(dom.isAnchor)));
const 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;
}
addRow(position) {
const rng = this.getLastRange(this.$editable);
if (rng.isCollapsed() && rng.isOnCell()) {
this.beforeCommand();
this.table.addRow(rng, position);
this.afterCommand();
}
}
addCol(position) {
const rng = this.getLastRange(this.$editable);
if (rng.isCollapsed() && rng.isOnCell()) {
this.beforeCommand();
this.table.addCol(rng, position);
this.afterCommand();
}
}
deleteRow() {
const rng = this.getLastRange(this.$editable);
if (rng.isCollapsed() && rng.isOnCell()) {
this.beforeCommand();
this.table.deleteRow(rng);
this.afterCommand();
}
}
deleteCol() {
const rng = this.getLastRange(this.$editable);
if (rng.isCollapsed() && rng.isOnCell()) {
this.beforeCommand();
this.table.deleteCol(rng);
this.afterCommand();
}
}
deleteTable() {
const 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
*/
resizeTo(pos, $target, bKeepRatio) {
let imageSize;
if (bKeepRatio) {
const newRatio = pos.y / pos.x;
const 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.
*/
hasFocus() {
return this.$editable.is(':focus');
}
/**
* set focus
*/
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}
*/
isEmpty() {
return dom.isEmpty(this.$editable[0]) || dom.emptyPara === this.$editable.html();
}
/**
* Removes all contents and restores the editable instance to an _emptyPara_.
*/
empty() {
this.context.invoke('code', dom.emptyPara);
}
/**
* normalize content
*/
normalizeContent() {
this.$editable[0].normalize();
}
}
// CONCATENATED MODULE: ./src/js/base/module/Clipboard.js
class Clipboard_Clipboard {
constructor(context) {
this.context = context;
this.$editable = context.layoutInfo.editable;
}
initialize() {
this.$editable.on('paste', this.pasteByEvent.bind(this));
}
/**
* paste by clipboard event
*
* @param {Event} event
*/
pasteByEvent(event) {
const clipboardData = event.originalEvent.clipboardData;
if (clipboardData && clipboardData.items && clipboardData.items.length) {
const 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();
this.context.invoke('editor.afterCommand');
} else if (item.kind === 'string') {
// paste text with maxTextLength check
if (this.context.invoke('editor.isLimited', clipboardData.getData('Text').length)) {
event.preventDefault();
} else {
this.context.invoke('editor.afterCommand');
}
}
}
}
}
// CONCATENATED MODULE: ./src/js/base/module/Dropzone.js
class Dropzone_Dropzone {
constructor(context) {
this.context = context;
this.$eventListener = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_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_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(['', '', '
'].join('')).prependTo(this.$editor);
}
/**
* attach Drag and Drop Events
*/
initialize() {
if (this.options.disableDragAndDrop) {
// prevent default drop event
this.documentEventHandlers.onDrop = 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
*/
attachDragAndDropEvent() {
let collection = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()();
const $dropzoneMessage = this.$dropzone.find('.note-dropzone-message');
this.documentEventHandlers.onDragenter = e => {
const isCodeview = this.context.invoke('codeview.isActivated');
const 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 = 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_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()();
this.$editor.removeClass('dragover');
}
};
this.documentEventHandlers.onDrop = () => {
collection = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_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', () => {
this.$dropzone.addClass('hover');
$dropzoneMessage.text(this.lang.image.dropImage);
}).on('dragleave', () => {
this.$dropzone.removeClass('hover');
$dropzoneMessage.text(this.lang.image.dragImageHere);
}); // attach dropImage
this.$dropzone.on('drop', event => {
const 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_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each(dataTransfer.types, (idx, type) => {
// skip moz-specific types
if (type.toLowerCase().indexOf('_moz_') > -1) {
return;
}
const content = dataTransfer.getData(type);
if (type.toLowerCase().indexOf('text') > -1) {
this.context.invoke('editor.pasteHTML', content);
} else {
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(content).each((idx, item) => {
this.context.invoke('editor.insertNode', item);
});
}
});
}
}).on('dragover', false); // prevent default dragover event
}
destroy() {
Object.keys(this.documentEventHandlers).forEach(key => {
this.$eventListener.off(key.substr(2).toLowerCase(), this.documentEventHandlers[key]);
});
this.documentEventHandlers = {};
}
}
// CONCATENATED MODULE: ./src/js/base/module/Codeview.js
let CodeMirror;
if (env.hasCodeMirror) {
CodeMirror = window.CodeMirror;
}
/**
* @class Codeview
*/
class Codeview_CodeView {
constructor(context) {
this.context = context;
this.$editor = context.layoutInfo.editor;
this.$editable = context.layoutInfo.editable;
this.$codable = context.layoutInfo.codable;
this.options = context.options;
}
sync() {
const isCodeview = this.isActivated();
if (isCodeview && env.hasCodeMirror) {
this.$codable.data('cmEditor').save();
}
}
/**
* @return {Boolean}
*/
isActivated() {
return this.$editor.hasClass('codeview');
}
/**
* toggle codeview
*/
toggle() {
if (this.isActivated()) {
this.deactivate();
} else {
this.activate();
}
this.context.triggerEvent('codeview.toggled');
}
/**
* purify input value
* @param value
* @returns {*}
*/
purify(value) {
if (this.options.codeviewFilter) {
// filter code view regex
value = value.replace(this.options.codeviewFilterRegex, ''); // allow specific iframe tag
if (this.options.codeviewIframeFilter) {
const whitelist = this.options.codeviewIframeWhitelistSrc.concat(this.options.codeviewIframeWhitelistSrcBase);
value = value.replace(/(', '
'].join('')).prependTo(this.$editingArea);
this.$handle.on('mousedown', event => {
if (dom.isControlSizing(event.target)) {
event.preventDefault();
event.stopPropagation();
const $target = this.$handle.find('.note-control-selection').data('target');
const posStart = $target.offset();
const scrollTop = this.$document.scrollTop();
const onMouseMove = event => {
this.context.invoke('editor.resizeTo', {
x: event.clientX - posStart.left,
y: event.clientY - (posStart.top - scrollTop)
}, $target, !event.shiftKey);
this.update($target[0], event);
};
this.$document.on('mousemove', onMouseMove).one('mouseup', e => {
e.preventDefault();
this.$document.off('mousemove', onMouseMove);
this.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', e => {
e.preventDefault();
this.update();
});
}
destroy() {
this.$handle.remove();
}
update(target, event) {
if (this.context.isDisabled()) {
return false;
}
const isImage = dom.isImg(target);
const $selection = this.$handle.find('.note-control-selection');
this.context.invoke('imagePopover.update', target, event);
if (isImage) {
const $image = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(target);
const position = $image.position();
const pos = {
left: position.left + parseInt($image.css('marginLeft'), 10),
top: position.top + parseInt($image.css('marginTop'), 10)
}; // exclude margin
const 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.
const origImageObj = new Image();
origImageObj.src = $image.attr('src');
const 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
*/
hide() {
this.context.invoke('editor.clearTarget');
this.$handle.children().hide();
}
}
// CONCATENATED MODULE: ./src/js/base/module/AutoLink.js
const defaultScheme = 'http://';
const linkPattern = /^([A-Za-z][A-Za-z0-9+-.]*\:[\/]{2}|tel:|mailto:[A-Z0-9._%+-]+@)?(www\.)?(.+)$/i;
class AutoLink_AutoLink {
constructor(context) {
this.context = context;
this.events = {
'summernote.keyup': (we, e) => {
if (!e.isDefaultPrevented()) {
this.handleKeyup(e);
}
},
'summernote.keydown': (we, e) => {
this.handleKeydown(e);
}
};
}
initialize() {
this.lastWordRange = null;
}
destroy() {
this.lastWordRange = null;
}
replace() {
if (!this.lastWordRange) {
return;
}
const keyword = this.lastWordRange.toString();
const match = keyword.match(linkPattern);
if (match && (match[1] || match[2])) {
const link = match[1] ? keyword : defaultScheme + keyword;
const urlText = keyword.replace(/^(?:https?:\/\/)?(?:tel?:?)?(?:mailto?:?)?(?:www\.)?/i, '').split('/')[0];
const node = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()('').html(urlText).attr('href', link)[0];
if (this.context.options.linkTargetBlank) {
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(node).attr('target', '_blank');
}
this.lastWordRange.insertNode(node);
this.lastWordRange = null;
this.context.invoke('editor.focus');
}
}
handleKeydown(e) {
if (lists.contains([core_key.code.ENTER, core_key.code.SPACE], e.keyCode)) {
const wordRange = this.context.invoke('editor.createRange').getWordRange();
this.lastWordRange = wordRange;
}
}
handleKeyup(e) {
if (lists.contains([core_key.code.ENTER, core_key.code.SPACE], e.keyCode)) {
this.replace();
}
}
}
// CONCATENATED MODULE: ./src/js/base/module/AutoSync.js
/**
* textarea auto sync.
*/
class AutoSync_AutoSync {
constructor(context) {
this.$note = context.layoutInfo.note;
this.events = {
'summernote.change': () => {
this.$note.val(context.invoke('code'));
}
};
}
shouldInitialize() {
return dom.isTextarea(this.$note[0]);
}
}
// CONCATENATED MODULE: ./src/js/base/module/AutoReplace.js
class AutoReplace_AutoReplace {
constructor(context) {
this.context = context;
this.options = context.options.replace || {};
this.keys = [core_key.code.ENTER, core_key.code.SPACE, core_key.code.PERIOD, core_key.code.COMMA, core_key.code.SEMICOLON, core_key.code.SLASH];
this.previousKeydownCode = null;
this.events = {
'summernote.keyup': (we, e) => {
if (!e.isDefaultPrevented()) {
this.handleKeyup(e);
}
},
'summernote.keydown': (we, e) => {
this.handleKeydown(e);
}
};
}
shouldInitialize() {
return !!this.options.match;
}
initialize() {
this.lastWord = null;
}
destroy() {
this.lastWord = null;
}
replace() {
if (!this.lastWord) {
return;
}
const self = this;
const keyword = this.lastWord.toString();
this.options.match(keyword, function (match) {
if (match) {
let 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');
}
});
}
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)) {
const wordRange = this.context.invoke('editor.createRange').getWordRange();
this.lastWord = wordRange;
}
this.previousKeydownCode = e.keyCode;
}
handleKeyup(e) {
if (lists.contains(this.keys, e.keyCode)) {
this.replace();
}
}
}
// CONCATENATED MODULE: ./src/js/base/module/Placeholder.js
class Placeholder_Placeholder {
constructor(context) {
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': () => {
this.update();
},
'summernote.codeview.toggled': () => {
this.update();
}
};
}
shouldInitialize() {
return !!this.options.placeholder;
}
initialize() {
this.$placeholder = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()('', '', '', '', '', '', this.options.disableResizeImage ? '' : '', '
', '');
this.$placeholder.on('click', () => {
this.context.invoke('focus');
}).html(this.options.placeholder).prependTo(this.$editingArea);
this.update();
}
destroy() {
this.$placeholder.remove();
}
update() {
const isShow = !this.context.invoke('codeview.isActivated') && this.context.invoke('editor.isEmpty');
this.$placeholder.toggle(isShow);
}
}
// CONCATENATED MODULE: ./src/js/base/module/Buttons.js
class Buttons_Buttons {
constructor(context) {
this.ui = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.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']);
}
representShortcut(editorMethod) {
let 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 + ')';
}
button(o) {
if (!this.options.tooltip && o.tooltip) {
delete o.tooltip;
}
o.container = this.options.container;
return this.ui.button(o);
}
initialize() {
this.addToolbarButtons();
this.addImagePopoverButtons();
this.addLinkPopoverButtons();
this.addTablePopoverButtons();
this.fontInstalledMap = {};
}
destroy() {
delete this.fontInstalledMap;
}
isFontInstalled(name) {
if (!this.fontInstalledMap.hasOwnProperty(name)) {
this.fontInstalledMap[name] = env.isFontInstalled(name) || lists.contains(this.options.fontNamesIgnoreCheck, name);
}
return this.fontInstalledMap[name];
}
isFontDeservedToAdd(name) {
name = name.toLowerCase();
return name !== '' && this.isFontInstalled(name) && env.genericFontFamilies.indexOf(name) === -1;
}
colorPalette(className, tooltip, backColor, foreColor) {
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: e => {
const $button = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_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: $button => {
const $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 ? ['
', '
'].join('') : '') + (foreColor ? ['' + this.lang.color.background + '
', '', '', '
', '', '', '', '', '
', '', '', '
'].join('') : ''),
callback: $dropdown => {
$dropdown.find('.note-holder').each((idx, item) => {
const $holder = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_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((idx, item) => {
const $holder = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_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((idx, item) => {
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(item).change(function () {
const $chip = $dropdown.find('#' + external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(this).data('event')).find('.note-color-btn').first();
const 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: event => {
event.stopPropagation();
const $parent = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()('.' + className).find('.show');
const $button = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(event.target);
const eventName = $button.data('event');
let value = $button.attr('data-value');
if (eventName === 'openPalette') {
const $picker = $parent.find('#' + value);
const $palette = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()($parent.find('#' + $picker.data('event')).find('.note-color-row')[0]); // Shift palette chips
const $chip = $palette.find('.note-color-btn').last().detach(); // Set chip attributes
const 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)) {
const key = eventName === 'backColor' ? 'background-color' : 'color';
const $color = $button.closest('.note-color').find('.note-recent-color');
const $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();
}
addToolbarButtons() {
this.context.memo('button.style', () => {
return this.ui.buttonGroup([this.button({
className: 'dropdown-toggle',
contents: this.ui.dropdownButtonContents(this.ui.icon(this.options.icons.magic), this.options),
tooltip: this.lang.style.style,
data: {
toggle: 'dropdown'
}
}), this.ui.dropdown({
className: 'dropdown-style',
items: this.options.styleTags,
title: this.lang.style.style,
template: item => {
if (typeof item === 'string') {
item = {
tag: item,
title: this.lang.style.hasOwnProperty(item) ? this.lang.style[item] : item
};
}
const tag = item.tag;
const title = item.title;
const style = item.style ? ' style="' + item.style + '" ' : '';
const className = item.className ? ' class="' + item.className + '"' : '';
return '<' + tag + style + className + '>' + title + '';
},
click: this.context.createInvokeHandler('editor.formatBlock')
})]).render();
});
for (let styleIdx = 0, styleLen = this.options.styleTags.length; styleIdx < styleLen; styleIdx++) {
const item = this.options.styleTags[styleIdx];
this.context.memo('button.style.' + item, () => {
return this.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: this.lang.style[item],
click: this.context.createInvokeHandler('editor.formatBlock')
}).render();
});
}
this.context.memo('button.bold', () => {
return this.button({
className: 'note-btn-bold',
contents: this.ui.icon(this.options.icons.bold),
tooltip: this.lang.font.bold + this.representShortcut('bold'),
click: this.context.createInvokeHandlerAndUpdateState('editor.bold')
}).render();
});
this.context.memo('button.italic', () => {
return this.button({
className: 'note-btn-italic',
contents: this.ui.icon(this.options.icons.italic),
tooltip: this.lang.font.italic + this.representShortcut('italic'),
click: this.context.createInvokeHandlerAndUpdateState('editor.italic')
}).render();
});
this.context.memo('button.underline', () => {
return this.button({
className: 'note-btn-underline',
contents: this.ui.icon(this.options.icons.underline),
tooltip: this.lang.font.underline + this.representShortcut('underline'),
click: this.context.createInvokeHandlerAndUpdateState('editor.underline')
}).render();
});
this.context.memo('button.clear', () => {
return this.button({
contents: this.ui.icon(this.options.icons.eraser),
tooltip: this.lang.font.clear + this.representShortcut('removeFormat'),
click: this.context.createInvokeHandler('editor.removeFormat')
}).render();
});
this.context.memo('button.strikethrough', () => {
return this.button({
className: 'note-btn-strikethrough',
contents: this.ui.icon(this.options.icons.strikethrough),
tooltip: this.lang.font.strikethrough + this.representShortcut('strikethrough'),
click: this.context.createInvokeHandlerAndUpdateState('editor.strikethrough')
}).render();
});
this.context.memo('button.superscript', () => {
return this.button({
className: 'note-btn-superscript',
contents: this.ui.icon(this.options.icons.superscript),
tooltip: this.lang.font.superscript,
click: this.context.createInvokeHandlerAndUpdateState('editor.superscript')
}).render();
});
this.context.memo('button.subscript', () => {
return this.button({
className: 'note-btn-subscript',
contents: this.ui.icon(this.options.icons.subscript),
tooltip: this.lang.font.subscript,
click: this.context.createInvokeHandlerAndUpdateState('editor.subscript')
}).render();
});
this.context.memo('button.fontname', () => {
const styleInfo = this.context.invoke('editor.currentStyle');
if (this.options.addDefaultFonts) {
// Add 'default' fonts into the fontnames array if not exist
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each(styleInfo['font-family'].split(','), (idx, fontname) => {
fontname = fontname.trim().replace(/['"]+/g, '');
if (this.isFontDeservedToAdd(fontname)) {
if (this.options.fontNames.indexOf(fontname) === -1) {
this.options.fontNames.push(fontname);
}
}
});
}
return this.ui.buttonGroup([this.button({
className: 'dropdown-toggle',
contents: this.ui.dropdownButtonContents('', this.options),
tooltip: this.lang.font.name,
data: {
toggle: 'dropdown'
}
}), this.ui.dropdownCheck({
className: 'dropdown-fontname',
checkClassName: this.options.icons.menuCheck,
items: this.options.fontNames.filter(this.isFontInstalled.bind(this)),
title: this.lang.font.name,
template: item => {
return '' + item + '';
},
click: this.context.createInvokeHandlerAndUpdateState('editor.fontName')
})]).render();
});
this.context.memo('button.fontsize', () => {
return this.ui.buttonGroup([this.button({
className: 'dropdown-toggle',
contents: this.ui.dropdownButtonContents('', this.options),
tooltip: this.lang.font.size,
data: {
toggle: 'dropdown'
}
}), this.ui.dropdownCheck({
className: 'dropdown-fontsize',
checkClassName: this.options.icons.menuCheck,
items: this.options.fontSizes,
title: this.lang.font.size,
click: this.context.createInvokeHandlerAndUpdateState('editor.fontSize')
})]).render();
});
this.context.memo('button.fontsizeunit', () => {
return this.ui.buttonGroup([this.button({
className: 'dropdown-toggle',
contents: this.ui.dropdownButtonContents('', this.options),
tooltip: this.lang.font.sizeunit,
data: {
toggle: 'dropdown'
}
}), this.ui.dropdownCheck({
className: 'dropdown-fontsizeunit',
checkClassName: this.options.icons.menuCheck,
items: this.options.fontSizeUnits,
title: this.lang.font.sizeunit,
click: this.context.createInvokeHandlerAndUpdateState('editor.fontSizeUnit')
})]).render();
});
this.context.memo('button.color', () => {
return this.colorPalette('note-color-all', this.lang.color.recent, true, true);
});
this.context.memo('button.forecolor', () => {
return this.colorPalette('note-color-fore', this.lang.color.foreground, false, true);
});
this.context.memo('button.backcolor', () => {
return this.colorPalette('note-color-back', this.lang.color.background, true, false);
});
this.context.memo('button.ul', () => {
return this.button({
contents: this.ui.icon(this.options.icons.unorderedlist),
tooltip: this.lang.lists.unordered + this.representShortcut('insertUnorderedList'),
click: this.context.createInvokeHandler('editor.insertUnorderedList')
}).render();
});
this.context.memo('button.ol', () => {
return this.button({
contents: this.ui.icon(this.options.icons.orderedlist),
tooltip: this.lang.lists.ordered + this.representShortcut('insertOrderedList'),
click: this.context.createInvokeHandler('editor.insertOrderedList')
}).render();
});
const 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')
});
const 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')
});
const 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')
});
const 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')
});
const 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')
});
const 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', () => {
return this.ui.buttonGroup([this.button({
className: 'dropdown-toggle',
contents: this.ui.dropdownButtonContents(this.ui.icon(this.options.icons.alignLeft), this.options),
tooltip: this.lang.paragraph.paragraph,
data: {
toggle: 'dropdown'
}
}), this.ui.dropdown([this.ui.buttonGroup({
className: 'note-align',
children: [justifyLeft, justifyCenter, justifyRight, justifyFull]
}), this.ui.buttonGroup({
className: 'note-list',
children: [outdent, indent]
})])]).render();
});
this.context.memo('button.height', () => {
return this.ui.buttonGroup([this.button({
className: 'dropdown-toggle',
contents: this.ui.dropdownButtonContents(this.ui.icon(this.options.icons.textHeight), this.options),
tooltip: this.lang.font.height,
data: {
toggle: 'dropdown'
}
}), this.ui.dropdownCheck({
items: this.options.lineHeights,
checkClassName: this.options.icons.menuCheck,
className: 'dropdown-line-height',
title: this.lang.font.height,
click: this.context.createInvokeHandler('editor.lineHeight')
})]).render();
});
this.context.memo('button.table', () => {
return this.ui.buttonGroup([this.button({
className: 'dropdown-toggle',
contents: this.ui.dropdownButtonContents(this.ui.icon(this.options.icons.table), this.options),
tooltip: this.lang.table.table,
data: {
toggle: 'dropdown'
}
}), this.ui.dropdown({
title: this.lang.table.table,
className: 'note-table',
items: ['', '', '', '', '
', '1 x 1
'].join('')
})], {
callback: $node => {
const $catcher = $node.find('.note-dimension-picker-mousecatcher');
$catcher.css({
width: this.options.insertTableMaxSize.col + 'em',
height: this.options.insertTableMaxSize.row + 'em'
}).mousedown(this.context.createInvokeHandler('editor.insertTable')).on('mousemove', this.tableMoveHandler.bind(this));
}
}).render();
});
this.context.memo('button.link', () => {
return this.button({
contents: this.ui.icon(this.options.icons.link),
tooltip: this.lang.link.link + this.representShortcut('linkDialog.show'),
click: this.context.createInvokeHandler('linkDialog.show')
}).render();
});
this.context.memo('button.picture', () => {
return this.button({
contents: this.ui.icon(this.options.icons.picture),
tooltip: this.lang.image.image,
click: this.context.createInvokeHandler('imageDialog.show')
}).render();
});
this.context.memo('button.video', () => {
return this.button({
contents: this.ui.icon(this.options.icons.video),
tooltip: this.lang.video.video,
click: this.context.createInvokeHandler('videoDialog.show')
}).render();
});
this.context.memo('button.hr', () => {
return this.button({
contents: this.ui.icon(this.options.icons.minus),
tooltip: this.lang.hr.insert + this.representShortcut('insertHorizontalRule'),
click: this.context.createInvokeHandler('editor.insertHorizontalRule')
}).render();
});
this.context.memo('button.fullscreen', () => {
return this.button({
className: 'btn-fullscreen',
contents: this.ui.icon(this.options.icons.arrowsAlt),
tooltip: this.lang.options.fullscreen,
click: this.context.createInvokeHandler('fullscreen.toggle')
}).render();
});
this.context.memo('button.codeview', () => {
return this.button({
className: 'btn-codeview',
contents: this.ui.icon(this.options.icons.code),
tooltip: this.lang.options.codeview,
click: this.context.createInvokeHandler('codeview.toggle')
}).render();
});
this.context.memo('button.redo', () => {
return this.button({
contents: this.ui.icon(this.options.icons.redo),
tooltip: this.lang.history.redo + this.representShortcut('redo'),
click: this.context.createInvokeHandler('editor.redo')
}).render();
});
this.context.memo('button.undo', () => {
return this.button({
contents: this.ui.icon(this.options.icons.undo),
tooltip: this.lang.history.undo + this.representShortcut('undo'),
click: this.context.createInvokeHandler('editor.undo')
}).render();
});
this.context.memo('button.help', () => {
return this.button({
contents: this.ui.icon(this.options.icons.question),
tooltip: this.lang.options.help,
click: this.context.createInvokeHandler('helpDialog.show')
}).render();
});
}
/**
* image: [
* ['imageResize', ['resizeFull', 'resizeHalf', 'resizeQuarter', 'resizeNone']],
* ['float', ['floatLeft', 'floatRight', 'floatNone']],
* ['remove', ['removeMedia']],
* ],
*/
addImagePopoverButtons() {
// Image Size Buttons
this.context.memo('button.resizeFull', () => {
return this.button({
contents: '100%',
tooltip: this.lang.image.resizeFull,
click: this.context.createInvokeHandler('editor.resize', '1')
}).render();
});
this.context.memo('button.resizeHalf', () => {
return this.button({
contents: '50%',
tooltip: this.lang.image.resizeHalf,
click: this.context.createInvokeHandler('editor.resize', '0.5')
}).render();
});
this.context.memo('button.resizeQuarter', () => {
return this.button({
contents: '25%',
tooltip: this.lang.image.resizeQuarter,
click: this.context.createInvokeHandler('editor.resize', '0.25')
}).render();
});
this.context.memo('button.resizeNone', () => {
return this.button({
contents: this.ui.icon(this.options.icons.rollback),
tooltip: this.lang.image.resizeNone,
click: this.context.createInvokeHandler('editor.resize', '0')
}).render();
}); // Float Buttons
this.context.memo('button.floatLeft', () => {
return this.button({
contents: this.ui.icon(this.options.icons.floatLeft),
tooltip: this.lang.image.floatLeft,
click: this.context.createInvokeHandler('editor.floatMe', 'left')
}).render();
});
this.context.memo('button.floatRight', () => {
return this.button({
contents: this.ui.icon(this.options.icons.floatRight),
tooltip: this.lang.image.floatRight,
click: this.context.createInvokeHandler('editor.floatMe', 'right')
}).render();
});
this.context.memo('button.floatNone', () => {
return this.button({
contents: this.ui.icon(this.options.icons.rollback),
tooltip: this.lang.image.floatNone,
click: this.context.createInvokeHandler('editor.floatMe', 'none')
}).render();
}); // Remove Buttons
this.context.memo('button.removeMedia', () => {
return this.button({
contents: this.ui.icon(this.options.icons.trash),
tooltip: this.lang.image.remove,
click: this.context.createInvokeHandler('editor.removeMedia')
}).render();
});
}
addLinkPopoverButtons() {
this.context.memo('button.linkDialogShow', () => {
return this.button({
contents: this.ui.icon(this.options.icons.link),
tooltip: this.lang.link.edit,
click: this.context.createInvokeHandler('linkDialog.show')
}).render();
});
this.context.memo('button.unlink', () => {
return this.button({
contents: this.ui.icon(this.options.icons.unlink),
tooltip: this.lang.link.unlink,
click: this.context.createInvokeHandler('editor.unlink')
}).render();
});
}
/**
* table : [
* ['add', ['addRowDown', 'addRowUp', 'addColLeft', 'addColRight']],
* ['delete', ['deleteRow', 'deleteCol', 'deleteTable']]
* ],
*/
addTablePopoverButtons() {
this.context.memo('button.addRowUp', () => {
return this.button({
className: 'btn-md',
contents: this.ui.icon(this.options.icons.rowAbove),
tooltip: this.lang.table.addRowAbove,
click: this.context.createInvokeHandler('editor.addRow', 'top')
}).render();
});
this.context.memo('button.addRowDown', () => {
return this.button({
className: 'btn-md',
contents: this.ui.icon(this.options.icons.rowBelow),
tooltip: this.lang.table.addRowBelow,
click: this.context.createInvokeHandler('editor.addRow', 'bottom')
}).render();
});
this.context.memo('button.addColLeft', () => {
return this.button({
className: 'btn-md',
contents: this.ui.icon(this.options.icons.colBefore),
tooltip: this.lang.table.addColLeft,
click: this.context.createInvokeHandler('editor.addCol', 'left')
}).render();
});
this.context.memo('button.addColRight', () => {
return this.button({
className: 'btn-md',
contents: this.ui.icon(this.options.icons.colAfter),
tooltip: this.lang.table.addColRight,
click: this.context.createInvokeHandler('editor.addCol', 'right')
}).render();
});
this.context.memo('button.deleteRow', () => {
return this.button({
className: 'btn-md',
contents: this.ui.icon(this.options.icons.rowRemove),
tooltip: this.lang.table.delRow,
click: this.context.createInvokeHandler('editor.deleteRow')
}).render();
});
this.context.memo('button.deleteCol', () => {
return this.button({
className: 'btn-md',
contents: this.ui.icon(this.options.icons.colRemove),
tooltip: this.lang.table.delCol,
click: this.context.createInvokeHandler('editor.deleteCol')
}).render();
});
this.context.memo('button.deleteTable', () => {
return this.button({
className: 'btn-md',
contents: this.ui.icon(this.options.icons.trash),
tooltip: this.lang.table.delTable,
click: this.context.createInvokeHandler('editor.deleteTable')
}).render();
});
}
build($container, groups) {
for (let groupIdx = 0, groupLen = groups.length; groupIdx < groupLen; groupIdx++) {
const group = groups[groupIdx];
const groupName = Array.isArray(group) ? group[0] : group;
const buttons = Array.isArray(group) ? group.length === 1 ? [group[0]] : group[1] : [group];
const $group = this.ui.buttonGroup({
className: 'note-' + groupName
}).render();
for (let idx = 0, len = buttons.length; idx < len; idx++) {
const btn = this.context.memo('button.' + buttons[idx]);
if (btn) {
$group.append(typeof btn === 'function' ? btn(this.context) : btn);
}
}
$group.appendTo($container);
}
}
/**
* @param {jQuery} [$container]
*/
updateCurrentStyle($container) {
const $cont = $container || this.$toolbar;
const styleInfo = this.context.invoke('editor.currentStyle');
this.updateBtnStates($cont, {
'.note-btn-bold': () => {
return styleInfo['font-bold'] === 'bold';
},
'.note-btn-italic': () => {
return styleInfo['font-italic'] === 'italic';
},
'.note-btn-underline': () => {
return styleInfo['font-underline'] === 'underline';
},
'.note-btn-subscript': () => {
return styleInfo['font-subscript'] === 'subscript';
},
'.note-btn-superscript': () => {
return styleInfo['font-superscript'] === 'superscript';
},
'.note-btn-strikethrough': () => {
return styleInfo['font-strikethrough'] === 'strikethrough';
}
});
if (styleInfo['font-family']) {
const fontNames = styleInfo['font-family'].split(',').map(name => {
return name.replace(/[\'\"]/g, '').replace(/\s+$/, '').replace(/^\s+/, '');
});
const fontName = lists.find(fontNames, this.isFontInstalled.bind(this));
$cont.find('.dropdown-fontname a').each((idx, item) => {
const $item = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(item); // always compare string to avoid creating another func.
const isChecked = $item.data('value') + '' === fontName + '';
$item.toggleClass('checked', isChecked);
});
$cont.find('.note-current-fontname').text(fontName).css('font-family', fontName);
}
if (styleInfo['font-size']) {
const fontSize = styleInfo['font-size'];
$cont.find('.dropdown-fontsize a').each((idx, item) => {
const $item = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(item); // always compare with string to avoid creating another func.
const isChecked = $item.data('value') + '' === fontSize + '';
$item.toggleClass('checked', isChecked);
});
$cont.find('.note-current-fontsize').text(fontSize);
const fontSizeUnit = styleInfo['font-size-unit'];
$cont.find('.dropdown-fontsizeunit a').each((idx, item) => {
const $item = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(item);
const isChecked = $item.data('value') + '' === fontSizeUnit + '';
$item.toggleClass('checked', isChecked);
});
$cont.find('.note-current-fontsizeunit').text(fontSizeUnit);
}
if (styleInfo['line-height']) {
const lineHeight = styleInfo['line-height'];
$cont.find('.dropdown-line-height li a').each((idx, item) => {
// always compare with string to avoid creating another func.
const isChecked = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(item).data('value') + '' === lineHeight + '';
this.className = isChecked ? 'checked' : '';
});
}
}
updateBtnStates($container, infos) {
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each(infos, (selector, pred) => {
this.ui.toggleBtnActive($container.find(selector), pred());
});
}
tableMoveHandler(event) {
const PX_PER_EM = 18;
const $picker = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(event.target.parentNode); // target is mousecatcher
const $dimensionDisplay = $picker.next();
const $catcher = $picker.find('.note-dimension-picker-mousecatcher');
const $highlighted = $picker.find('.note-dimension-picker-highlighted');
const $unhighlighted = $picker.find('.note-dimension-picker-unhighlighted');
let posOffset; // HTML5 with jQuery - e.offsetX is undefined in Firefox
if (event.offsetX === undefined) {
const posCatcher = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(event.target).offset();
posOffset = {
x: event.pageX - posCatcher.left,
y: event.pageY - posCatcher.top
};
} else {
posOffset = {
x: event.offsetX,
y: event.offsetY
};
}
const 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);
}
}
// CONCATENATED MODULE: ./src/js/base/module/Toolbar.js
class Toolbar_Toolbar {
constructor(context) {
this.context = context;
this.$window = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(window);
this.$document = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(document);
this.ui = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.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);
}
shouldInitialize() {
return !this.options.airMode;
}
initialize() {
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', () => {
this.context.invoke('buttons.updateCurrentStyle');
});
this.context.invoke('buttons.updateCurrentStyle');
if (this.options.followingToolbar) {
this.$window.on('scroll resize', this.followScroll);
}
}
destroy() {
this.$toolbar.children().remove();
if (this.options.followingToolbar) {
this.$window.off('scroll resize', this.followScroll);
}
}
followScroll() {
if (this.$editor.hasClass('fullscreen')) {
return false;
}
const editorHeight = this.$editor.outerHeight();
const editorWidth = this.$editor.width();
const toolbarHeight = this.$toolbar.height();
const statusbarHeight = this.$statusbar.height(); // check if the web app is currently using another static bar
let otherBarHeight = 0;
if (this.options.otherStaticBar) {
otherBarHeight = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(this.options.otherStaticBar).outerHeight();
}
const currentOffset = this.$document.scrollTop();
const editorOffsetTop = this.$editor.offset().top;
const editorOffsetBottom = editorOffsetTop + editorHeight;
const activateOffset = editorOffsetTop - otherBarHeight;
const deactivateOffsetBottom = editorOffsetBottom - otherBarHeight - toolbarHeight - statusbarHeight;
if (!this.isFollowing && currentOffset > activateOffset && currentOffset < deactivateOffsetBottom - toolbarHeight) {
this.isFollowing = true;
this.$toolbar.css({
position: 'fixed',
top: otherBarHeight,
width: editorWidth,
zIndex: 1000
});
this.$editable.css({
marginTop: this.$toolbar.height() + 5
});
} 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: ''
});
}
}
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();
}
}
updateFullscreen(isFullscreen) {
this.ui.toggleBtnActive(this.$toolbar.find('.btn-fullscreen'), isFullscreen);
this.changeContainer(isFullscreen);
}
updateCodeview(isCodeview) {
this.ui.toggleBtnActive(this.$toolbar.find('.btn-codeview'), isCodeview);
if (isCodeview) {
this.deactivate();
} else {
this.activate();
}
}
activate(isIncludeCodeview) {
let $btn = this.$toolbar.find('button');
if (!isIncludeCodeview) {
$btn = $btn.not('.btn-codeview').not('.btn-fullscreen');
}
this.ui.toggleBtn($btn, true);
}
deactivate(isIncludeCodeview) {
let $btn = this.$toolbar.find('button');
if (!isIncludeCodeview) {
$btn = $btn.not('.btn-codeview').not('.btn-fullscreen');
}
this.ui.toggleBtn($btn, false);
}
}
// CONCATENATED MODULE: ./src/js/base/module/LinkDialog.js
class LinkDialog_LinkDialog {
constructor(context) {
this.context = context;
this.ui = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui;
this.$body = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_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']);
}
initialize() {
const $container = this.options.dialogsInBody ? this.$body : this.options.container;
const body = ['', ``, ``, '
', '', ``, ``, '
', !this.options.disableLinkTarget ? external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()('').append(this.ui.checkbox({
className: 'sn-checkbox-open-in-new-window',
text: this.lang.link.openInNewWindow,
checked: true
}).render()).html() : '', external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()('').append(this.ui.checkbox({
className: 'sn-checkbox-use-protocol',
text: this.lang.link.useProtocol,
checked: true
}).render()).html()].join('');
const buttonClass = 'btn btn-primary note-btn note-btn-primary note-link-btn';
const 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);
}
destroy() {
this.ui.hideDialog(this.$dialog);
this.$dialog.remove();
}
bindEnterKey($input, $btn) {
$input.on('keypress', event => {
if (event.keyCode === core_key.code.ENTER) {
event.preventDefault();
$btn.trigger('click');
}
});
}
/**
* toggle update button
*/
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}
*/
showLinkDialog(linkInfo) {
return external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.Deferred(deferred => {
const $linkText = this.$dialog.find('.note-link-text');
const $linkUrl = this.$dialog.find('.note-link-url');
const $linkBtn = this.$dialog.find('.note-link-btn');
const $openInNewWindow = this.$dialog.find('.sn-checkbox-open-in-new-window input[type=checkbox]');
const $useProtocol = this.$dialog.find('.sn-checkbox-use-protocol input[type=checkbox]');
this.ui.onDialogShown(this.$dialog, () => {
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', () => {
// 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', () => {
// 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);
const isNewWindowChecked = linkInfo.isNewWindow !== undefined ? linkInfo.isNewWindow : this.context.options.linkTargetBlank;
$openInNewWindow.prop('checked', isNewWindowChecked);
const useProtocolChecked = linkInfo.url ? false : this.context.options.useProtocol;
$useProtocol.prop('checked', useProtocolChecked);
$linkBtn.one('click', 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, () => {
// detach events
$linkText.off();
$linkUrl.off();
$linkBtn.off();
if (deferred.state() === 'pending') {
deferred.reject();
}
});
this.ui.showDialog(this.$dialog);
}).promise();
}
/**
* @param {Object} layoutInfo
*/
show() {
const linkInfo = this.context.invoke('editor.getLinkInfo');
this.context.invoke('editor.saveRange');
this.showLinkDialog(linkInfo).then(linkInfo => {
this.context.invoke('editor.restoreRange');
this.context.invoke('editor.createLink', linkInfo);
}).fail(() => {
this.context.invoke('editor.restoreRange');
});
}
}
// CONCATENATED MODULE: ./src/js/base/module/LinkPopover.js
class LinkPopover_LinkPopover {
constructor(context) {
this.context = context;
this.ui = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui;
this.options = context.options;
this.events = {
'summernote.keyup summernote.mouseup summernote.change summernote.scroll': () => {
this.update();
},
'summernote.disable summernote.dialog.shown summernote.blur': () => {
this.hide();
}
};
}
shouldInitialize() {
return !lists.isEmpty(this.options.popover.link);
}
initialize() {
this.$popover = this.ui.popover({
className: 'note-link-popover',
callback: $node => {
const $content = $node.find('.popover-content,.note-popover-content');
$content.prepend(' ');
}
}).render().appendTo(this.options.container);
const $content = this.$popover.find('.popover-content,.note-popover-content');
this.context.invoke('buttons.build', $content, this.options.popover.link);
this.$popover.on('mousedown', e => {
e.preventDefault();
});
}
destroy() {
this.$popover.remove();
}
update() {
// Prevent focusing on editable when invoke('code') is executed
if (!this.context.invoke('editor.hasFocus')) {
this.hide();
return;
}
const rng = this.context.invoke('editor.getLastRange');
if (rng.isCollapsed() && rng.isOnAnchor()) {
const anchor = dom.ancestor(rng.sc, dom.isAnchor);
const href = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(anchor).attr('href');
this.$popover.find('a').attr('href', href).html(href);
const pos = dom.posFromPlaceholder(anchor);
const containerOffset = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_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();
}
}
hide() {
this.$popover.hide();
}
}
// CONCATENATED MODULE: ./src/js/base/module/ImageDialog.js
class ImageDialog_ImageDialog {
constructor(context) {
this.context = context;
this.ui = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui;
this.$body = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(document.body);
this.$editor = context.layoutInfo.editor;
this.options = context.options;
this.lang = this.options.langInfo;
}
initialize() {
let imageLimitation = '';
if (this.options.maximumImageFileSize) {
const unit = Math.floor(Math.log(this.options.maximumImageFileSize) / Math.log(1024));
const readableSize = (this.options.maximumImageFileSize / Math.pow(1024, unit)).toFixed(2) * 1 + ' ' + ' KMGTP'[unit] + 'B';
imageLimitation = `${this.lang.image.maximumFileSize + ' : ' + readableSize}`;
}
const $container = this.options.dialogsInBody ? this.$body : this.options.container;
const body = ['', '', '', imageLimitation, '
', '', '', '', '
'].join('');
const buttonClass = 'btn btn-primary note-btn note-btn-primary note-image-btn';
const footer = ``;
this.$dialog = this.ui.dialog({
title: this.lang.image.insert,
fade: this.options.dialogsFade,
body: body,
footer: footer
}).render().appendTo($container);
}
destroy() {
this.ui.hideDialog(this.$dialog);
this.$dialog.remove();
}
bindEnterKey($input, $btn) {
$input.on('keypress', event => {
if (event.keyCode === core_key.code.ENTER) {
event.preventDefault();
$btn.trigger('click');
}
});
}
show() {
this.context.invoke('editor.saveRange');
this.showImageDialog().then(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(() => {
this.context.invoke('editor.restoreRange');
});
}
/**
* show image dialog
*
* @param {jQuery} $dialog
* @return {Promise}
*/
showImageDialog() {
return external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.Deferred(deferred => {
const $imageInput = this.$dialog.find('.note-image-input');
const $imageUrl = this.$dialog.find('.note-image-url');
const $imageBtn = this.$dialog.find('.note-image-btn');
this.ui.onDialogShown(this.$dialog, () => {
this.context.triggerEvent('dialog.shown'); // Cloning imageInput to clear element.
$imageInput.replaceWith($imageInput.clone().on('change', event => {
deferred.resolve(event.target.files || event.target.value);
}).val(''));
$imageUrl.on('input paste propertychange', () => {
this.ui.toggleBtn($imageBtn, $imageUrl.val());
}).val('');
if (!env.isSupportTouch) {
$imageUrl.trigger('focus');
}
$imageBtn.click(event => {
event.preventDefault();
deferred.resolve($imageUrl.val());
});
this.bindEnterKey($imageUrl, $imageBtn);
});
this.ui.onDialogHidden(this.$dialog, () => {
$imageInput.off();
$imageUrl.off();
$imageBtn.off();
if (deferred.state() === 'pending') {
deferred.reject();
}
});
this.ui.showDialog(this.$dialog);
});
}
}
// CONCATENATED MODULE: ./src/js/base/module/ImagePopover.js
/**
* 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'.
*/
class ImagePopover_ImagePopover {
constructor(context) {
this.context = context;
this.ui = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui;
this.editable = context.layoutInfo.editable[0];
this.options = context.options;
this.events = {
'summernote.disable summernote.blur': () => {
this.hide();
}
};
}
shouldInitialize() {
return !lists.isEmpty(this.options.popover.image);
}
initialize() {
this.$popover = this.ui.popover({
className: 'note-image-popover'
}).render().appendTo(this.options.container);
const $content = this.$popover.find('.popover-content,.note-popover-content');
this.context.invoke('buttons.build', $content, this.options.popover.image);
this.$popover.on('mousedown', e => {
e.preventDefault();
});
}
destroy() {
this.$popover.remove();
}
update(target, event) {
if (dom.isImg(target)) {
const position = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(target).offset();
const containerOffset = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(this.options.container).offset();
let 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();
}
}
hide() {
this.$popover.hide();
}
}
// CONCATENATED MODULE: ./src/js/base/module/TablePopover.js
class TablePopover_TablePopover {
constructor(context) {
this.context = context;
this.ui = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui;
this.options = context.options;
this.events = {
'summernote.mousedown': (we, e) => {
this.update(e.target);
},
'summernote.keyup summernote.scroll summernote.change': () => {
this.update();
},
'summernote.disable summernote.blur': () => {
this.hide();
}
};
}
shouldInitialize() {
return !lists.isEmpty(this.options.popover.table);
}
initialize() {
this.$popover = this.ui.popover({
className: 'note-table-popover'
}).render().appendTo(this.options.container);
const $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', e => {
e.preventDefault();
});
}
destroy() {
this.$popover.remove();
}
update(target) {
if (this.context.isDisabled()) {
return false;
}
const isCell = dom.isCell(target);
if (isCell) {
const pos = dom.posFromPlaceholder(target);
const containerOffset = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_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;
}
hide() {
this.$popover.hide();
}
}
// CONCATENATED MODULE: ./src/js/base/module/VideoDialog.js
class VideoDialog_VideoDialog {
constructor(context) {
this.context = context;
this.ui = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui;
this.$body = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(document.body);
this.$editor = context.layoutInfo.editor;
this.options = context.options;
this.lang = this.options.langInfo;
}
initialize() {
const $container = this.options.dialogsInBody ? this.$body : this.options.container;
const body = ['', ``, ``, '
'].join('');
const buttonClass = 'btn btn-primary note-btn note-btn-primary note-video-btn';
const footer = ``;
this.$dialog = this.ui.dialog({
title: this.lang.video.insert,
fade: this.options.dialogsFade,
body: body,
footer: footer
}).render().appendTo($container);
}
destroy() {
this.ui.hideDialog(this.$dialog);
this.$dialog.remove();
}
bindEnterKey($input, $btn) {
$input.on('keypress', event => {
if (event.keyCode === core_key.code.ENTER) {
event.preventDefault();
$btn.trigger('click');
}
});
}
createVideoNode(url) {
// video url patterns(youtube, instagram, vimeo, dailymotion, youku, mp4, ogg, webm)
const ytRegExp = /\/\/(?:www\.)?(?:youtu\.be\/|youtube\.com\/(?:embed\/|v\/|watch\?v=|watch\?.+&v=))([\w|-]{11})(?:(?:[\?&]t=)(\S+))?$/;
const ytRegExpForStart = /^(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$/;
const ytMatch = url.match(ytRegExp);
const igRegExp = /(?:www\.|\/\/)instagram\.com\/p\/(.[a-zA-Z0-9_-]*)/;
const igMatch = url.match(igRegExp);
const vRegExp = /\/\/vine\.co\/v\/([a-zA-Z0-9]+)/;
const vMatch = url.match(vRegExp);
const vimRegExp = /\/\/(player\.)?vimeo\.com\/([a-z]*\/)*(\d+)[?]?.*/;
const vimMatch = url.match(vimRegExp);
const dmRegExp = /.+dailymotion.com\/(video|hub)\/([^_]+)[^#]*(#video=([^_&]+))?/;
const dmMatch = url.match(dmRegExp);
const youkuRegExp = /\/\/v\.youku\.com\/v_show\/id_(\w+)=*\.html/;
const youkuMatch = url.match(youkuRegExp);
const qqRegExp = /\/\/v\.qq\.com.*?vid=(.+)/;
const qqMatch = url.match(qqRegExp);
const qqRegExp2 = /\/\/v\.qq\.com\/x?\/?(page|cover).*?\/([^\/]+)\.html\??.*/;
const qqMatch2 = url.match(qqRegExp2);
const mp4RegExp = /^.+.(mp4|m4v)$/;
const mp4Match = url.match(mp4RegExp);
const oggRegExp = /^.+.(ogg|ogv)$/;
const oggMatch = url.match(oggRegExp);
const webmRegExp = /^.+.(webm)$/;
const webmMatch = url.match(webmRegExp);
const fbRegExp = /(?:www\.|\/\/)facebook\.com\/([^\/]+)\/videos\/([0-9]+)/;
const fbMatch = url.match(fbRegExp);
let $video;
if (ytMatch && ytMatch[1].length === 11) {
const youtubeId = ytMatch[1];
var start = 0;
if (typeof ytMatch[2] !== 'undefined') {
const 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_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()('