https://pawtul.com/static/vendor/summernote/summernote-lite.js

1/*!
2 * 
3 * Super simple wysiwyg editor v0.8.18
4 * https://summernote.org
5 * 
6 * 
7 * Copyright 2013- Alan Hong. and other contributors
8 * summernote may be freely distributed under the MIT license.
9 * 
10 * Date: 2020-05-20T18:09Z
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})(window, function(__WEBPACK_EXTERNAL_MODULE__0__) {
23return /******/ (function(modules) { // webpackBootstrap
24/******/ 	// The module cache
25/******/ 	var installedModules = {};
26/******/
27/******/ 	// The require function
28/******/ 	function __webpack_require__(moduleId) {
29/******/
30/******/ 		// Check if module is in cache
31/******/ 		if(installedModules[moduleId]) {
32/******/ 			return installedModules[moduleId].exports;
33/******/ 		}
34/******/ 		// Create a new module (and put it into the cache)
35/******/ 		var module = installedModules[moduleId] = {
36/******/ 			i: moduleId,
37/******/ 			l: false,
38/******/ 			exports: {}
39/******/ 		};
40/******/
41/******/ 		// Execute the module function
42/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
43/******/
44/******/ 		// Flag the module as loaded
45/******/ 		module.l = true;
46/******/
47/******/ 		// Return the exports of the module
48/******/ 		return module.exports;
49/******/ 	}
50/******/
51/******/
52/******/ 	// expose the modules object (__webpack_modules__)
53/******/ 	__webpack_require__.m = modules;
54/******/
55/******/ 	// expose the module cache
56/******/ 	__webpack_require__.c = installedModules;
57/******/
58/******/ 	// define getter function for harmony exports
59/******/ 	__webpack_require__.d = function(exports, name, getter) {
60/******/ 		if(!__webpack_require__.o(exports, name)) {
61/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
62/******/ 		}
63/******/ 	};
64/******/
65/******/ 	// define __esModule on exports
66/******/ 	__webpack_require__.r = function(exports) {
67/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
68/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
69/******/ 		}
70/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
71/******/ 	};
72/******/
73/******/ 	// create a fake namespace object
74/******/ 	// mode & 1: value is a module id, require it
75/******/ 	// mode & 2: merge all properties of value into the ns
76/******/ 	// mode & 4: return value when already ns object
77/******/ 	// mode & 8|1: behave like require
78/******/ 	__webpack_require__.t = function(value, mode) {
79/******/ 		if(mode & 1) value = __webpack_require__(value);
80/******/ 		if(mode & 8) return value;
81/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
82/******/ 		var ns = Object.create(null);
83/******/ 		__webpack_require__.r(ns);
84/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
85/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
86/******/ 		return ns;
87/******/ 	};
88/******/
89/******/ 	// getDefaultExport function for compatibility with non-harmony modules
90/******/ 	__webpack_require__.n = function(module) {
91/******/ 		var getter = module && module.__esModule ?
92/******/ 			function getDefault() { return module['default']; } :
93/******/ 			function getModuleExports() { return module; };
94/******/ 		__webpack_require__.d(getter, 'a', getter);
95/******/ 		return getter;
96/******/ 	};
97/******/
98/******/ 	// Object.prototype.hasOwnProperty.call
99/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
100/******/
101/******/ 	// __webpack_public_path__
102/******/ 	__webpack_require__.p = "";
103/******/
104/******/
105/******/ 	// Load entry module and return exports
106/******/ 	return __webpack_require__(__webpack_require__.s = 51);
107/******/ })
108/************************************************************************/
109/******/ ({
110
111/***/ 0:

325      outdent: 'Outdent',
326      indent: 'Indent',
327      left: 'Align left',
328      center: 'Align center',
329      right: 'Align right',
330      justify: 'Justify full'
331    },
332    color: {
333      recent: 'Recent Color',
334      more: 'More Color',
335      background: 'Background Color',
336      foreground: 'Text Color',
337      transparent: 'Transparent',
338      setTransparent: 'Set transparent',
339      reset: 'Reset',
340      resetToDefault: 'Reset to default',
341      cpSelect: 'Select'
342    },
343    shortcut: {
344      shortcuts: 'Keyboard shortcuts',
345      close: 'Close',
346      textFormatting: 'Text formatting',
347      action: 'Action',
348      paragraphFormatting: 'Paragraph formatting',
349      documentStyle: 'Document Style',
350      extraKeys: 'Extra keys'
351    },
352    help: {
353      'escape': 'Escape',
354      'insertParagraph': 'Insert Paragraph',
355      'undo': 'Undo the last command',
356      'redo': 'Redo the last command',
357      'tab': 'Tab',
358      'untab': 'Untab',
359      'bold': 'Set a bold style',
360      'italic': 'Set a italic style',
361      'underline': 'Set a underline style',
362      'strikethrough': 'Set a strikethrough style',
363      'removeFormat': 'Clean a style',
364      'justifyLeft': 'Set left align',
365      'justifyCenter': 'Set center align',
366      'justifyRight': 'Set right align',
367      'justifyFull': 'Set full align',
368      'insertUnorderedList': 'Toggle unordered list',
369      'insertOrderedList': 'Toggle ordered list',
370      'outdent': 'Outdent on current paragraph',
371      'indent': 'Indent on current paragraph',
372      'formatPara': 'Change current block\'s format as a paragraph(P tag)',
373      'formatH1': 'Change current block\'s format as H1',
374      'formatH2': 'Change current block\'s format as H2',
375      'formatH3': 'Change current block\'s format as H3',
376      'formatH4': 'Change current block\'s format as H4',
377      'formatH5': 'Change current block\'s format as H5',
378      'formatH6': 'Change current block\'s format as H6',
379      'insertHorizontalRule': 'Insert horizontal rule',
380      'linkDialog.show': 'Show Link Dialog'
381    },
382    history: {
383      undo: 'Undo',
384      redo: 'Redo'
385    },
386    specialChar: {
387      specialChar: 'SPECIAL CHARACTERS',
388      select: 'Select Special characters'
389    },
390    output: {
391      noSelection: 'No Selection Made!'
392    }
393  }
394});
395// CONCATENATED MODULE: ./src/js/base/core/env.js
396
397var isSupportAmd = typeof define === 'function' && __webpack_require__(2); // eslint-disable-line
398
399/**
400 * returns whether font is installed or not.
401 *
402 * @param {String} fontName
403 * @return {Boolean}
404 */
405
406var genericFontFamilies = ['sans-serif', 'serif', 'monospace', 'cursive', 'fantasy'];
407
408function validFontName(fontName) {
409  return external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.inArray(fontName.toLowerCase(), genericFontFamilies) === -1 ? "'".concat(fontName, "'") : fontName;
410}
411
412function env_isFontInstalled(fontName) {
413  var testFontName = fontName === 'Comic Sans MS' ? 'Courier New' : 'Comic Sans MS';
414  var testText = 'mmmmmmmmmmwwwww';
415  var testSize = '200px';
416  var canvas = document.createElement('canvas');
417  var context = canvas.getContext('2d');
418  context.font = testSize + " '" + testFontName + "'";
419  var originalWidth = context.measureText(testText).width;
420  context.font = testSize + ' ' + validFontName(fontName) + ', "' + testFontName + '"';
421  var width = context.measureText(testText).width;
422  return originalWidth !== width;
423}
424
425var userAgent = navigator.userAgent;
426var isMSIE = /MSIE|Trident/i.test(userAgent);
427var browserVersion;
428
429if (isMSIE) {
430  var matches = /MSIE (\d+[.]\d+)/.exec(userAgent);
431
432  if (matches) {
433    browserVersion = parseFloat(matches[1]);
434  }
435
436  matches = /Trident\/.*rv:([0-9]{1,}[.0-9]{0,})/.exec(userAgent);
437
438  if (matches) {
439    browserVersion = parseFloat(matches[1]);
440  }
441}
442
443var isEdge = /Edge\/\d+/.test(userAgent);
444var isSupportTouch = 'ontouchstart' in window || navigator.MaxTouchPoints > 0 || navigator.msMaxTouchPoints > 0; // [workaround] IE doesn't have input events for contentEditable
445// - see: https://goo.gl/4bfIvA
446
447var inputEventName = isMSIE ? 'DOMCharacterDataModified DOMSubtreeModified DOMNodeInserted' : 'input';
448/**
449 * @class core.env
450 *
451 * Object which check platform and agent
452 *
453 * @singleton
454 * @alternateClassName env
455 */
456
457/* harmony default export */ var env = ({
458  isMac: navigator.appVersion.indexOf('Mac') > -1,
459  isMSIE: isMSIE,
460  isEdge: isEdge,
461  isFF: !isEdge && /firefox/i.test(userAgent),
462  isPhantom: /PhantomJS/i.test(userAgent),
463  isWebkit: !isEdge && /webkit/i.test(userAgent),
464  isChrome: !isEdge && /chrome/i.test(userAgent),
465  isSafari: !isEdge && /safari/i.test(userAgent) && !/chrome/i.test(userAgent),
466  browserVersion: browserVersion,
467  jqueryVersion: parseFloat(external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.fn.jquery),
468  isSupportAmd: isSupportAmd,

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

1528    offset = isSkipInnerOffset ? 0 : point.offset - 1;
1529  }
1530
1531  return {
1532    node: node,
1533    offset: offset
1534  };
1535}
1536/**
1537 * returns next boundaryPoint
1538 *
1539 * @param {BoundaryPoint} point
1540 * @param {Boolean} isSkipInnerOffset
1541 * @return {BoundaryPoint}
1542 */
1543
1544
1545function dom_nextPoint(point, isSkipInnerOffset) {
1546  var node, offset;
1547
1548  if (nodeLength(point.node) === point.offset) {
1549    if (isEditable(point.node)) {
1550      return null;
1551    }
1552
1553    var nextTextNode = getNextTextNode(point.node);
1554
1555    if (nextTextNode) {
1556      node = nextTextNode;
1557      offset = 0;
1558    } else {
1559      node = point.node.parentNode;
1560      offset = dom_position(point.node) + 1;
1561    }
1562  } else if (hasChildren(point.node)) {
1563    node = point.node.childNodes[point.offset];
1564    offset = 0;
1565  } else {
1566    node = point.node;
1567    offset = isSkipInnerOffset ? nodeLength(point.node) : point.offset + 1;
1568  }
1569
1570  return {
1571    node: node,
1572    offset: offset
1573  };
1574}
1575/**
1576 * returns next boundaryPoint with empty node
1577 *
1578 * @param {BoundaryPoint} point
1579 * @param {Boolean} isSkipInnerOffset
1580 * @return {BoundaryPoint}
1581 */
1582
1583
1584function nextPointWithEmptyNode(point, isSkipInnerOffset) {
1585  var node, offset; // if node is empty string node, return current node's sibling.
1586
1587  if (dom_isEmpty(point.node)) {
1588    node = point.node.nextSibling;
1589    offset = 0;
1590    return {
1591      node: node,
1592      offset: offset
1593    };
1594  }
1595
1596  if (nodeLength(point.node) === point.offset) {
1597    if (isEditable(point.node)) {
1598      return null;
1599    }
1600
1601    var nextTextNode = getNextTextNode(point.node);
1602
1603    if (nextTextNode) {
1604      node = nextTextNode;
1605      offset = 0;
1606    } else {
1607      node = point.node.parentNode;
1608      offset = dom_position(point.node) + 1;
1609    } // if next node is editable, return current node's sibling node.
1610
1611
1612    if (isEditable(node)) {
1613      node = point.node.nextSibling;
1614      offset = 0;
1615    }
1616  } else if (hasChildren(point.node)) {
1617    node = point.node.childNodes[point.offset];
1618    offset = 0;
1619
1620    if (dom_isEmpty(node)) {
1621      return null;
1622    }
1623  } else {
1624    node = point.node;
1625    offset = isSkipInnerOffset ? nodeLength(point.node) : point.offset + 1;
1626
1627    if (dom_isEmpty(node)) {
1628      return null;
1629    }
1630  }
1631
1632  return {
1633    node: node,
1634    offset: offset
1635  };
1636}
1637/*
1638* returns the next Text node index or 0 if not found.
1639*/
1640
1641
1642function getNextTextNode(actual) {
1643  if (!actual.nextSibling) return undefined;
1644  if (actual.parent !== actual.nextSibling.parent) return undefined;
1645  if (isText(actual.nextSibling)) return actual.nextSibling;
1646  return getNextTextNode(actual.nextSibling);
1647}
1648/**
1649 * returns whether pointA and pointB is same or not.
1650 *
1651 * @param {BoundaryPoint} pointA
1652 * @param {BoundaryPoint} pointB
1653 * @return {Boolean}
1654 */
1655
1656
1657function isSamePoint(pointA, pointB) {
1658  return pointA.node === pointB.node && pointA.offset === pointB.offset;
1659}
1660/**
1661 * returns whether point is visible (can set cursor) or not.
1662 *
1663 * @param {BoundaryPoint} point
1664 * @return {Boolean}
1665 */
1666
1667
1668function isVisiblePoint(point) {
1669  if (isText(point.node) || !hasChildren(point.node) || dom_isEmpty(point.node)) {
1670    return true;
1671  }
1672
1673  var leftNode = point.node.childNodes[point.offset - 1];
1674  var rightNode = point.node.childNodes[point.offset];
1675
1676  if ((!leftNode || isVoid(leftNode)) && (!rightNode || isVoid(rightNode))) {
1677    return true;
1678  }
1679
1680  return false;
1681}
1682/**
1683 * @method prevPointUtil
1684 *
1685 * @param {BoundaryPoint} point
1686 * @param {Function} pred
1687 * @return {BoundaryPoint}
1688 */
1689
1690
1691function prevPointUntil(point, pred) {
1692  while (point) {
1693    if (pred(point)) {
1694      return point;
1695    }
1696
1697    point = dom_prevPoint(point);
1698  }
1699
1700  return null;
1701}
1702/**
1703 * @method nextPointUntil
1704 *
1705 * @param {BoundaryPoint} point
1706 * @param {Function} pred
1707 * @return {BoundaryPoint}
1708 */
1709
1710
1711function nextPointUntil(point, pred) {
1712  while (point) {
1713    if (pred(point)) {
1714      return point;
1715    }
1716
1717    point = dom_nextPoint(point);
1718  }
1719
1720  return null;
1721}
1722/**
1723 * returns whether point has character or not.
1724 *
1725 * @param {Point} point
1726 * @return {Boolean}
1727 */
1728
1729
1730function isCharPoint(point) {
1731  if (!isText(point.node)) {
1732    return false;
1733  }
1734
1735  var ch = point.node.nodeValue.charAt(point.offset - 1);
1736  return ch && ch !== ' ' && ch !== NBSP_CHAR;
1737}
1738/**
1739 * returns whether point has space or not.
1740 *
1741 * @param {Point} point
1742 * @return {Boolean}
1743 */
1744
1745
1746function isSpacePoint(point) {
1747  if (!isText(point.node)) {
1748    return false;
1749  }
1750
1751  var ch = point.node.nodeValue.charAt(point.offset - 1);
1752  return ch === ' ' || ch === NBSP_CHAR;
1753}
1754/**
1755 * @method walkPoint
1756 *
1757 * @param {BoundaryPoint} startPoint
1758 * @param {BoundaryPoint} endPoint
1759 * @param {Function} handler
1760 * @param {Boolean} isSkipInnerOffset
1761 */
1762
1763
1764function walkPoint(startPoint, endPoint, handler, isSkipInnerOffset) {
1765  var point = startPoint;
1766
1767  while (point) {
1768    handler(point);
1769
1770    if (isSamePoint(point, endPoint)) {
1771      break;
1772    }
1773
1774    var isSkipOffset = isSkipInnerOffset && startPoint.node !== point.node && endPoint.node !== point.node;

1775    point = nextPointWithEmptyNode(point, isSkipOffset);
1776  }
1777}
1778/**
1779 * @method makeOffsetPath
1780 *
1781 * return offsetPath(array of offset) from ancestor
1782 *
1783 * @param {Node} ancestor - ancestor node
1784 * @param {Node} node
1785 */
1786
1787
1788function makeOffsetPath(ancestor, node) {
1789  var ancestors = listAncestor(node, func.eq(ancestor));
1790  return ancestors.map(dom_position).reverse();
1791}
1792/**
1793 * @method fromOffsetPath
1794 *
1795 * return element from offsetPath(array of offset)
1796 *
1797 * @param {Node} ancestor - ancestor node
1798 * @param {array} offsets - offsetPath
1799 */
1800
1801
1802function fromOffsetPath(ancestor, offsets) {
1803  var current = ancestor;
1804
1805  for (var i = 0, len = offsets.length; i < len; i++) {
1806    if (current.childNodes.length <= offsets[i]) {
1807      current = current.childNodes[current.childNodes.length - 1];
1808    } else {
1809      current = current.childNodes[offsets[i]];
1810    }
1811  }
1812
1813  return current;
1814}
1815/**
1816 * @method splitNode
1817 *
1818 * split element or #text
1819 *
1820 * @param {BoundaryPoint} point
1821 * @param {Object} [options]
1822 * @param {Boolean} [options.isSkipPaddingBlankHTML] - default: false
1823 * @param {Boolean} [options.isNotSplitEdgePoint] - default: false
1824 * @param {Boolean} [options.isDiscardEmptySplits] - default: false
1825 * @return {Node} right node of boundaryPoint
1826 */
1827
1828
1829function splitNode(point, options) {
1830  var isSkipPaddingBlankHTML = options && options.isSkipPaddingBlankHTML;
1831  var isNotSplitEdgePoint = options && options.isNotSplitEdgePoint;
1832  var isDiscardEmptySplits = options && options.isDiscardEmptySplits;
1833
1834  if (isDiscardEmptySplits) {
1835    isSkipPaddingBlankHTML = true;
1836  } // edge case
1837
1838
1839  if (isEdgePoint(point) && (isText(point.node) || isNotSplitEdgePoint)) {
1840    if (isLeftEdgePoint(point)) {
1841      return point.node;

1842    } else if (isRightEdgePoint(point)) {
1843      return point.node.nextSibling;
1844    }
1845  } // split #text
1846
1847
1848  if (isText(point.node)) {
1849    return point.node.splitText(point.offset);
1850  } else {
1851    var childNode = point.node.childNodes[point.offset];
1852    var clone = insertAfter(point.node.cloneNode(false), point.node);
1853    appendChildNodes(clone, listNext(childNode));
1854
1855    if (!isSkipPaddingBlankHTML) {
1856      paddingBlankHTML(point.node);
1857      paddingBlankHTML(clone);
1858    }
1859
1860    if (isDiscardEmptySplits) {
1861      if (dom_isEmpty(point.node)) {
1862        remove(point.node);
1863      }
1864
1865      if (dom_isEmpty(clone)) {
1866        remove(clone);
1867        return point.node.nextSibling;
1868      }
1869    }
1870
1871    return clone;
1872  }
1873}
1874/**
1875 * @method splitTree
1876 *
1877 * split tree by point
1878 *
1879 * @param {Node} root - split root
1880 * @param {BoundaryPoint} point
1881 * @param {Object} [options]
1882 * @param {Boolean} [options.isSkipPaddingBlankHTML] - default: false
1883 * @param {Boolean} [options.isNotSplitEdgePoint] - default: false
1884 * @return {Node} right node of boundaryPoint
1885 */
1886
1887
1888function splitTree(root, point, options) {
1889  // ex) [#text, <span>, <p>]
1890  var ancestors = listAncestor(point.node, func.eq(root));
1891
1892  if (!ancestors.length) {
1893    return null;
1894  } else if (ancestors.length === 1) {
1895    return splitNode(point, options);
1896  }
1897
1898  return ancestors.reduce(function (node, parent) {
1899    if (node === point.node) {
1900      node = splitNode(point, options);
1901    }
1902
1903    return splitNode({
1904      node: parent,
1905      offset: node ? dom_position(node) : nodeLength(parent)
1906    }, options);
1907  });
1908}
1909/**
1910 * split point
1911 *
1912 * @param {Point} point
1913 * @param {Boolean} isInline
1914 * @return {Object}
1915 */
1916
1917
1918function splitPoint(point, isInline) {
1919  // find splitRoot, container
1920  //  - inline: splitRoot is a child of paragraph
1921  //  - block: splitRoot is a child of bodyContainer
1922  var pred = isInline ? isPara : isBodyContainer;
1923  var ancestors = listAncestor(point.node, pred);
1924  var topAncestor = lists.last(ancestors) || point.node;
1925  var splitRoot, container;
1926
1927  if (pred(topAncestor)) {
1928    splitRoot = ancestors[ancestors.length - 2];
1929    container = topAncestor;
1930  } else {
1931    splitRoot = topAncestor;
1932    container = splitRoot.parentNode;
1933  } // if splitRoot is exists, split with splitTree
1934
1935
1936  var pivot = splitRoot && splitTree(splitRoot, point, {
1937    isSkipPaddingBlankHTML: isInline,
1938    isNotSplitEdgePoint: isInline
1939  }); // if container is point.node, find pivot with point.offset
1940
1941  if (!pivot && container === point.node) {
1942    pivot = point.node.childNodes[point.offset];
1943  }
1944
1945  return {
1946    rightNode: pivot,
1947    container: container
1948  };
1949}
1950
1951function dom_create(nodeName) {
1952  return document.createElement(nodeName);
1953}
1954
1955function createText(text) {
1956  return document.createTextNode(text);
1957}
1958/**
1959 * @method remove
1960 *
1961 * remove node, (isRemoveChild: remove child or not)
1962 *
1963 * @param {Node} node
1964 * @param {Boolean} isRemoveChild
1965 */
1966
1967
1968function remove(node, isRemoveChild) {
1969  if (!node || !node.parentNode) {
1970    return;
1971  }
1972
1973  if (node.removeNode) {
1974    return node.removeNode(isRemoveChild);
1975  }
1976
1977  var parent = node.parentNode;
1978
1979  if (!isRemoveChild) {
1980    var nodes = [];
1981
1982    for (var i = 0, len = node.childNodes.length; i < len; i++) {
1983      nodes.push(node.childNodes[i]);
1984    }
1985
1986    for (var _i = 0, _len = nodes.length; _i < _len; _i++) {
1987      parent.insertBefore(nodes[_i], node);
1988    }
1989  }
1990
1991  parent.removeChild(node);
1992}
1993/**
1994 * @method removeWhile
1995 *
1996 * @param {Node} node
1997 * @param {Function} pred
1998 */
1999
2000
2001function removeWhile(node, pred) {
2002  while (node) {
2003    if (isEditable(node) || !pred(node)) {
2004      break;
2005    }
2006
2007    var parent = node.parentNode;
2008    remove(node);
2009    node = parent;
2010  }
2011}
2012/**
2013 * @method replace
2014 *
2015 * replace node with provided nodeName
2016 *
2017 * @param {Node} node
2018 * @param {String} nodeName
2019 * @return {Node} - new node
2020 */
2021
2022
2023function dom_replace(node, nodeName) {
2024  if (node.nodeName.toUpperCase() === nodeName.toUpperCase()) {
2025    return node;
2026  }
2027
2028  var newNode = dom_create(nodeName);
2029
2030  if (node.style.cssText) {
2031    newNode.style.cssText = node.style.cssText;
2032  }
2033
2034  appendChildNodes(newNode, lists.from(node.childNodes));
2035  insertAfter(newNode, node);
2036  remove(node);
2037  return newNode;
2038}
2039
2040var isTextarea = makePredByNodeName('TEXTAREA');
2041/**
2042 * @param {jQuery} $node
2043 * @param {Boolean} [stripLinebreaks] - default: false
2044 */
2045
2046function dom_value($node, stripLinebreaks) {
2047  var val = isTextarea($node[0]) ? $node.val() : $node.html();
2048
2049  if (stripLinebreaks) {
2050    return val.replace(/[\n\r]/g, '');
2051  }
2052
2053  return val;
2054}
2055/**
2056 * @method html
2057 *
2058 * get the HTML contents of node
2059 *
2060 * @param {jQuery} $node
2061 * @param {Boolean} [isNewlineOnBlock]
2062 */
2063
2064
2065function dom_html($node, isNewlineOnBlock) {
2066  var markup = dom_value($node);
2067
2068  if (isNewlineOnBlock) {
2069    var regexTag = /<(\/?)(\b(?!!)[^>\s]*)(.*?)(\s*\/?>)/g;
2070    markup = markup.replace(regexTag, function (match, endSlash, name) {
2071      name = name.toUpperCase();
2072      var isEndOfInlineContainer = /^DIV|^TD|^TH|^P|^LI|^H[1-7]/.test(name) && !!endSlash;
2073      var isBlockNode = /^BLOCKQUOTE|^TABLE|^TBODY|^TR|^HR|^UL|^OL/.test(name);
2074      return match + (isEndOfInlineContainer || isBlockNode ? '\n' : '');
2075    });
2076    markup = markup.trim();
2077  }
2078
2079  return markup;
2080}
2081
2082function posFromPlaceholder(placeholder) {
2083  var $placeholder = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(placeholder);
2084  var pos = $placeholder.offset();
2085  var height = $placeholder.outerHeight(true); // include margin
2086
2087  return {
2088    left: pos.left,
2089    top: pos.top + height
2090  };
2091}
2092
2093function attachEvents($node, events) {

2303.summernote.plugins || {}); // add and initialize modules
2304
2305      Object.keys(modules).forEach(function (key) {
2306        _this.module(key, modules[key], true);
2307      });
2308      Object.keys(this.modules).forEach(function (key) {
2309        _this.initializeModule(key);
2310      });
2311    }
2312  }, {
2313    key: "_destroy",
2314    value: function _destroy() {
2315      var _this2 = this;
2316
2317      // destroy modules with reversed order
2318      Object.keys(this.modules).reverse().forEach(function (key) {
2319        _this2.removeModule(key);
2320      });
2321      Object.keys(this.memos).forEach(function (key) {
2322        _this2.removeMemo(key);
2323      }); // trigger custom onDestroy callback
2324
2325      this.triggerEvent('destroy', this);
2326    }
2327  }, {
2328    key: "code",
2329    value: function code(html) {
2330      var isActivated = this.invoke('codeview.isActivated');
2331
2332      if (html === undefined) {
2333        this.invoke('codeview.sync');
2334        return isActivated ? this.layoutInfo.codable.val() : this.layoutInfo.editable.html();
2335      } else {
2336        if (isActivated) {
2337          this.invoke('codeview.sync', html);
2338        } else {
2339          this.layoutInfo.editable.html(html);
2340        }
2341
2342        this.$note.val(html);
2343        this.triggerEvent('change', html, this.layoutInfo.editable);
2344      }
2345    }
2346  }, {
2347    key: "isDisabled",
2348    value: function isDisabled() {
2349      return this.layoutInfo.editable.attr('contenteditable') === 'false';
2350    }
2351  }, {
2352    key: "enable",
2353    value: function enable() {
2354      this.layoutInfo.editable.attr('contenteditable', true);
2355      this.invoke('toolbar.activate', true);
2356      this.triggerEvent('disable', false);
2357      this.options.editing = true;
2358    }
2359  }, {
2360    key: "disable",
2361    value: function disable() {
2362      // close codeview if codeview is opend
2363      if (this.invoke('codeview.isActivated')) {
2364        this.invoke('codeview.deactivate');
2365      }
2366
2367      this.layoutInfo.editable.attr('contenteditable', false);
2368      this.options.editing = false;
2369      this.invoke('toolbar.deactivate', true);
2370      this.triggerEvent('disable', true);
2371    }
2372  }, {
2373    key: "triggerEvent",
2374    value: function triggerEvent() {
2375      var namespace = lists.head(arguments);
2376      var args = lists.tail(lists.from(arguments));
2377      var callback = this.options.callbacks[func.namespaceToCamel(namespace, 'on')];
2378
2379      if (callback) {
2380        callback.apply(this.$note[0], args);
2381      }
2382
2383      this.$note.trigger('summernote.' + namespace, args);
2384    }
2385  }, {
2386    key: "initializeModule",
2387    value: function initializeModule(key) {
2388      var module = this.modules[key];
2389      module.shouldInitialize = module.shouldInitialize || func.ok;
2390
2391      if (!module.shouldInitialize()) {
2392        return;
2393      } // initialize module
2394
2395
2396      if (module.initialize) {
2397        module.initialize();
2398      } // attach events
2399
2400
2401      if (module.events) {
2402        dom.attachEvents(this.$note, module.events);
2403      }
2404    }
2405  }, {
2406    key: "module",
2407    value: function module(key, ModuleClass, withoutIntialize) {
2408      if (arguments.length === 1) {
2409        return this.modules[key];
2410      }
2411
2412      this.modules[key] = new ModuleClass(this);
2413
2414      if (!withoutIntialize) {
2415        this.initializeModule(key);
2416      }
2417    }
2418  }, {
2419    key: "removeModule",
2420    value: function removeModule(key) {
2421      var module = this.modules[key];
2422
2423      if (module.shouldInitialize()) {
2424        if (module.events) {
2425          dom.detachEvents(this.$note, module.events);
2426        }
2427
2428        if (module.destroy) {
2429          module.destroy();
2430        }
2431      }
2432
2433      delete this.modules[key];
2434    }
2435  }, {
2436    key: "memo",
2437    value: function memo(key, obj) {
2438      if (arguments.length === 1) {
2439        return this.memos[key];
2440      }
2441
2442      this.memos[key] = obj;
2443    }
2444  }, {
2445    key: "removeMemo",
2446    value: function removeMemo(key) {
2447      if (this.memos[key] && this.memos[key].destroy) {
2448        this.memos[key].destroy();
2449      }
2450
2451      delete this.memos[key];
2452    }
2453    /**
2454     * Some buttons need to change their visual style immediately once they get pressed
2455     */
2456
2457  }, {
2458    key: "createInvokeHandlerAndUpdateState",
2459    value: function createInvokeHandlerAndUpdateState(namespace, value) {
2460      var _this3 = this;
2461
2462      return function (event) {
2463        _this3.createInvokeHandler(namespace, value)(event);
2464
2465        _this3.invoke('buttons.updateCurrentStyle');
2466      };
2467    }
2468  }, {
2469    key: "createInvokeHandler",
2470    value: function createInvokeHandler(namespace, value) {
2471      var _this4 = this;
2472
2473      return function (event) {
2474        event.preventDefault();
2475        var $target = external_

2539        return context.invoke.apply(context, lists.from(arguments));
2540      } else if (options.focus) {
2541        context.invoke('editor.focus');
2542      }
2543    }
2544
2545    return this;
2546  }
2547});
2548// CONCATENATED MODULE: ./src/js/base/core/range.js
2549function range_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
2550
2551function range_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
2552
2553function range_createClass(Constructor, protoProps, staticProps) { if (protoProps) range_defineProperties(Constructor.prototype, protoProps); if (staticProps) range_defineProperties(Constructor, staticProps); return Constructor; }
2554
2555
2556
2557
2558
2559
2560/**
2561 * return boundaryPoint from TextRange, inspired by Andy Na's HuskyRange.js
2562 *
2563 * @param {TextRange} textRange
2564 * @param {Boolean} isStart
2565 * @return {BoundaryPoint}
2566 *
2567 * @see http://msdn.microsoft.com/en-us/library/ie/ms535872(v=vs.85).aspx
2568 */
2569
2570function textRangeToPoint(textRange, isStart) {
2571  var container = textRange.parentElement();
2572  var offset;
2573  var tester = document.body.createTextRange();
2574  var prevContainer;
2575  var childNodes = lists.from(container.childNodes);
2576
2577  for (offset = 0; offset < childNodes.length; offset++) {
2578    if (dom.isText(childNodes[offset])) {
2579      continue;
2580    }
2581
2582    tester.moveToElementText(childNodes[offset]);
2583
2584    if (tester.compareEndPoints('StartToStart', textRange) >= 0) {
2585      break;
2586    }
2587
2588    prevContainer = childNodes[offset];
2589  }
2590
2591  if (offset !== 0 && dom.isText(childNodes[offset - 1])) {
2592    var textRangeStart = document.body.createTextRange();
2593    var curTextNode = null;
2594    textRangeStart.moveToElementText(prevContainer || container);
2595    textRangeStart.collapse(!prevContainer);
2596    curTextNode = prevContainer ? prevContainer.nextSibling : container.firstChild;
2597    var pointTester = textRange.duplicate();
2598    pointTester.setEndPoint('StartToStart', textRangeStart);
2599    var textCount = pointTester.text.replace(/[\r\n]/g, '').length;
2600
2601    while (textCount > curTextNode.nodeValue.length && curTextNode.nextSibling) {
2602      textCount -= curTextNode.nodeValue.length;
2603      curTextNode = curTextNode.nextSibling;
2604    } // [workaround] enforce IE to re-reference curTextNode, hack
2605
2606
2607    var dummy = curTextNode.nodeValue; // eslint-disable-line
2608
2609    if (isStart && curTextNode.nextSibling && dom.isText(curTextNode.nextSibling) && textCount === curTextNode.nodeValue.length) {
2610      textCount -= curTextNode.nodeValue.length;
2611      curTextNode = curTextNode.nextSibling;
2612    }
2613
2614    container = curTextNode;
2615    offset = textCount;
2616  }
2617
2618  return {
2619    cont: container,
2620    offset: offset
2621  };
2622}
2623/**
2624 * return TextRange from boundary point (inspired by google closure-library)
2625 * @param {BoundaryPoint} point
2626 * @return {TextRange}
2627 */
2628
2629
2630function pointToTextRange(point) {
2631  var textRangeInfo = function textRangeInfo(container, offset) {
2632    var node, isCollapseToStart;
2633
2634    if (dom.isText(container)) {
2635      var prevTextNodes = dom.listPrev(container, func.not(dom.isText));
2636      var prevContainer = lists.last(prevTextNodes).previousSibling;
2637      node = prevContainer || container.parentNode;
2638      offset += lists.sum(lists.tail(prevTextNodes), dom.nodeLength);
2639      isCollapseToStart = !prevContainer;
2640    } else {
2641      node = container.childNodes[offset] || container;
2642
2643      if (dom.isText(node)) {
2644        return textRangeInfo(node, 0);
2645      }
2646
2647      offset = 0;
2648      isCollapseToStart = false;
2649    }
2650
2651    return {
2652      node: node,
2653      collapseToStart: isCollapseToStart,
2654      offset: offset
2655    };
2656  };
2657
2658  var textRange = document.body.createTextRange();
2659  var info = textRangeInfo(point.node, point.offset);
2660  textRange.moveToElementText(info.node);
2661  textRange.collapse(info.collapseToStart);
2662  textRange.moveStart('character', info.offset);
2663  return textRange;
2664}
2665/**
2666   * Wrapped Range
2667   *
2668   * @constructor
2669   * @param {Node} sc - start container
2670   * @param {Number} so - start offset
2671   * @param {Node} ec - end container
2672   * @param {Number} eo - end offset
2673   */
2674
2675
2676var range_WrappedRange = /*#__PURE__*/function () {
2677  function WrappedRange(sc, so, ec, eo) {
2678    range_classCallCheck(this, WrappedRange);
2679
2680    this.sc = sc;
2681    this.so = so;
2682    this.ec = ec;
2683    this.eo = eo; // isOnEditable: judge whether range is on editable or not
2684
2685    this.isOnEditable = this.makeIsOn(dom.isEditable); // isOnList: judge whether range is on list node or not
2686
2687    this.isOnList = this.makeIsOn(dom.isList); // isOnAnchor: judge whether range is on anchor node or not
2688
2689    this.isOnAnchor = this.makeIsOn(dom.isAnchor); // isOnCell: judge whether range is on cell node or not
2690
2691    this.isOnCell = this.makeIsOn(dom.isCell); // isOnData: judge whether range is on data node or not
2692
2693    this.isOnData = this.makeIsOn(dom.isData);
2694  } // nativeRange: get nativeRange from sc, so, ec, eo
2695
2696
2697  range_createClass(WrappedRange, [{
2698    key: "nativeRange",
2699    value: function nativeRange() {
2700      if (env.isW3CRangeSupport) {
2701        var w3cRange = document.createRange();
2702        w3cRange.setStart(this.sc, this.so);
2703        w3cRange.setEnd(this.ec, this.eo);
2704        return w3cRange;
2705      } else {
2706        var textRange = pointToTextRange({
2707          node: this.sc,
2708          offset: this.so
2709        });
2710        textRange.setEndPoint('EndToEnd', pointToTextRange({
2711          node: this.ec,
2712          offset: this.eo
2713        }));
2714        return textRange;
2715      }
2716    }
2717  }, {
2718    key: "getPoints",
2719    value: function getPoints() {
2720      return {
2721        sc: this.sc,
2722        so: this.so,
2723        ec: this.ec,
2724        eo: this.eo
2725      };
2726    }
2727  }, {
2728    key: "getStartPoint",
2729    value: function getStartPoint() {
2730      return {
2731        node: this.sc,
2732        offset: this.so
2733      };
2734    }
2735  }, {
2736    key: "getEndPoint",
2737    value: function getEndPoint() {
2738      return {
2739        node: this.ec,
2740        offset: this.eo
2741      };
2742    }
2743    /**
2744     * select update visible range
2745     */
2746
2747  }, {
2748    key: "select",
2749    value: function select() {
2750      var nativeRng = this.nativeRange();
2751
2752      if (env.isW3CRangeSupport) {
2753        var selection = document.getSelection();
2754
2755        if (selection.rangeCount > 0) {
2756          selection.removeAllRanges();
2757        }
2758
2759        selection.addRange(nativeRng);
2760      } else {
2761        nativeRng.select();
2762      }
2763
2764      return this;
2765    }
2766    /**
2767     * Moves the scrollbar to start container(sc) of current range
2768     *
2769     * @return {WrappedRange}
2770     */
2771
2772  }, {
2773    key: "scrollIntoView",
2774    value: function scrollIntoView(container) {
2775      var height = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jq