https://uftb.ac.bd/assets/dashboard/js/summernote/dist/summernote.js

1/*!
2 *
3 * Super simple WYSIWYG editor v0.8.20
4 * https://summernote.org
5 *
6 *
7 * Copyright 2013- Alan Hong and contributors
8 * Summernote may be freely distributed under the MIT license.
9 *
10 * Date: 2021-10-14T21:15Z
11 *
12 */
13(function webpackUniversalModuleDefinition(root, factory) {
14    if (typeof exports === 'object' && typeof module === 'object')
15        module.exports = factory(require("jQuery"));
16    else if (typeof define === 'function' && define.amd)
17        define(["jQuery"], factory);
18    else {
19        var a = typeof exports === 'object' ? factory(require("jQuery")) : factory(root["jQuery"]);
20        for (var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
21    }
22})(self, function (__WEBPACK_EXTERNAL_MODULE__1145__) {
23    return /******/ (() => { // webpackBootstrap
24        /******/
25        "use strict";
26        /******/
27        var __webpack_modules__ = ({
28
29            /***/ 9770:
30            /***/ ((__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) => {
31
32                /* harmony import */
33                var jquery__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1145);
34                /* harmony import */
35                var jquery__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(jquery__WEBPACK_IMPORTED_MODULE_0__);
36
37                (jquery__WEBPACK_IMPORTED_MODULE_0___default().summernote) = (jquery__WEBPACK_IMPORTED_MODULE_0___default().summernote) || {
38                    lang: {}
39                };
40                if (public_lang == "ar") {
41                    jquery__WEBPACK_IMPORTED_MODULE_0___default().extend((jquery__WEBPACK_IMPORTED_MODULE_0___default().summernote.lang), {
42                        'en-US': {
43                            font: {
44                                bold: 'عريض',
45                                italic: 'مائل',
46                                underline: 'تحته خط',
47                                clear: 'مسح التنسيق',
48                                height: 'إرتفاع السطر',
49                                name: 'الخط',
50                                strikethrough: 'فى وسطه خط',
51                                subscript: 'مخطوطة',
52                                superscript: 'حرف فوقي',
53                                size: 'الحجم'
54                            },
55                            image: {
56
57                                image: 'صورة',
58                                insert: 'إضافة صورة',
59                                resizeFull: 'الحجم بالكامل',
60                                resizeHalf: 'تصغير للنصف',
61                                resizeQuarter: 'تصغير للربع',
62                                floatLeft: 'تطيير لليسار',
63                                floatRight: 'تطيير لليمين',
64                                floatNone: 'ثابته',
65                                shapeRounded: 'الشكل: تقريب',
66                                shapeCircle: 'الشكل: دائرة',
67                                shapeThumbnail: 'الشكل: صورة مصغرة',
68                                shapeNone: 'الشكل: لا شيء',
69                                dragImageHere: 'إدرج الصورة هنا',
70                                dropImage: 'إسقاط صورة أو نص',
71                                selectFromFiles: 'حدد ملف',
72                                maximumFileSize: 'الحد الأقصى لحجم الملف',
73                                maximumFileSizeError: 'تم تجاوز الحد الأقصى لحجم الملف',
74                                url: 'رابط الصورة',
75                                remove: 'حذف الصورة',
76                            },
77                            video: {
78                                video: 'فيديو',
79                                videoLink: 'رابط الفيديو',
80                                insert: 'إدراج الفيديو',
81                                url: 'رابط الفيديو',
82                                providers: '(YouTube, Vimeo, Vine, Instagram, DailyMotion ou Youku)'
83                            },
84                            link: {
85                                link: 'رابط رابط',
86                                insert: 'إدراج',
87                                unlink: 'حذف الرابط',
88                                edit: 'تعديل',
89                                textToDisplay: 'النص',
90                                url: 'مسار الرابط',
91                                openInNewWindow: 'فتح في نافذة جديدة'
92                            },
93                            table: {
94                                table: 'جدول'
95                            },
96                            hr: {
97                                insert: 'إدراج خط أفقي'
98                            },
99                            style: {
100                                style: 'تنسيق',
101                                p: 'عادي',
102                                blockquote: 'إقتباس',
103                                pre: 'شفيرة',
104                                h1: 'عنوان رئيسي 1',
105                                h2: 'عنوان رئيسي 2',
106                                h3: 'عنوان رئيسي 3',
107                                h4: 'عنوان رئيسي 4',
108                                h5: 'عنوان رئيسي 5',
109                                h6: 'عنوان رئيسي 6'
110                            },
111                            lists: {
112                                unordered: 'قائمة مُنقطة',
113                                ordered: 'قائمة مُرقمة'
114                            },
115                            options: {
116                                help: 'مساعدة',
117                                fullscreen: 'حجم الشاشة بالكامل',
118                                codeview: 'شفيرة المصدر'
119                            },
120                            paragraph: {
121                                paragraph: 'فقرة',

408                var getter = module && module.__esModule ?
409                    /******/                () => (module['default']) :
410                    /******/                () => (module);
411                /******/
412                __webpack_require__.d(getter, {a: getter});
413                /******/
414                return getter;
415                /******/
416            };
417            /******/
418        })();
419        /******/
420        /******/ 	/* webpack/runtime/define property getters */
421        /******/
422        (() => {
423            /******/ 		// define getter functions for harmony exports
424            /******/
425            __webpack_require__.d = (exports, definition) => {
426                /******/
427                for (var key in definition) {
428                    /******/
429                    if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
430                        /******/
431                        Object.defineProperty(exports, key, {enumerable: true, get: definition[key]});
432                        /******/
433                    }
434                    /******/
435                }
436                /******/
437            };
438            /******/
439        })();
440        /******/
441        /******/ 	/* webpack/runtime/hasOwnProperty shorthand */
442        /******/
443        (() => {
444            /******/
445            __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
446            /******/
447        })();
448        /******/
449        /******/ 	/* webpack/runtime/make namespace object */
450        /******/
451        (() => {
452            /******/ 		// define __esModule on exports
453            /******/
454            __webpack_require__.r = (exports) => {
455                /******/
456                if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
457                    /******/
458                    Object.defineProperty(exports, Symbol.toStringTag, {value: 'Module'});
459                    /******/
460                }
461                /******/
462                Object.defineProperty(exports, '__esModule', {value: true});
463                /******/
464            };
465            /******/
466        })();
467        /******/
468        /************************************************************************/
469        var __webpack_exports__ = {};
470// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
471        (() => {
472// ESM COMPAT FLAG
473            __webpack_require__.r(__webpack_exports__);
474
475// EXTERNAL MODULE: external "jQuery"
476            var external_jQuery_ = __webpack_require__(1145);
477            var external_jQuery_default = /*#__PURE__*/__webpack_require__.n(external_jQuery_);
478// EXTERNAL MODULE: ./src/lang/summernote-en-US.js
479            var summernote_en_US = __webpack_require__(9770);
480            ;// CONCATENATED MODULE: ./src/js/core/env.js
481
482            /**
483             * returns whether font is installed or not.
484             *
485             * @param {String} fontName
486             * @return {Boolean}
487             */
488
489            var genericFontFamilies = ['sans-serif', 'serif', 'monospace', 'cursive', 'fantasy'];
490
491            function validFontName(fontName) {
492                return external_jQuery_default().inArray(fontName.toLowerCase(), genericFontFamilies) === -1 ? "'".concat(fontName, "'") : fontName;
493            }
494
495            function isFontInstalled(fontName) {
496                var testFontName = fontName === 'Comic Sans MS' ? 'Courier New' : 'Comic Sans MS';
497                var testText = 'mmmmmmmmmmwwwww';
498                var testSize = '200px';
499                var canvas = document.createElement('canvas');
500                var context = canvas.getContext('2d');
501                context.font = testSize + " '" + testFontName + "'";
502                var originalWidth = context.measureText(testText).width;
503                context.font = testSize + ' ' + validFontName(fontName) + ', "' + testFontName + '"';
504                var width = context.measureText(testText).width;
505                return originalWidth !== width;
506            }
507
508            var userAgent = navigator.userAgent;
509            var isMSIE = /MSIE|Trident/i.test(userAgent);
510            var browserVersion;
511
512            if (isMSIE) {
513                var matches = /MSIE (\d+[.]\d+)/.exec(userAgent);
514
515                if (matches) {
516                    browserVersion = parseFloat(matches[1]);
517                }
518
519                matches = /Trident\/.*rv:([0-9]{1,}[.0-9]{0,})/.exec(userAgent);
520
521                if (matches) {
522                    browserVersion = parseFloat(matches[1]);
523                }
524            }
525
526            var isEdge = /Edge\/\d+/.test(userAgent);
527            var isSupportTouch = 'ontouchstart' in window || navigator.MaxTouchPoints > 0 || navigator.msMaxTouchPoints > 0; // [workaround] IE doesn't have input events for contentEditable
528// - see: https://goo.gl/4bfIvA
529
530            var inputEventName = isMSIE ? 'DOMCharacterDataModified DOMSubtreeModified DOMNodeInserted' : 'input';
531            /**
532             * @class core.env
533             *
534             * Object which check platform and agent
535             *
536             * @singleton
537             * @alternateClassName env
538             */
539
540            /* harmony default export */
541            const env = ({
542                isMac: navigator.appVersion.indexOf('Mac') > -1,
543                isMSIE: isMSIE,
544                isEdge: isEdge,
545                isFF: !isEdge && /firefox/i.test(userAgent),
546                isPhantom: /PhantomJS/i.test(userAgent),
547                isWebkit: !isEdge && /webkit/i.test(userAgent),
548                isChrome: !isEdge && /chrome/i.test(userAgent),
549                isSafari: !isEdge && /safari/i.test(userAgent) && !/chrome/i.test(userAgent),
550                browserVersion: browserVersion,
551                isSupportTouch: isSupportTouch,
552                isFontInstalled: isFontInstalled,
553                isW3CRangeSupport: !!document.createRange,
554                inputEventName: inputEventName,
555                genericFontFamilies: genericFontFamilies,
556                validFontName: validFontName
557            });
558            ;// CONCATENATED MODULE: ./src/js/core/func.js
559
560            /**
561             * @class core.func
562             *
563             * func utils (for high-order func's arg)
564             *
565             * @singleton
566             * @alternateClassName func
567             */
568
569            function eq(itemA) {
570                return function (itemB) {
571                    return itemA === itemB;
572                };
573            }
574
575            function eq2(itemA, itemB) {
576                return itemA === itemB;
577            }
578
579            function peq2(propName) {
580                return function (itemA, itemB) {
581                    return itemA[propName] === itemB[propName];
582                };
583            }
584
585            function ok() {
586                return true;
587            }
588
589            function fail() {
590                return false;

591            }
592
593            function not(f) {
594                return function () {
595                    return !f.apply(f, arguments);
596                };
597            }
598
599            function and(fA, fB) {
600                return function (item) {
601                    return fA(item) && fB(item);
602                };
603            }
604
605            function func_self(a) {
606                return a;
607            }
608
609            function invoke(obj, method) {
610                return function () {
611                    return obj[method].apply(obj, arguments);
612                };
613            }
614
615            var idCounter = 0;
616
617            /**
618             * reset globally-unique id
619             *
620             */
621
622            function resetUniqueId() {
623                idCounter = 0;
624            }
625
626            /**
627             * generate a globally-unique id
628             *
629             * @param {String} [prefix]
630             */
631
632
633            function uniqueId(prefix) {
634                var id = ++idCounter + '';
635                return prefix ? prefix + id : id;
636            }
637
638            /**
639             * returns bnd (bounds) from rect
640             *
641             * - IE Compatibility Issue: http://goo.gl/sRLOAo
642             * - Scroll Issue: http://goo.gl/sNjUc
643             *
644             * @param {Rect} rect
645             * @return {Object} bounds
646             * @return {Number} bounds.top
647             * @return {Number} bounds.left
648             * @return {Number} bounds.width
649             * @return {Number} bounds.height
650             */
651
652
653            function rect2bnd(rect) {
654                var $document = external_jQuery_default()(document);
655                return {
656                    top: rect.top + $document.scrollTop(),
657                    left: rect.left + $document.scrollLeft(),
658                    width: rect.right - rect.left,
659                    height: rect.bottom - rect.top
660                };
661            }
662
663            /**
664             * returns a copy of the object where the keys have become the values and the values the keys.
665             * @param {Object} obj
666             * @return {Object}
667             */
668
669
670            function invertObject(obj) {
671                var inverted = {};
672
673                for (var key in obj) {
674                    if (Object.prototype.hasOwnProperty.call(obj, key)) {
675                        inverted[obj[key]] = key;
676                    }
677                }
678
679                return inverted;
680            }
681
682            /**
683             * @param {String} namespace
684             * @param {String} [prefix]
685             * @return {String}
686             */
687
688
689            function namespaceToCamel(namespace, prefix) {
690                prefix = prefix || '';
691                return prefix + namespace.split('.').map(function (name) {
692                    return name.substring(0, 1).toUpperCase() + name.substring(1);
693                }).join('');
694            }
695
696            /**
697             * Returns a function, that, as long as it continues to be invoked, will not
698             * be triggered. The function will be called after it stops being called for
699             * N milliseconds. If `immediate` is passed, trigger the function on the
700             * leading edge, instead of the trailing.
701             * @param {Function} func
702             * @param {Number} wait
703             * @param {Boolean} immediate
704             * @return {Function}
705             */
706
707
708            function debounce(func, wait, immediate) {
709                var timeout;
710                return function () {
711                    var context = this;
712                    var args = arguments;
713
714                    var later = function later() {
715                        timeout = null;
716
717                        if (!immediate) {
718                            func.apply(context, args);
719                        }
720                    };
721
722                    var callNow = immediate && !timeout;
723                    clearTimeout(timeout);
724                    timeout = setTimeout(later, wait);
725
726                    if (callNow) {
727                        func.apply(context, args);
728                    }
729                };
730            }
731
732            /**
733             *
734             * @param {String} url
735             * @return {Boolean}
736             */
737
738
739            function isValidUrl(url) {
740                var expression = /[-a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)/gi;
741                return expression.test(url);
742            }
743
744            /* harmony default export */
745            const func = ({
746                eq: eq,
747                eq2: eq2,
748                peq2: peq2,
749                ok: ok,
750                fail: fail,
751                self: func_self,
752                not: not,
753                and: and,
754                invoke: invoke,
755                resetUniqueId: resetUniqueId,
756                uniqueId: uniqueId,
757                rect2bnd: rect2bnd,
758                invertObject: invertObject,
759                namespaceToCamel: namespaceToCamel,
760                debounce: debounce,
761                isValidUrl: isValidUrl
762            });
763            ;// CONCATENATED MODULE: ./src/js/core/lists.js
764
765            /**
766             * returns the first item of an array.
767             *
768             * @param {Array} array
769             */
770
771            function head(array) {
772                return array[0];
773            }
774
775            /**
776             * returns the last item of an array.
777             *
778             * @param {Array} array
779             */
780
781
782            function last(array) {
783                return array[array.length - 1];
784            }
785
786            /**
787             * returns everything but the last entry of the array.
788             *
789             * @param {Array} array
790             */
791
792
793            function initial(array) {
794                return array.slice(0, array.length - 1);
795            }
796
797            /**
798             * returns the rest of the items in an array.
799             *
800             * @param {Array} array
801             */
802
803
804            function tail(array) {
805                return array.slice(1);
806            }
807
808            /**
809             * returns item of array
810             */
811
812
813            function find(array, pred) {
814                for (var idx = 0, len = array.length; idx < len; idx++) {
815                    var item = array[idx];
816
817                    if (pred(item)) {
818                        return item;
819                    }
820                }
821            }
822
823            /**
824             * returns true if all of the values in the array pass the predicate truth test.
825             */
826
827
828            function lists_all(array, pred) {
829                for (var idx = 0, len = array.length; idx < len; idx++) {
830                    if (!pred(array[idx])) {
831                        return false;
832                    }
833                }
834
835                return true;
836            }
837
838            /**
839             * returns true if the value is present in the list.
840             */
841
842
843            function contains(array, item) {
844                if (array && array.length && item) {
845                    if (array.indexOf) {
846                        return array.indexOf(item) !== -1;
847                    } else if (array.contains) {
848                        // `DOMTokenList` doesn't implement `.indexOf`, but it implements `.contains`
849                        return array.contains(item);
850                    }
851                }
852
853                return false;
854            }
855
856            /**
857             * get sum from a list
858             *
859             * @param {Array} array - array
860             * @param {Function} fn - iterator
861             */
862
863
864            function sum(array, fn) {
865                fn = fn || func.self;
866                return array.reduce(function (memo, v) {
867                    return memo + fn(v);
868                }, 0);
869            }
870
871            /**
872             * returns a copy of the collection with array type.
873             * @param {Collection} collection - collection eg) node.childNodes, ...
874             */
875
876
877            function from(collection) {
878                var result = [];
879                var length = collection.length;
880                var idx = -1;
881
882                while (++idx < length) {
883                    result[idx] = collection[idx];
884                }
885
886                return result;
887            }
888
889            /**
890             * returns whether list is empty or not
891             */
892
893
894            function isEmpty(array) {
895                return !array || !array.length;
896            }
897
898            /**
899             * cluster elements by predicate function.
900             *
901             * @param {Array} array - array
902             * @param {Function} fn - predicate function for cluster rule
903             * @param {Array[]}
904             */
905
906
907            function clusterBy(array, fn) {
908                if (!array.length) {
909                    return [];
910                }
911
912                var aTail = tail(array);
913                return aTail.reduce(function (memo, v) {
914                    var aLast = last(memo);
915
916                    if (fn(last(aLast), v)) {
917                        aLast[aLast.length] = v;
918                    } else {
919                        memo[memo.length] = [v];
920                    }
921
922                    return memo;
923                }, [[head(array)]]);
924            }
925
926            /**
927             * returns a copy of the array with all false values removed
928             *
929             * @param {Array} array - array
930             * @param {Function} fn - predicate function for cluster rule
931             */
932
933
934            function compact(array) {
935                var aResult = [];
936
937                for (var idx = 0, len = array.length; idx < len; idx++) {
938                    if (array[idx]) {
939                        aResult.push(array[idx]);
940                    }
941                }
942
943                return aResult;
944            }
945
946            /**
947             * produces a duplicate-free version of the array
948             *
949             * @param {Array} array
950             */
951
952
953            function unique(array) {
954                var results = [];
955
956                for (var idx = 0, len = array.length; idx < len; idx++) {
957                    if (!contains(results, array[idx])) {
958                        results.push(array[idx]);
959                    }
960                }
961
962                return results;
963            }
964
965            /**
966             * returns next item.
967             * @param {Array} array
968             */
969
970
971            function next(array, item) {
972                if (array && array.length && item) {
973                    var idx = array.indexOf(item);
974                    return idx === -1 ? null : array[idx + 1];
975                }
976
977                return null;
978            }
979
980            /**
981             * returns prev item.
982             * @param {Array} array
983             */
984
985
986            function prev(array, item) {
987                if (array && array.length && item) {
988                    var idx = array.indexOf(item);
989                    return idx === -1 ? null : array[idx - 1];
990                }
991
992                return null;
993            }
994
995            /**
996             * @class core.list
997             *
998             * list utils
999             *
1000             * @singleton
1001             * @alternateClassName list
1002             */
1003
1004
1005            /* harmony default export */
1006            const lists = ({
1007                head: head,
1008                last: last,
1009                initial: initial,
1010                tail: tail,
1011                prev: prev,
1012                next: next,
1013                find: find,
1014                contains: contains,
1015                all: lists_all,
1016                sum: sum,
1017                from: from,
1018                isEmpty: isEmpty,
1019                clusterBy: clusterBy,
1020                compact: compact,
1021                unique: unique
1022            });
1023            ;// CONCATENATED MODULE: ./src/js/core/dom.js
1024
1025
1026            var NBSP_CHAR = String.fromCharCode(160);
1027            var ZERO_WIDTH_NBSP_CHAR = "\uFEFF";
1028
1029            /**
1030             * @method isEditable
1031             *
1032             * returns whether node is `note-editable` or not.
1033             *
1034             * @param {Node} node
1035             * @return {Boolean}
1036             */
1037
1038            function isEditable(node) {
1039                return node && external_jQuery_default()(node).hasClass('note-editable');
1040            }
1041
1042            /**
1043             * @method isControlSizing
1044             *
1045             * returns whether node is `note-control-sizing` or not.
1046             *
1047             * @param {Node} node
1048             * @return {Boolean}
1049             */
1050
1051
1052            function isControlSizing(node) {
1053                return node && external_jQuery_default()(node).hasClass('note-control-sizing');
1054            }
1055
1056            /**
1057             * @method makePredByNodeName
1058             *
1059             * returns predicate which judge whether nodeName is same
1060             *
1061             * @param {String} nodeName
1062             * @return {Function}
1063             */
1064
1065
1066            function makePredByNodeName(nodeName) {
1067                nodeName = nodeName.toUpperCase();
1068                return function (node) {
1069                    return node && node.nodeName.toUpperCase() === nodeName;
1070                };
1071            }
1072
1073            /**
1074             * @method isText
1075             *
1076             *
1077             *
1078             * @param {Node} node
1079             * @return {Boolean} true if node's type is text(3)
1080             */
1081
1082
1083            function isText(node) {
1084                return node && node.nodeType === 3;
1085            }
1086
1087            /**
1088             * @method isElement
1089             *
1090             *
1091             *
1092             * @param {Node} node
1093             * @return {Boolean} true if node's type is element(1)
1094             */
1095
1096
1097            function isElement(node) {
1098                return node && node.nodeType === 1;
1099            }
1100
1101            /**
1102             * ex) br, col, embed, hr, img, input, ...
1103             * @see http://www.w3.org/html/wg/drafts/html/master/syntax.html#void-elements
1104             */
1105
1106
1107            function isVoid(node) {
1108                return node && /^BR|^IMG|^HR|^IFRAME|^BUTTON|^INPUT|^AUDIO|^VIDEO|^EMBED/.test(node.nodeName.toUpperCase());
1109            }
1110
1111            function isPara(node) {
1112                if (isEditable(node)) {
1113                    return false;
1114                } // Chrome(v31.0), FF(v25.0.1) use DIV for paragraph
1115
1116
1117                return node && /^DIV|^P|^LI|^H[1-7]/.test(node.nodeName.toUpperCase());
1118            }
1119
1120            function isHeading(node) {
1121                return node && /^H[1-7]/.test(node.nodeName.toUpperCase());
1122            }
1123
1124            var isPre = makePredByNodeName('PRE');
1125            var isLi = makePredByNodeName('LI');
1126
1127            function isPurePara(node) {
1128                return isPara(node) && !isLi(node);
1129            }
1130
1131            var isTable = makePredByNodeName('TABLE');
1132            var isData = makePredByNodeName('DATA');
1133
1134            function isInline(node) {
1135                return !isBodyContainer(node) && !isList(node) && !isHr(node) && !isPara(node) && !isTable(node) && !isBlockquote(node) && !isData(node);
1136            }
1137
1138            function isList(node) {
1139                return node && /^UL|^OL/.test(node.nodeName.toUpperCase());
1140            }
1141
1142            var isHr = makePredByNodeName('HR');
1143
1144            function isCell(node) {
1145                return node && /^TD|^TH/.test(node.nodeName.toUpperCase());
1146            }
1147
1148            var isBlockquote = makePredByNodeName('BLOCKQUOTE');
1149
1150            function isBodyContainer(node) {
1151                return isCell(node) || isBlockquote(node) || isEditable(node);
1152            }
1153
1154            var isAnchor = makePredByNodeName('A');
1155
1156            function isParaInline(node) {
1157                return isInline(node) && !!ancestor(node, isPara);
1158            }
1159
1160            function isBodyInline(node) {
1161                return isInline(node) && !ancestor(node, isPara);
1162            }
1163
1164            var isBody = makePredByNodeName('BODY');
1165
1166            /**
1167             * returns whether nodeB is closest sibling of nodeA
1168             *
1169             * @param {Node} nodeA
1170             * @param {Node} nodeB
1171             * @return {Boolean}
1172             */
1173
1174            function isClosestSibling(nodeA, nodeB) {
1175                return nodeA.nextSibling === nodeB || nodeA.previousSibling === nodeB;
1176            }
1177
1178            /**
1179             * returns array of closest siblings with node
1180             *
1181             * @param {Node} node
1182             * @param {function} [pred] - predicate function
1183             * @return {Node[]}
1184             */
1185
1186
1187            function withClosestSiblings(node, pred) {
1188                pred = pred || func.ok;
1189                var siblings = [];
1190
1191                if (node.previousSibling && pred(node.previousSibling)) {
1192                    siblings.push(node.previousSibling);
1193                }
1194
1195                siblings.push(node);
1196
1197                if (node.nextSibling && pred(node.nextSibling)) {
1198                    siblings.push(node.nextSibling);
1199                }
1200
1201                return siblings;
1202            }
1203
1204            /**
1205             * blank HTML for cursor position
1206             * - [workaround] old IE only works with &nbsp;
1207             * - [workaround] IE11 and other browser works with bogus br
1208             */
1209
1210
1211            var blankHTML = env.isMSIE && env.browserVersion < 11 ? '&nbsp;' : '<br>';
1212
1213            /**
1214             * @method nodeLength
1215             *
1216             * returns #text's text size or element's childNodes size
1217             *
1218             * @param {Node} node
1219             */
1220
1221            function nodeLength(node) {
1222                if (isText(node)) {
1223                    return node.nodeValue.length;
1224                }
1225
1226                if (node) {
1227                    return node.childNodes.length;
1228                }
1229
1230                return 0;
1231            }
1232
1233            /**
1234             * returns whether deepest child node is empty or not.
1235             *
1236             * @param {Node} node
1237             * @return {Boolean}
1238             */
1239
1240
1241            function deepestChildIsEmpty(node) {
1242                do {
1243                    if (node.firstElementChild === null || node.firstElementChild.innerHTML === '') break;
1244                } while (node = node.firstElementChild);
1245
1246                return dom_isEmpty(node);
1247            }
1248
1249            /**
1250             * returns whether node is empty or not.
1251             *
1252             * @param {Node} node
1253             * @return {Boolean}
1254             */
1255
1256
1257            function dom_isEmpty(node) {
1258                var len = nodeLength(node);
1259
1260                if (len === 0) {
1261                    return true;
1262                } else if (!isText(node) && len === 1 && node.innerHTML === blankHTML) {
1263                    // ex) <p><br></p>, <span><br></span>
1264                    return true;
1265                } else if (lists.all(node.childNodes, isText) && node.innerHTML === '') {
1266                    // ex) <p></p>, <span></span>
1267                    return true;
1268                }
1269
1270                return false;
1271            }
1272
1273            /**
1274             * padding blankHTML if node is empty (for cursor position)
1275             */
1276
1277
1278            function paddingBlankHTML(node) {
1279                if (!isVoid(node) && !nodeLength(node)) {
1280                    node.innerHTML = blankHTML;
1281                }
1282            }
1283
1284            /**
1285             * find nearest ancestor predicate hit
1286             *
1287             * @param {Node} node
1288             * @param {Function} pred - predicate function
1289             */
1290
1291
1292            function ancestor(node, pred) {
1293                while (node) {
1294                    if (pred(node)) {
1295                        return node;
1296                    }
1297
1298                    if (isEditable(node)) {
1299                        break;
1300                    }
1301
1302                    node = node.parentNode;
1303                }
1304
1305                return null;
1306            }
1307
1308            /**
1309             * find nearest ancestor only single child blood line and predicate hit
1310             *
1311             * @param {Node} node
1312             * @param {Function} pred - predicate function
1313             */
1314
1315
1316            function singleChildAncestor(node, pred) {
1317                node = node.parentNode;
1318
1319                while (node) {
1320                    if (nodeLength(node) !== 1) {
1321                        break;
1322                    }
1323
1324                    if (pred(node)) {
1325                        return node;
1326                    }
1327
1328                    if (isEditable(node)) {
1329                        break;
1330                    }
1331
1332                    node = node.parentNode;
1333                }
1334
1335                return null;
1336            }
1337
1338            /**
1339             * returns new array of ancestor nodes (until predicate hit).
1340             *
1341             * @param {Node} node
1342             * @param {Function} [optional] pred - predicate function
1343             */
1344
1345
1346            function listAncestor(node, pred) {
1347                pred = pred || func.fail;
1348                var ancestors = [];
1349                ancestor(node, function (el) {
1350                    if (!isEditable(el)) {
1351                        ancestors.push(el);
1352                    }
1353
1354                    return pred(el);
1355                });
1356                return ancestors;
1357            }
1358
1359            /**
1360             * find farthest ancestor predicate hit
1361             */
1362
1363
1364            function lastAncestor(node, pred) {
1365                var ancestors = listAncestor(node);
1366                return lists.last(ancestors.filter(pred));
1367            }
1368
1369            /**
1370             * returns common ancestor node between two nodes.
1371             *
1372             * @param {Node} nodeA
1373             * @param {Node} nodeB
1374             */
1375
1376
1377            function commonAncestor(nodeA, nodeB) {
1378                var ancestors = listAncestor(nodeA);
1379
1380                for (var n = nodeB; n; n = n.parentNode) {
1381                    if (ancestors.indexOf(n) > -1) return n;
1382                }
1383
1384                return null; // difference document area
1385            }
1386
1387            /**
1388             * listing all previous siblings (until predicate hit).
1389             *
1390             * @param {Node} node
1391             * @param {Function} [optional] pred - predicate function
1392             */
1393
1394
1395            function listPrev(node, pred) {
1396                pred = pred || func.fail;
1397                var nodes = [];
1398
1399                while (node) {
1400                    if (pred(node)) {
1401                        break;
1402                    }
1403
1404                    nodes.push(node);
1405                    node = node.previousSibling;
1406                }
1407
1408                return nodes;
1409            }
1410
1411            /**
1412             * listing next siblings (until predicate hit).
1413             *
1414             * @param {Node} node
1415             * @param {Function} [pred] - predicate function
1416             */
1417
1418
1419            function listNext(node, pred) {
1420                pred = pred || func.fail;
1421                var nodes = [];
1422
1423                while (node) {
1424                    if (pred(node)) {
1425                        break;
1426                    }
1427
1428                    nodes.push(node);
1429                    node = node.nextSibling;
1430                }
1431
1432                return nodes;
1433            }
1434
1435            /**
1436             * listing descendant nodes
1437             *
1438             * @param {Node} node
1439             * @param {Function} [pred] - predicate function
1440             */
1441
1442
1443            function listDescendant(node, pred) {
1444                var descendants = [];
1445                pred = pred || func.ok; // start DFS(depth first search) with node
1446
1447                (function fnWalk(current) {
1448                    if (node !== current && pred(current)) {
1449                        descendants.push(current);
1450                    }
1451
1452                    for (var idx = 0, len = current.childNodes.length; idx < len; idx++) {
1453                        fnWalk(current.childNodes[idx]);
1454                    }
1455                })(node);
1456
1457                return descendants;
1458            }
1459
1460            /**
1461             * wrap node with new tag.
1462             *
1463             * @param {Node} node
1464             * @param {Node} tagName of wrapper
1465             * @return {Node} - wrapper
1466             */
1467
1468
1469            function wrap(node, wrapperName) {
1470                var parent = node.parentNode;
1471                var wrapper = external_jQuery_default()('<' + wrapperName + '>')[0];
1472                parent.insertBefore(wrapper, node);
1473                wrapper.appendChild(node);
1474                return wrapper;
1475            }
1476
1477            /**
1478             * insert node after preceding
1479             *
1480             * @param {Node} node
1481             * @param {Node} preceding - predicate function
1482             */
1483
1484
1485            function insertAfter(node, preceding) {
1486                var next = preceding.nextSibling;
1487                var parent = preceding.parentNode;
1488
1489                if (next) {
1490                    parent.insertBefore(node, next);
1491                } else {
1492                    parent.appendChild(node);
1493                }
1494
1495                return node;
1496            }
1497
1498            /**
1499             * append elements.
1500             *
1501             * @param {Node} node
1502             * @param {Collection} aChild
1503             */
1504
1505
1506            function appendChildNodes(node, aChild) {
1507                external_jQuery_default().each(aChild, function (idx, child) {
1508                    node.appendChild(child);
1509                });
1510                return node;
1511            }
1512
1513            /**
1514             * returns whether boundaryPoint is left edge or not.
1515             *
1516             * @param {BoundaryPoint} point
1517             * @return {Boolean}
1518             */
1519
1520
1521            function isLeftEdgePoint(point) {
1522                return point.offset === 0;
1523            }
1524
1525            /**
1526             * returns whether boundaryPoint is right edge or not.
1527             *
1528             * @param {BoundaryPoint} point
1529             * @return {Boolean}
1530             */
1531
1532
1533            function isRightEdgePoint(point) {
1534                return point.offset === nodeLength(point.node);
1535            }
1536
1537            /**
1538             * returns whether boundaryPoint is edge or not.
1539             *
1540             * @param {BoundaryPoint} point
1541             * @return {Boolean}
1542             */
1543
1544
1545            function isEdgePoint(point) {
1546                return isLeftEdgePoint(point) || isRightEdgePoint(point);
1547            }
1548
1549            /**
1550             * returns whether node is left edge of ancestor or not.
1551             *
1552             * @param {Node} node
1553             * @param {Node} ancestor
1554             * @return {Boolean}
1555             */
1556
1557
1558            function isLeftEdgeOf(node, ancestor) {
1559                while (node && node !== ancestor) {
1560                    if (position(node) !== 0) {
1561                        return false;
1562                    }
1563
1564                    node = node.parentNode;
1565                }
1566
1567                return true;
1568            }
1569
1570            /**
1571             * returns whether node is right edge of ancestor or not.
1572             *
1573             * @param {Node} node
1574             * @param {Node} ancestor
1575             * @return {Boolean}
1576             */
1577
1578
1579            function isRightEdgeOf(node, ancestor) {
1580                if (!ancestor) {
1581                    return false;
1582                }
1583
1584                while (node && node !== ancestor) {
1585                    if (position(node) !== nodeLength(node.parentNode) - 1) {
1586                        return false;
1587                    }
1588
1589                    node = node.parentNode;
1590                }
1591
1592                return true;
1593            }
1594
1595            /**
1596             * returns whether point is left edge of ancestor or not.
1597             * @param {BoundaryPoint} point
1598             * @param {Node} ancestor
1599             * @return {Boolean}
1600             */
1601
1602
1603            function isLeftEdgePointOf(point, ancestor) {
1604                return isLeftEdgePoint(point) && isLeftEdgeOf(point.node, ancestor);
1605            }
1606
1607            /**
1608             * returns whether point is right edge of ancestor or not.
1609             * @param {BoundaryPoint} point
1610             * @param {Node} ancestor
1611             * @return {Boolean}
1612             */
1613
1614
1615            function isRightEdgePointOf(point, ancestor) {
1616                return isRightEdgePoint(point) && isRightEdgeOf(point.node, ancestor);
1617            }
1618
1619            /**
1620             * returns offset from parent.
1621             *
1622             * @param {Node} node
1623             */
1624
1625
1626            function position(node) {
1627                var offset = 0;
1628
1629                while (node = node.previousSibling) {
1630                    offset += 1;
1631                }
1632
1633                return offset;
1634            }
1635
1636            function hasChildren(node) {
1637                return !!(node && node.childNodes && node.childNodes.length);
1638            }
1639
1640            /**
1641             * returns previous boundaryPoint
1642             *
1643             * @param {BoundaryPoint} point
1644             * @param {Boolean} isSkipInnerOffset
1645             * @return {BoundaryPoint}
1646             */
1647
1648
1649            function prevPoint(point, isSkipInnerOffset) {
1650                var node;
1651                var offset;
1652
1653                if (point.offset === 0) {
1654                    if (isEditable(point.node)) {
1655                        return null;
1656                    }
1657
1658                    node = point.node.parentNode;
1659                    offset = position(point.node);
1660                } else if (hasChildren(point.node)) {
1661                    node = point.node.childNodes[point.offset - 1];
1662                    offset = nodeLength(node);
1663                } else {
1664                    node = point.node;
1665                    offset = isSkipInnerOffset ? 0 : point.offset - 1;
1666                }
1667
1668                return {
1669                    node: node,
1670                    offset: offset
1671                };
1672            }
1673
1674            /**
1675             * returns next boundaryPoint
1676             *
1677             * @param {BoundaryPoint} point
1678             * @param {Boolean} isSkipInnerOffset
1679             * @return {BoundaryPoint}
1680             */
1681
1682
1683            function nextPoint(point, isSkipInnerOffset) {
1684                var node, offset;
1685
1686                if (nodeLength(point.node) === point.offset) {
1687                    if (isEditable(point.node)) {
1688                        return null;
1689                    }
1690
1691                    var nextTextNode = getNextTextNode(point.node);
1692
1693                    if (nextTextNode) {
1694                        node = nextTextNode;
1695                        offset = 0;
1696                    } else {
1697                        node = point.node.parentNode;
1698                        offset = position(point.node) + 1;
1699                    }
1700                } else if (hasChildren(point.node)) {
1701                    node = point.node.childNodes[point.offset];
1702                    offset = 0;
1703                } else {
1704                    node = point.node;

1705                    offset = isSkipInnerOffset ? nodeLength(point.node) : point.offset + 1;
1706                }
1707
1708                return {
1709                    node: node,
1710                    offset: offset
1711                };
1712            }
1713
1714            /**
1715             * returns next boundaryPoint with empty node
1716             *
1717             * @param {BoundaryPoint} point
1718             * @param {Boolean} isSkipInnerOffset
1719             * @return {BoundaryPoint}
1720             */
1721
1722
1723            function nextPointWithEmptyNode(point, isSkipInnerOffset) {
1724                var node,
1725                    offset = 0; // if node is empty string node, return current node's sibling.
1726
1727                if (dom_isEmpty(point.node)) {
1728                    if (point.node === null) {
1729                        return null;
1730                    }
1731
1732                    node = point.node.nextSibling;
1733                    offset = 0;
1734                    return {
1735                        node: node,
1736                        offset: offset
1737                    };
1738                }
1739
1740                if (nodeLength(point.node) === point.offset) {
1741                    if (isEditable(point.node)) {
1742                        return null;
1743                    }
1744
1745                    node = point.node.parentNode;
1746                    offset = position(point.node) + 1; // if next node is editable ,  return current node's sibling node.
1747
1748                    if (isEditable(node)) {
1749                        node = point.node.nextSibling;
1750                        offset = 0;
1751                    }
1752                } else if (hasChildren(point.node)) {
1753                    node = point.node.childNodes[point.offset];
1754                    offset = 0;
1755
1756                    if (dom_isEmpty(node)) {
1757                        if (!dom_isEmpty(point.node.nextSibling)) {
1758                            return {
1759                                node: point.node.nextSibling,
1760                                offset: offset
1761                            };
1762                        }
1763
1764                        return null;
1765                    }
1766                } else {
1767                    node = point.node;
1768                    offset = isSkipInnerOffset ? nodeLength(point.node) : point.offset + 1;
1769
1770                    if (dom_isEmpty(node)) {
1771                        return null;
1772                    }
1773                }
1774
1775                return {
1776                    node: node,
1777                    offset: offset
1778                };
1779            }
1780
1781            /*
1782* returns the next Text node index or 0 if not found.
1783*/
1784
1785
1786            function getNextTextNode(actual) {
1787                if (!actual.nextSibling) return undefined;
1788                if (actual.parent !== actual.nextSibling.parent) return undefined;
1789                if (isText(actual.nextSibling)) return actual.nextSibling; else return getNextTextNode(actual.nextSibling);
1790            }
1791
1792            /**
1793             * returns whether pointA and pointB is same or not.
1794             *
1795             * @param {BoundaryPoint} pointA
1796             * @param {BoundaryPoint} pointB
1797             * @return {Boolean}
1798             */
1799
1800
1801            function isSamePoint(pointA, pointB) {
1802                return pointA.node === pointB.node && pointA.offset === pointB.offset;
1803            }
1804
1805            /**
1806             * returns whether point is visible (can set cursor) or not.
1807             *
1808             * @param {BoundaryPoint} point
1809             * @return {Boolean}
1810             */
1811
1812
1813            function isVisiblePoint(point) {
1814                if (isText(point.node) || !hasChildren(point.node) || dom_isEmpty(point.node)) {
1815                    return true;
1816                }
1817
1818                var leftNode = point.node.childNodes[point.offset - 1];
1819                var rightNode = point.node.childNodes[point.offset];
1820
1821                if ((!leftNode || isVoid(leftNode)) && (!rightNode || isVoid(rightNode)) || isTable(rightNode)) {
1822                    return true;
1823                }
1824
1825                return false;
1826            }
1827
1828            /**
1829             * @method prevPointUtil
1830             *
1831             * @param {BoundaryPoint} point
1832             * @param {Function} pred
1833             * @return {BoundaryPoint}
1834             */
1835
1836
1837            function prevPointUntil(point, pred) {
1838                while (point) {
1839                    if (pred(point)) {
1840                        return point;
1841                    }
1842
1843                    point = prevPoint(point);
1844                }
1845
1846                return null;
1847            }
1848
1849            /**
1850             * @method nextPointUntil
1851             *
1852             * @param {BoundaryPoint} point
1853             * @param {Function} pred
1854             * @return {BoundaryPoint}
1855             */
1856
1857
1858            function nextPointUntil(point, pred) {
1859                while (point) {
1860                    if (pred(point)) {
1861                        return point;
1862                    }
1863
1864                    point = nextPoint(point);
1865                }
1866
1867                return null;
1868            }
1869
1870            /**
1871             * returns whether point has character or not.
1872             *
1873             * @param {Point} point
1874             * @return {Boolean}
1875             */
1876
1877
1878            function isCharPoint(point) {
1879                if (!isText(point.node)) {
1880                    return false;
1881                }
1882
1883                var ch = point.node.nodeValue.charAt(point.offset - 1);
1884                return ch && ch !== ' ' && ch !== NBSP_CHAR;
1885            }
1886
1887            /**
1888             * returns whether point has space or not.
1889             *
1890             * @param {Point} point
1891             * @return {Boolean}
1892             */
1893
1894
1895            function isSpacePoint(point) {
1896                if (!isText(point.node)) {
1897                    return false;
1898                }
1899
1900                var ch = point.node.nodeValue.charAt(point.offset - 1);
1901                return ch === ' ' || ch === NBSP_CHAR;
1902            }
1903
1904            /**
1905             * @method walkPoint
1906             *
1907             * @param {BoundaryPoint} startPoint
1908             * @param {BoundaryPoint} endPoint
1909             * @param {Function} handler
1910             * @param {Boolean} isSkipInnerOffset
1911             */
1912
1913
1914            function walkPoint(startPoint, endPoint, handler, isSkipInnerOffset) {
1915                var point = startPoint;
1916
1917                while (point) {
1918                    handler(point);
1919
1920                    if (isSamePoint(point, endPoint)) {
1921                        break;
1922                    }
1923
1924                    var isSkipOffset = isSkipInnerOffset && startPoint.node !== point.node && endPoint.node !== point.node;

1925                    point = nextPointWithEmptyNode(point, isSkipOffset);
1926                }
1927            }
1928
1929            /**
1930             * @method makeOffsetPath
1931             *
1932             * return offsetPath(array of offset) from ancestor
1933             *
1934             * @param {Node} ancestor - ancestor node
1935             * @param {Node} node
1936             */
1937
1938
1939            function makeOffsetPath(ancestor, node) {
1940                var ancestors = listAncestor(node, func.eq(ancestor));
1941                return ancestors.map(position).reverse();
1942            }
1943
1944            /**
1945             * @method fromOffsetPath
1946             *
1947             * return element from offsetPath(array of offset)
1948             *
1949             * @param {Node} ancestor - ancestor node
1950             * @param {array} offsets - offsetPath
1951             */
1952
1953
1954            function fromOffsetPath(ancestor, offsets) {
1955                var current = ancestor;
1956
1957                for (var i = 0, len = offsets.length; i < len; i++) {
1958                    if (current.childNodes.length <= offsets[i]) {
1959                        current = current.childNodes[current.childNodes.length - 1];
1960                    } else {
1961                        current = current.childNodes[offsets[i]];
1962                    }
1963                }
1964
1965                return current;
1966            }
1967
1968            /**
1969             * @method splitNode
1970             *
1971             * split element or #text
1972             *
1973             * @param {BoundaryPoint} point
1974             * @param {Object} [options]
1975             * @param {Boolean} [options.isSkipPaddingBlankHTML] - default: false
1976             * @param {Boolean} [options.isNotSplitEdgePoint] - default: false
1977             * @param {Boolean} [options.isDiscardEmptySplits] - default: false
1978             * @return {Node} right node of boundaryPoint
1979             */
1980
1981
1982            function splitNode(point, options) {
1983                var isSkipPaddingBlankHTML = options && options.isSkipPaddingBlankHTML;
1984                var isNotSplitEdgePoint = options && options.isNotSplitEdgePoint;
1985                var isDiscardEmptySplits = options && options.isDiscardEmptySplits;
1986
1987                if (isDiscardEmptySplits) {
1988                    isSkipPaddingBlankHTML = true;
1989                } // edge case
1990
1991
1992                if (isEdgePoint(point) && (isText(point.node) || isNotSplitEdgePoint)) {
1993                    if (isLeftEdgePoint(point)) {
1994                        return point.node;

1995                    } else if (isRightEdgePoint(point)) {
1996                        return point.node.nextSibling;
1997                    }
1998                } // split #text
1999
2000
2001                if (isText(point.node)) {
2002                    return point.node.splitText(point.offset);
2003                } else {
2004                    var childNode = point.node.childNodes[point.offset];
2005                    var clone = insertAfter(point.node.cloneNode(false), point.node);
2006                    appendChildNodes(clone, listNext(childNode));
2007
2008                    if (!isSkipPaddingBlankHTML) {
2009                        paddingBlankHTML(point.node);
2010                        paddingBlankHTML(clone);
2011                    }
2012
2013                    if (isDiscardEmptySplits) {
2014                        if (dom_isEmpty(point.node)) {
2015                            remove(point.node);
2016                        }
2017
2018                        if (dom_isEmpty(clone)) {
2019                            remove(clone);
2020                            return point.node.nextSibling;
2021                        }
2022                    }
2023
2024                    return clone;
2025                }
2026            }
2027
2028            /**
2029             * @method splitTree
2030             *
2031             * split tree by point
2032             *
2033             * @param {Node} root - split root
2034             * @param {BoundaryPoint} point
2035             * @param {Object} [options]
2036             * @param {Boolean} [options.isSkipPaddingBlankHTML] - default: false
2037             * @param {Boolean} [options.isNotSplitEdgePoint] - default: false
2038             * @return {Node} right node of boundaryPoint
2039             */
2040
2041
2042            function splitTree(root, point, options) {
2043                // ex) [#text, <span>, <p>]
2044                var ancestors = listAncestor(point.node, func.eq(root));
2045
2046                if (!ancestors.length) {
2047                    return null;
2048                } else if (ancestors.length === 1) {
2049                    return splitNode(point, options);
2050                }
2051
2052                return ancestors.reduce(function (node, parent) {
2053                    if (node === point.node) {
2054                        node = splitNode(point, options);
2055                    }
2056
2057                    return splitNode({
2058                        node: parent,
2059                        offset: node ? position(node) : nodeLength(parent)
2060                    }, options);
2061                });
2062            }
2063
2064            /**
2065             * split point
2066             *
2067             * @param {Point} point
2068             * @param {Boolean} isInline
2069             * @return {Object}
2070             */
2071
2072
2073            function splitPoint(point, isInline) {
2074                // find splitRoot, container
2075                //  - inline: splitRoot is a child of paragraph
2076                //  - block: splitRoot is a child of bodyContainer
2077                var pred = isInline ? isPara : isBodyContainer;
2078                var ancestors = listAncestor(point.node, pred);
2079                var topAncestor = lists.last(ancestors) || point.node;
2080                var splitRoot, container;
2081
2082                if (pred(topAncestor)) {
2083                    splitRoot = ancestors[ancestors.length - 2];
2084                    container = topAncestor;
2085                } else {
2086                    splitRoot = topAncestor;
2087                    container = splitRoot.parentNode;
2088                } // if splitRoot is exists, split with splitTree
2089
2090
2091                var pivot = splitRoot && splitTree(splitRoot, point, {
2092                    isSkipPaddingBlankHTML: isInline,
2093                    isNotSplitEdgePoint: isInline
2094                }); // if container is point.node, find pivot with point.offset
2095
2096                if (!pivot && container === point.node) {
2097                    pivot = point.node.childNodes[point.offset];
2098                }
2099
2100                return {
2101                    rightNode: pivot,
2102                    container: container
2103                };
2104            }
2105
2106            function create(nodeName) {
2107                return document.createElement(nodeName);
2108            }
2109
2110            function createText(text) {
2111                return document.createTextNode(text);
2112            }
2113
2114            /**
2115             * @method remove
2116             *
2117             * remove node, (isRemoveChild: remove child or not)
2118             *
2119             * @param {Node} node
2120             * @param {Boolean} isRemoveChild
2121             */
2122
2123
2124            function remove(node, isRemoveChild) {
2125                if (!node || !node.parentNode) {
2126                    return;
2127                }
2128
2129                if (node.removeNode) {
2130                    return node.removeNode(isRemoveChild);
2131                }
2132
2133                var parent = node.parentNode;
2134
2135                if (!isRemoveChild) {
2136                    var nodes = [];
2137
2138                    for (var i = 0, len = node.childNodes.length; i < len; i++) {
2139                        nodes.push(node.childNodes[i]);
2140                    }
2141
2142                    for (var _i = 0, _len = nodes.length; _i < _len; _i++) {
2143                        parent.insertBefore(nodes[_i], node);
2144                    }
2145                }
2146
2147                parent.removeChild(node);
2148            }
2149
2150            /**
2151             * @method removeWhile
2152             *
2153             * @param {Node} node
2154             * @param {Function} pred
2155             */
2156
2157
2158            function removeWhile(node, pred) {
2159                while (node) {
2160                    if (isEditable(node) || !pred(node)) {
2161                        break;
2162                    }
2163
2164                    var parent = node.parentNode;
2165                    remove(node);
2166                    node = parent;
2167                }
2168            }
2169
2170            /**
2171             * @method replace
2172             *
2173             * replace node with provided nodeName
2174             *
2175             * @param {Node} node
2176             * @param {String}

2176 nodeName
2177             * @return {Node} - new node
2178             */
2179
2180
2181            function replace(node, nodeName) {
2182                if (node.nodeName.toUpperCase() === nodeName.toUpperCase()) {
2183                    return node;
2184                }
2185
2186                var newNode = create(nodeName);
2187
2188                if (node.style.cssText) {
2189                    newNode.style.cssText = node.style.cssText;
2190                }
2191
2192                appendChildNodes(newNode, lists.from(node.childNodes));
2193                insertAfter(newNode, node);
2194                remove(node);
2195                return newNode;
2196            }
2197
2198            var isTextarea = makePredByNodeName('TEXTAREA');
2199
2200            /**
2201             * @param {jQuery} $node
2202             * @param {Boolean} [stripLinebreaks] - default: false
2203             */
2204
2205            function value($node, stripLinebreaks) {
2206                var val = isTextarea($node[0]) ? $node.val() : $node.html();
2207
2208                if (stripLinebreaks) {
2209                    return val.replace(/[\n\r]/g, '');
2210                }
2211
2212                return val;
2213            }
2214
2215            /**
2216             * @method html
2217             *
2218             * get the HTML contents of node
2219             *
2220             * @param {jQuery} $node
2221             * @param {Boolean} [isNewlineOnBlock]
2222             */
2223
2224
2225            function html($node, isNewlineOnBlock) {
2226                var markup = value($node);
2227
2228                if (isNewlineOnBlock) {
2229                    var regexTag = /<(\/?)(\b(?!!)[^>\s]*)(.*?)(\s*\/?>)/g;
2230                    markup = markup.replace(regexTag, function (match, endSlash, name) {
2231                        name = name.toUpperCase();
2232                        var isEndOfInlineContainer = /^DIV|^TD|^TH|^P|^LI|^H[1-7]/.test(name) && !!endSlash;
2233                        var isBlockNode = /^BLOCKQUOTE|^TABLE|^TBODY|^TR|^HR|^UL|^OL/.test(name);
2234                        return match + (isEndOfInlineContainer || isBlockNode ? '\n' : '');
2235                    });
2236                    markup = markup.trim();
2237                }
2238
2239                return markup;
2240            }
2241
2242            function posFromPlaceholder(placeholder) {
2243                var $placeholder = external_jQuery_default()(placeholder);
2244                var pos = $placeholder.offset();
2245                var height = $placeholder.outerHeight(true); // include margin
2246
2247                return {
2248                    left: pos.left,
2249                    top: pos.top + height
2250                };
2251            }
2252
2253            function attachEvents($node, events) {
2254                Object.keys(events).forEach(function (key) {
2255                    $node.on(key, events[key]);
2256                });
2257            }
2258
2259            function detachEvents($node, events) {
2260                Object.keys(events).forEach(function (key) {
2261                    $node.off(key, events[key]);
2262                });
2263            }
2264
2265            /**
2266             * @method isCustomStyleTag
2267             *
2268             * assert if a node contains a "note-styletag" class,
2269             * which implies that's a custom-made style tag node
2270             *
2271             * @param {Node} an HTML DOM node
2272             */
2273
2274
2275            function isCustomStyleTag(node) {
2276                return node && !isText(node) && lists.contains(node.classList, 'note-styletag');
2277            }
2278
2279            /* harmony default export */
2280            const dom = ({
2281                /** @property {String} NBSP_CHAR */
2282                NBSP_CHAR: NBSP_CHAR,
2283
2284                /** @property {String} ZERO_WIDTH_NBSP_CHAR */
2285                ZERO_WIDTH_NBSP_CHAR: ZERO_WIDTH_NBSP_CHAR,
2286
2287                /** @property {String} blank */
2288                blank: blankHTML,
2289
2290                /** @property {String} emptyPara */
2291                emptyPara: "<div>".concat(blankHTML, "</div>"),
2292                makePredByNodeName: makePredByNodeName,
2293                isEditable: isEditable,
2294                isControlSizing: isControlSizing,
2295                isText: isText,
2296                isElement: isElement,
2297                isVoid: isVoid,
2298                isPara: isPara,
2299                isPurePara: isPurePara,
2300                isHeading: isHeading,
2301                isInline: isInline,
2302                isBlock: func.not(isInline),
2303                isBodyInline: isBodyInline,
2304                isBody: isBody,
2305                isParaInline: isParaInline,
2306                isPre: isPre,
2307                isList: isList,
2308                isTable: isTable,
2309                isData: isData,
2310                isCell: isCell,
2311                isBlockquote: isBlockquote,
2312                isBodyContainer: isBodyContainer,
2313                isAnchor: isAnchor,
2314                isDiv: makePredByNodeName('DIV'),
2315                isLi: isLi,
2316                isBR: makePredByNodeName('BR'),
2317                isSpan: makePredByNodeName('SPAN'),
2318                isB: makePredByNodeName('B'),
2319                isU: makePredByNodeName('U'),
2320                isS: makePredByNodeName('S'),
2321                isI: makePredByNodeName('I'),
2322                isImg: makePredByNodeName('IMG'),
2323                isTextarea: isTextarea,

2324                deepestChildIsEmpty: deepestChildIsEmpty,
2325                isEmpty: dom_isEmpty,
2326                isEmptyAnchor: func.and(isAnchor, dom_isEmpty),
2327                isClosestSibling: isClosestSibling,
2328                withClosestSiblings: withClosestSiblings,
2329                nodeLength: nodeLength,
2330                isLeftEdgePoint: isLeftEdgePoint,
2331                isRightEdgePoint: isRightEdgePoint,
2332                isEdgePoint: isEdgePoint,
2333                isLeftEdgeOf: isLeftEdgeOf,
2334                isRightEdgeOf: isRightEdgeOf,
2335                isLeftEdgePointOf: isLeftEdgePointOf,
2336                isRightEdgePointOf: isRightEdgePointOf,
2337                prevPoint: prevPoint,
2338                nextPoint: nextPoint,
2339                nextPointWithEmptyNode: nextPointWithEmptyNode,
2340                isSamePoint: isSamePoint,
2341                isVisiblePoint: isVisiblePoint,
2342                prevPointUntil: prevPointUntil,
2343                nextPointUntil: nextPointUntil,
2344                isCharPoint: isCharPoint,
2345                isSpacePoint: isSpacePoint,
2346                walkPoint: walkPoint,
2347                ancestor: ancestor,
2348                singleChildAncestor: singleChildAncestor,
2349                listAncestor: listAncestor,
2350                lastAncestor: lastAncestor,
2351                listNext: listNext,
2352                listPrev: listPrev,
2353                listDescendant: listDescendant,
2354                commonAncestor: commonAncestor,
2355                wrap: wrap,
2356                insertAfter: insertAfter,
2357                appendChildNodes: appendChildNodes,
2358                position: position,
2359                hasChildren: hasChildren,
2360                makeOffsetPath: makeOffsetPath,
2361                fromOffsetPath: fromOffsetPath,
2362                splitTree: splitTree,
2363                splitPoint: splitPoint,
2364                create: create,
2365                createText: createText,
2366                remove: remove,
2367                removeWhile: removeWhile,
2368                replace: replace,
2369                html: html,
2370                value: value,
2371                posFromPlaceholder: posFromPlaceholder,
2372                attachEvents: attachEvents,
2373                detachEvents: detachEvents,
2374                isCustomStyleTag: isCustomStyleTag
2375            });
2376            ;// CONCATENATED MODULE: ./src/js/Context.js
2377            function _classCallCheck(instance, Constructor) {
2378                if (!(instance instanceof Constructor)) {
2379                    throw new TypeError("Cannot call a class as a function");
2380                }
2381            }
2382
2383            function _defineProperties(target, props) {
2384                for (var i = 0; i < props.length; i++) {
2385                    var descriptor = props[i];
2386                    descriptor.enumerable = descriptor.enumerable || false;
2387                    descriptor.configurable = true;
2388                    if ("value" in descriptor) descriptor.writable = true;
2389                    Object.defineProperty(target, descriptor.key, descriptor);
2390                }
2391            }
2392
2393            function _createClass(Constructor, protoProps, staticProps) {
2394                if (protoProps) _defineProperties(Constructor.prototype, protoProps);
2395                if (staticProps) _defineProperties(Constructor, staticProps);
2396                return Constructor;
2397            }
2398
2399
2400            var Context = /*#__PURE__*/function () {
2401                /**
2402                 * @param {jQuery} $note
2403                 * @param {Object} options
2404                 */
2405                function Context($note, options) {
2406                    _classCallCheck(this, Context);
2407
2408                    this.$note = $note;
2409                    this.memos = {};
2410                    this.modules = {};
2411                    this.layoutInfo = {};
2412                    this.options = external_jQuery_default().extend(true, {}, options); // init ui with options
2413
2414                    (external_jQuery_default()).summernote.ui = external_jQuery_default().summernote.ui_template(this.options);
2415                    this.ui = (external_jQuery_default()).summernote.ui;
2416                    this.initialize();
2417                }
2418
2419                /**
2420                 * create layout and initialize modules and other resources
2421                 */
2422
2423
2424                _createClass(Context, [{
2425                    key: "initialize",
2426                    value: function initialize() {
2427                        this.layoutInfo = this.ui.createLayout(this.$note);
2428
2429                        this._initialize();
2430
2431                        this.$note.hide();
2432                        return this;
2433                    }
2434                    /**
2435                     * destroy modules and other resources and remove layout
2436                     */
2437
2438                }, {

2439                    key: "destroy",
2440                    value: function destroy() {
2441                        this._destroy();
2442
2443                        this.$note.removeData('summernote');
2444                        this.ui.removeLayout(this.$note, this.layoutInfo);
2445                    }
2446                    /**
2447                     * destory modules and other resources and initialize it again
2448                     */
2449
2450                }, {
2451                    key: "reset",
2452                    value: function reset() {
2453                        var disabled = this.isDisabled();
2454                        this.code(dom.emptyPara);
2455
2456                        this._destroy();
2457
2458                        this._initialize();
2459
2460                        if (disabled) {
2461                            this.disable();
2462                        }
2463                    }
2464                }, {
2465                    key: "_initialize",
2466                    value: function _initialize() {
2467                        var _this = this;
2468
2469                        // set own id
2470                        this.options.id = func.uniqueId(external_jQuery_default().now()); // set default container for tooltips, popovers, and dialogs
2471
2472                        this.options.container = this.options.container || this.layoutInfo.editor; // add optional buttons
2473
2474                        var buttons = external_jQuery_default().extend({}, this.options.buttons);
2475                        Object.keys(buttons).forEach(function (key) {
2476                            _this.memo('button.' + key, buttons[key]);
2477                        });
2478                        var modules = external_jQuery_default().extend({}, this.options.modules, (external_jQuery_default()).summernote.plugins || {}); // add and initialize modules
2479
2480                        Object.keys(modules).forEach(function (key) {
2481                            _this.module(key, modules[key], true);
2482                        });
2483                        Object.keys(this.modules).forEach(function (key) {
2484                            _this.initializeModule(key);
2485                        });
2486                    }
2487                }, {
2488                    key: "_destroy",
2489                    value: function _destroy() {
2490                        var _this2 = this;
2491
2492                        // destroy modules with reversed order
2493                        Object.keys(this.modules).reverse().forEach(function (key) {
2494                            _this2.removeModule(key);
2495                        });
2496                        Object.keys(this.memos).forEach(function (key) {
2497                            _this2.removeMemo(key);
2498                        }); // trigger custom onDestroy callback
2499
2500                        this.triggerEvent('destroy', this);
2501                    }
2502                }, {
2503                    key: "code",
2504                    value: function code(html) {
2505                        var isActivated = this.invoke('codeview.isActivated');
2506
2507                        if (html === undefined) {
2508                            this.invoke('codeview.sync');
2509                            return isActivated ? this.layoutInfo.codable.val() : this.layoutInfo.editable.html();
2510                        } else {
2511                            if (isActivated) {
2512                                this.invoke('codeview.sync', html);
2513                            } else {
2514                                this.layoutInfo.editable.html(html);
2515                            }
2516
2517                            this.$note.val(html);
2518                            this.triggerEvent('change', html, this.layoutInfo.editable);
2519                        }
2520                    }
2521                }, {
2522                    key: "isDisabled",
2523                    value: function isDisabled() {
2524                        return this.layoutInfo.editable.attr('contenteditable') === 'false';
2525                    }
2526                }, {
2527                    key: "enable",
2528                    value: function enable() {
2529                        this.layoutInfo.editable.attr('contenteditable', true);
2530                        this.invoke('toolbar.activate', true);
2531                        this.triggerEvent('disable', false);
2532                        this.options.editing = true;
2533                    }
2534                }, {
2535                    key: "disable",
2536                    value: function disable() {
2537                        // close codeview if codeview is opend
2538                        if (this.invoke('codeview.isActivated')) {
2539                            this.invoke('codeview.deactivate');
2540                        }
2541
2542                        this.layoutInfo.editable.attr('contenteditable', false);
2543                        this.options.editing = false;
2544                        this.invoke('toolbar.deactivate', true);
2545                        this.triggerEvent('disable', true);
2546                    }
2547                }, {
2548                    key: "triggerEvent",
2549                    value: function triggerEvent() {
2550                        var namespace = lists.head(arguments);
2551                        var args = lists.tail(lists.from(arguments));
2552                        var callback = this.options.callbacks[func.namespaceToCamel(namespace, 'on')];
2553
2554                        if (callback) {
2555                            callback.apply(this.$note[0], args);
2556                        }
2557
2558                        this.$note.trigger('summernote.' + namespace, args);
2559                    }
2560                }, {
2561                    key: "initializeModule",
2562                    value: function initializeModule(key) {
2563                        var module = this.modules[key];
2564                        module.shouldInitialize = module.shouldInitialize || func.ok;
2565
2566                        if (!module.shouldInitialize()) {
2567                            return;
2568                        } // initialize module
2569
2570
2571                        if (module.initialize) {
2572                            module.initialize();
2573                        } // attach events
2574
2575
2576                        if (module.events) {
2577                            dom.attachEvents(this.$note, module.events);
2578                        }
2579                    }
2580                }, {
2581                    key: "module",
2582                    value: function module(key, ModuleClass, withoutIntialize) {
2583                        if (arguments.length === 1) {
2584                            return this.modules[key];
2585                        }
2586
2587                        this.modules[key] = new ModuleClass(this);
2588
2589                        if (!withoutIntialize) {
2590                            this.initializeModule(key);
2591                        }
2592                    }
2593                }, {
2594                    key: "removeModule",
2595                    value: function removeModule(key) {
2596                        var module = this.modules[key];
2597
2598                        if (module.shouldInitialize()) {
2599                            if (module.events) {
2600                                dom.detachEvents(this.$note, module.events);
2601                            }
2602
2603                            if (module.destroy) {
2604                                module.destroy();
2605                            }
2606                        }
2607
2608                        delete this.modules[key];
2609                    }
2610                }, {
2611                    key: "memo",
2612                    value: function memo(key, obj) {
2613                        if (arguments.length === 1) {
2614                            return this.memos[key];
2615                        }
2616
2617                        this.memos[key] = obj;
2618                    }
2619                }, {
2620                    key: "removeMemo",
2621                    value: function removeMemo(key) {
2622                        if (this.memos[key] && this.memos[key].destroy) {
2623                            this.memos[key].destroy();
2624                        }
2625
2626                        delete this.memos[key];
2627                    }
2628                    /**
2629                     * Some buttons need to change their visual style immediately once they get pressed
2630                     */
2631
2632                }, {
2633                    key: "createInvokeHandlerAndUpdateState",
2634                    value: function createInvokeHandlerAndUpdateState(namespace, value) {
2635                        var _this3 = this;
2636
2637                        return function (event) {
2638                            _this3.createInvokeHandler(namespace, value)(event);
2639
2640                            _this3.invoke('buttons.updateCurrentStyle');
2641                        };
2642                    }
2643                }, {
2644                    key: "createInvokeHandler",
2645                    value: function createInvokeHandler(namespace, value) {
2646                        var _this4 = this;
2647
2648                        return function (event) {
2649                            event.preventDefault();
2650                            var $target = external_jQuery_default()(event.target);
2651
2652                            _this4.invoke(namespace, value || $target.closest('[data-value]').data('value'), $target);
2653                        };
2654                    }
2655                }, {
2656                    key: "invoke",
2657                    value: function invoke() {
2658                        var namespace = lists.head(arguments);
2659                        var args = lists.tail(lists.from(arguments));
2660                        var splits = namespace.split('.');
2661                        var hasSeparator = splits.length > 1;
2662                        var moduleName = hasSeparator && lists.head(splits);
2663                        var methodName = hasSeparator ? lists.last(splits) : lists.head(splits);
2664                        var module = this.modules[moduleName || 'editor'];
2665
2666                        if (!moduleName && this[methodName]) {
2667                            return this[methodName].apply(this, args);
2668                        } else if (module && module[methodName] && module.shouldInitialize()) {
2669                            return module[methodName].apply(module, args