https://www.annuaire-sdis.fr/vendor/summernote/summernote-bs4.js

295}
296function not(f) {
297    return function () {
298        return !f.apply(f, arguments);
299    };
300}
301function and(fA, fB) {
302    return function (item) {
303        return fA(item) && fB(item);
304    };
305}
306function self(a) {
307    return a;
308}
309function invoke(obj, method) {
310    return function () {
311        return obj[method].apply(obj, arguments);
312    };
313}
314var idCounter = 0;
315/**
316 * generate a globally-unique id
317 *
318 * @param {String} [prefix]
319 */
320function uniqueId(prefix) {
321    var id = ++idCounter + '';
322    return prefix ? prefix + id : id;
323}
324/**
325 * returns bnd (bounds) from rect
326 *
327 * - IE Compatibility Issue: http://goo.gl/sRLOAo
328 * - Scroll Issue: http://goo.gl/sNjUc
329 *
330 * @param {Rect} rect
331 * @return {Object} bounds
332 * @return {Number} bounds.top
333 * @return {Number} bounds.left
334 * @return {Number} bounds.width
335 * @return {Number} bounds.height
336 */
337function rect2bnd(rect) {
338    var $document = $(document);
339    return {
340        top: rect.top + $document.scrollTop(),
341        left: rect.left + $document.scrollLeft(),
342        width: rect.right - rect.left,
343        height: rect.bottom - rect.top
344    };
345}
346/**
347 * returns a copy of the object where the keys have become the values and the values the keys.
348 * @param {Object} obj
349 * @return {Object}
350 */
351function invertObject(obj) {
352    var inverted = {};
353    for (var key in obj) {
354        if (obj.hasOwnProperty(key)) {
355            inverted[obj[key]] = key;
356        }
357    }
358    return inverted;
359}
360/**
361 * @param {String} namespace
362 * @param {String} [prefix]
363 * @return {String}
364 */
365function namespaceToCamel(namespace, prefix) {
366    prefix = prefix || '';
367    return prefix + namespace.split('.').map(function (name) {
368        return name.substring(0, 1).toUpperCase() + name.substring(1);
369    }).join('');
370}
371/**
372 * Returns a function, that, as long as it continues to be invoked, will not
373 * be triggered. The function will be called after it stops being called for
374 * N milliseconds. If `immediate` is passed, trigger the function on the
375 * leading edge, instead of the trailing.
376 * @param {Function} func
377 * @param {Number} wait
378 * @param {Boolean} immediate
379 * @return {Function}
380 */
381function debounce(func, wait, immediate) {
382    var _this = this;
383    var timeout;
384    return function () {
385        var context = _this;
386        var args = arguments;
387        var later = function () {
388            timeout = null;
389            if (!immediate) {
390                func.apply(context, args);
391            }
392        };
393        var callNow = immediate && !timeout;
394        clearTimeout(timeout);
395        timeout = setTimeout(later, wait);
396        if (callNow) {
397            func.apply(context, args);
398        }
399    };
400}
401var func = {
402    eq: eq,
403    eq2: eq2,
404    peq2: peq2,
405    ok: ok,
406    fail: fail,
407    self: self,
408    not: not,
409    and: and,
410    invoke: invoke,
411    uniqueId: uniqueId,
412    rect2bnd: rect2bnd,
413    invertObject: invertObject,
414    namespaceToCamel: namespaceToCamel,
415    debounce: debounce
416};
417
418/**
419 * returns the first item of an array.
420 *
421 * @param {Array} array
422 */
423function head(array) {
424    return array[0];
425}
426/**
427 * returns the last item of an array.
428 *
429 * @param {Array} array
430 */
431function last(array) {
432    return array[array.length - 1];
433}
434/**
435 * returns everything but the last entry of the array.
436 *
437 * @param {Array} array
438 */
439function initial(array) {
440    return array.slice(0, array.length - 1);
441}
442/**
443 * returns the rest of the items in an array.
444 *
445 * @param {Array} array
446 */
447function tail(array) {
448    return array.slice(1);
449}
450/**
451 * returns item of array
452 */
453function find(array, pred) {
454    for (var idx = 0, len = array.length; idx < len; idx++) {
455        var item = array[idx];
456        if (pred(item)) {
457            return item;
458        }
459    }
460}
461/**
462 * returns true if all of the values in the array pass the predicate truth test.
463 */
464function all(array, pred) {
465    for (var idx = 0, len = array.length; idx < len; idx++) {
466        if (!pred(array[idx])) {
467            return false;
468        }
469    }
470    return true;
471}
472/**
473 * returns index of item
474 */
475function indexOf(array, item) {
476    return $$1.inArray(item, array);
477}
478/**
479 * returns true if the value is present in the list.
480 */
481function contains(array, item) {
482    return indexOf(array, item) !== -1;
483}
484/**
485 * get sum from a list
486 *
487 * @param {Array} array - array
488 * @param {Function} fn - iterator
489 */
490function sum(array, fn) {
491    fn = fn || func.self;
492    return array.reduce(function (memo, v) {
493        return memo + fn(v);
494    }, 0);
495}
496/**
497 * returns a copy of the collection with array type.
498 * @param {Collection} collection - collection eg) node.childNodes, ...
499 */
500function from(collection) {
501    var result = [];
502    var length = collection.length;
503    var idx = -1;
504    while (++idx < length) {
505        result[idx] = collection[idx];
506    }
507    return result;
508}
509/**
510 * returns whether list is empty or not
511 */
512function isEmpty$1(array) {
513    return !array || !array.length;
514}
515/**
516 * cluster elements by predicate function.
517 *
518 * @param {Array} array - array
519 * @param {Function} fn - predicate function for cluster rule
520 * @param {Array[]}
521 */
522function clusterBy(array, fn) {
523    if (!array.length) {
524        return [];
525    }
526    var aTail = tail(array);
527    return aTail.reduce(function (memo, v) {
528        var aLast = last(memo);
529        if (fn(last(aLast), v)) {
530            aLast[aLast.length] = v;
531        }
532        else {
533            memo[memo.length] = [v];
534        }
535        return memo;
536    }, [[head(array)]]);
537}
538/**
539 * returns a copy of the array with all false values removed
540 *
541 * @param {Array} array - array
542 * @param {Function} fn - predicate function for cluster rule
543 */
544function compact(array) {
545    var aResult = [];
546    for (var idx = 0, len = array.length; idx < len; idx++) {
547        if (array[idx]) {
548            aResult.push(array[idx]);
549        }
550    }
551    return aResult;
552}
553/**
554 * produces a duplicate-free version of the array
555 *
556 * @param {Array} array
557 */
558function unique(array) {
559    var results = [];
560    for (var idx = 0, len = array.length; idx < len; idx++) {
561        if (!contains(results, array[idx])) {
562            results.push(array[idx]);
563        }
564    }
565    return results;
566}
567/**
568 * returns next item.
569 * @param {Array} array
570 */
571function next(array, item) {
572    var idx = indexOf(array, item);
573    if (idx === -1) {
574        return null;
575    }
576    return array[idx + 1];
577}
578/**
579 * returns prev item.
580 * @param {Array} array
581 */
582function prev(array, item) {
583    var idx = indexOf(array, item);
584    if (idx === -1) {
585        return null;
586    }
587    return array[idx - 1];
588}
589/**
590 * @class core.list
591 *
592 * list utils
593 *
594 * @singleton
595 * @alternateClassName list
596 */
597var lists = {
598    head: head,
599    last: last,
600    initial: initial,
601    tail: tail,
602    prev: prev,
603    next: next,
604    find: find,
605    contains: contains,
606    all: all,
607    sum: sum,
608    from: from,
609    isEmpty: isEmpty$1,
610    clusterBy: clusterBy,
611    compact: compact,
612    unique: unique
613};
614
615var isSupportAmd = typeof define === 'function' && define.amd; // eslint-disable-line
616/**
617 * returns whether font is installed or not.
618 *
619 * @param {String} fontName
620 * @return {Boolean}
621 */
622function isFontInstalled(fontName) {
623    var testFontName = fontName === 'Comic Sans MS' ? 'Courier New' : 'Comic Sans MS';
624    var $tester = $$1('<div>').css({
625        position: 'absolute',
626        left: '-9999px',
627        top: '-9999px',
628        fontSize: '200px'
629    }).text('mmmmmmmmmwwwwwww').appendTo(document.body);
630    var originalWidth = $tester.css('fontFamily', testFontName).width();
631    var width = $tester.css('fontFamily', fontName + ',' + testFontName).width();
632    $tester.remove();
633    return originalWidth !== width;
634}
635var userAgent = navigator.userAgent;
636var isMSIE = /MSIE|Trident/i.test(userAgent);
637var browserVersion;
638if (isMSIE) {
639    var matches = /MSIE (\d+[.]\d+)/.exec(userAgent);
640    if (matches) {
641        browserVersion = parseFloat(matches[1]);
642    }
643    matches = /Trident\/.*rv:([0-9]{1,}[.0-9]{0,})/.exec(userAgent);
644    if (matches) {
645        browserVersion = parseFloat(matches[1]);
646    }
647}
648var isEdge = /Edge\/\d+/.test(userAgent);
649var hasCodeMirror = !!window.CodeMirror;
650if (!hasCodeMirror && isSupportAmd) {
651    // Webpack
652    if (typeof __webpack_require__ === 'function') {
653        try {
654            // If CodeMirror can't be resolved, `require.resolve` will throw an
655            // exception and `hasCodeMirror` won't be set to `true`.

656            require.resolve('codemirror');
657            hasCodeMirror = true;
658        }
659        catch (e) {
660            // do nothing
661        }
662    }
663    else if (typeof require !== 'undefined') {
664        // Browserify
665        if (typeof require.resolve !== 'undefined') {
666            try {
667                // If CodeMirror can't be resolved, `require.resolve` will throw an
668                // exception and `hasCodeMirror` won't be set to `true`.
669                require.resolve('codemirror');
670                hasCodeMirror = true;
671            }
672            catch (e) {
673                // do nothing
674            }
675            // Almond/Require
676        }
677        else if (typeof require.specified !== 'undefined') {
678            hasCodeMirror = require.specified('codemirror');
679        }
680    }
681}
682var isSupportTouch = (('ontouchstart' in window) ||
683    (navigator.MaxTouchPoints > 0) ||
684    (navigator.msMaxTouchPoints > 0));
685// [workaround] IE doesn't have input events for contentEditable
686// - see: https://goo.gl/4bfIvA
687var inputEventName = (isMSIE || isEdge) ? 'DOMCharacterDataModified DOMSubtreeModified DOMNodeInserted' : 'input';
688/**
689 * @class core.env
690 *
691 * Object which check platform and agent
692 *
693 * @singleton
694 * @alternateClassName env
695 */
696var env = {
697    isMac: navigator.appVersion.indexOf('Mac') > -1,
698    isMSIE: isMSIE,
699    isEdge: isEdge,
700    isFF: !isEdge && /firefox/i.test(userAgent),
701    isPhantom: /PhantomJS/i.test(userAgent),
702    isWebkit: !isEdge && /webkit/i.test(userAgent),
703    isChrome: !isEdge && /chrome/i.test(userAgent),
704    isSafari: !isEdge && /safari/i.test(userAgent),
705    browserVersion: browserVersion,
706    jqueryVersion: parseFloat($$1.fn.jquery),
707    isSupportAmd: isSupportAmd,
708    isSupportTouch: isSupportTouch,
709    hasCodeMirror: hasCodeMirror,
710    isFontInstalled: isFontInstalled,
711    isW3CRangeSupport: !!document.createRange,
712    inputEventName: inputEventName
713};
714
715var NBSP_CHAR = String.fromCharCode(160);
716var ZERO_WIDTH_NBSP_CHAR = '\ufeff';
717/**
718 * @method isEditable
719 *
720 * returns whether node is `note-editable` or not.
721 *
722 * @param {Node} node
723 * @return {Boolean}
724 */
725function isEditable(node) {
726    return node && $$1(node).hasClass('note-editable');
727}
728/**
729 * @method isControlSizing
730 *
731 * returns whether node is `note-control-sizing` or not.
732 *
733 * @param {Node} node
734 * @return {Boolean}
735 */
736function isControlSizing(node) {
737    return node && $$1(node).hasClass('note-control-sizing');
738}
739/**
740 * @method makePredByNodeName
741 *
742 * returns predicate which judge whether nodeName is same
743 *
744 * @param {String} nodeName
745 * @return {Function}
746 */
747function makePredByNodeName(nodeName) {
748    nodeName = nodeName.toUpperCase();
749    return function (node) {
750        return node && node.nodeName.toUpperCase() === nodeName;
751    };
752}
753/**
754 * @method isText
755 *
756 *
757 *
758 * @param {Node} node
759 * @return {Boolean} true if node's type is text(3)
760 */
761function isText(node) {
762    return node && node.nodeType === 3;
763}
764/**
765 * @method isElement
766 *
767 *
768 *
769 * @param {Node} node
770 * @return {Boolean} true if node's type is element(1)
771 */
772function isElement(node) {
773    return node && node.nodeType === 1;
774}
775/**
776 * ex) br, col, embed, hr, img, input, ...
777 * @see http://www.w3.org/html/wg/drafts/html/master/syntax.html#void-elements
778 */
779function isVoid(node) {
780    return node && /^BR|^IMG|^HR|^IFRAME|^BUTTON|^INPUT/.test(node.nodeName.toUpperCase());
781}
782function isPara(node) {
783    if (isEditable(node)) {
784        return false;
785    }
786    // Chrome(v31.0), FF(v25.0.1) use DIV for paragraph
787    return node && /^DIV|^P|^LI|^H[1-7]/.test(node.nodeName.toUpperCase());
788}
789function isHeading(node) {
790    return node && /^H[1-7]/.test(node.nodeName.toUpperCase());
791}
792var isPre = makePredByNodeName('PRE');
793var isLi = makePredByNodeName('LI');
794function isPurePara(node) {
795    return isPara(node) && !isLi(node);
796}
797var isTable = makePredByNodeName('TABLE');
798var isData = makePredByNodeName('DATA');
799function isInline(node) {
800    return !isBodyContainer(node) &&
801        !isList(node) &&
802        !isHr(node) &&
803        !isPara(node) &&
804        !isTable(node) &&
805        !isBlockquote(node) &&
806        !isData(node);
807}
808function isList(node) {
809    return node && /^UL|^OL/.test(node.nodeName.toUpperCase());
810}
811var isHr = makePredByNodeName('HR');
812function isCell(node) {
813    return node && /^TD|^TH/.test(node.nodeName.toUpperCase());
814}
815var isBlockquote = makePredByNodeName('BLOCKQUOTE');
816function isBodyContainer(node) {
817    return isCell(node) || isBlockquote(node) || isEditable(node);
818}
819var isAnchor = makePredByNodeName('A');
820function isParaInline(node) {
821    return isInline(node) && !!ancestor(node, isPara);
822}
823function isBodyInline(node) {
824    return isInline(node) && !ancestor(node, isPara);
825}
826var isBody = makePredByNodeName('BODY');
827/**
828 * returns whether nodeB is closest sibling of nodeA
829 *
830 * @param {Node} nodeA
831 * @param {Node} nodeB
832 * @return {Boolean}
833 */
834function isClosestSibling(nodeA, nodeB) {
835    return nodeA.nextSibling === nodeB ||
836        nodeA.previousSibling === nodeB;
837}
838/**
839 * returns array of closest siblings with node
840 *
841 * @param {Node} node
842 * @param {function} [pred] - predicate function
843 * @return {Node[]}
844 */
845function withClosestSiblings(node, pred) {
846    pred = pred || func.ok;
847    var siblings = [];
848    if (node.previousSibling && pred(node.previousSibling)) {
849        siblings.push(node.previousSibling);
850    }
851    siblings.push(node);
852    if (node.nextSibling && pred(node.nextSibling)) {
853        siblings.push(node.nextSibling);
854    }
855    return siblings;
856}
857/**
858 * blank HTML for cursor position
859 * - [workaround] old IE only works with  
860 * - [workaround] IE11 and other browser works with bogus br
861 */
862var blankHTML = env.isMSIE && env.browserVersion < 11 ? '&nbsp;' : '<br>';
863/**
864 * @method nodeLength
865 *
866 * returns #text's text size or element's childNodes size
867 *
868 * @param {Node} node
869 */
870function nodeLength(node) {
871    if (isText(node)) {
872        return node.nodeValue.length;
873    }
874    if (node) {
875        return node.childNodes.length;
876    }
877    return 0;
878}
879/**
880 * returns whether node is empty or not.
881 *
882 * @param {Node} node
883 * @return {Boolean}
884 */
885function isEmpty(node) {
886    var len = nodeLength(node);
887    if (len === 0) {
888        return true;
889    }
890    else if (!isText(node) && len === 1 && node.innerHTML === blankHTML) {
891        // ex) <p><br></p>, <span><br></span>
892        return true;
893    }
894    else if (lists.all(node.childNodes, isText) && node.innerHTML === '') {
895        // ex) <p></p>, <span></span>
896        return true;
897    }
898    return false;
899}
900/**
901 * padding blankHTML if node is empty (for cursor position)
902 */
903function paddingBlankHTML(node) {
904    if (!isVoid(node) && !nodeLength(node)) {
905        node.innerHTML = blankHTML;
906    }
907}
908/**
909 * find nearest ancestor predicate hit
910 *
911 * @param {Node} node
912 * @param {Function} pred - predicate function
913 */
914function ancestor(node, pred) {
915    while (node) {
916        if (pred(node)) {
917            return node;
918        }
919        if (isEditable(node)) {
920            break;
921        }
922        node = node.parentNode;
923    }
924    return null;
925}
926/**
927 * find nearest ancestor only single child blood line and predicate hit
928 *
929 * @param {Node} node
930 * @param {Function} pred - predicate function
931 */
932function singleChildAncestor(node, pred) {
933    node = node.parentNode;
934    while (node) {
935        if (nodeLength(node) !== 1) {
936            break;
937        }
938        if (pred(node)) {
939            return node;
940        }
941        if (isEditable(node)) {
942            break;
943        }
944        node = node.parentNode;
945    }
946    return null;
947}
948/**
949 * returns new array of ancestor nodes (until predicate hit).
950 *
951 * @param {Node} node
952 * @param {Function} [optional] pred - predicate function
953 */
954function listAncestor(node, pred) {
955    pred = pred || func.fail;
956    var ancestors = [];
957    ancestor(node, function (el) {
958        if (!isEditable(el)) {
959            ancestors.push(el);
960        }
961        return pred(el);
962    });
963    return ancestors;
964}
965/**
966 * find farthest ancestor predicate hit
967 */
968function lastAncestor(node, pred) {
969    var ancestors = listAncestor(node);
970    return lists.last(ancestors.filter(pred));
971}
972/**
973 * returns common ancestor node between two nodes.
974 *
975 * @param {Node} nodeA
976 * @param {Node} nodeB
977 */
978function commonAncestor(nodeA, nodeB) {
979    var ancestors = listAncestor(nodeA);
980    for (var n = nodeB; n; n = n.parentNode) {
981        if ($$1.inArray(n, ancestors) > -1) {
982            return n;
983        }
984    }
985    return null; // difference document area
986}
987/**
988 * listing all previous siblings (until predicate hit).
989 *
990 * @param {Node} node
991 * @param {Function} [optional] pred - predicate function
992 */
993function listPrev(node, pred) {
994    pred = pred || func.fail;
995    var nodes = [];
996    while (node) {
997        if (pred(node)) {
998            break;
999        }
1000        nodes.push(node);
1001        node = node.previousSibling;
1002    }
1003    return nodes;
1004}
1005/**
1006 * listing next siblings (until predicate hit).
1007 *
1008 * @param {Node} node
1009 * @param {Function} [pred] - predicate function
1010 */
1011function listNext(node, pred) {
1012    pred = pred || func.fail;
1013    var nodes = [];
1014    while (node) {
1015        if (pred(node)) {
1016            break;
1017        }
1018        nodes.push(node);
1019        node = node.nextSibling;
1020    }
1021    return nodes;
1022}
1023/**
1024 * listing descendant nodes
1025 *
1026 * @param {Node} node
1027 * @param {Function} [pred] - predicate function
1028 */
1029function listDescendant(node, pred) {
1030    var descendants = [];
1031    pred = pred || func.ok;
1032    // start DFS(depth first search) with node
1033    (function fnWalk(current) {
1034        if (node !== current && pred(current)) {
1035            descendants.push(current);
1036        }
1037        for (var idx = 0, len = current.childNodes.length; idx < len; idx++) {
1038            fnWalk(current.childNodes[idx]);
1039        }
1040    })(node);
1041    return descendants;
1042}
1043/**
1044 * wrap node with new tag.
1045 *
1046 * @param {Node} node
1047 * @param {Node} tagName of wrapper
1048 * @return {Node} - wrapper
1049 */
1050function wrap(node, wrapperName) {
1051    var parent = node.parentNode;
1052    var wrapper = $$1('<' + wrapperName + '>')[0];
1053    parent.insertBefore(wrapper, node);
1054    wrapper.appendChild(node);
1055    return wrapper;
1056}
1057/**
1058 * insert node after preceding
1059 *
1060 * @param {Node} node
1061 * @param {Node} preceding - predicate function
1062 */
1063function insertAfter(node, preceding) {
1064    var next = preceding.nextSibling;
1065    var parent = preceding.parentNode;
1066    if (next) {
1067        parent.insertBefore(node, next);
1068    }
1069    else {
1070        parent.appendChild(node);
1071    }
1072    return node;
1073}
1074/**
1075 * append elements.
1076 *
1077 * @param {Node} node
1078 * @param {Collection} aChild
1079 */
1080function appendChildNodes(node, aChild) {
1081    $$1.each(aChild, function (idx, child) {
1082        node.appendChild(child);
1083    });
1084    return node;
1085}
1086/**
1087 * returns whether boundaryPoint is left edge or not.
1088 *
1089 * @param {BoundaryPoint} point
1090 * @return {Boolean}
1091 */
1092function isLeftEdgePoint(point) {
1093    return point.offset === 0;
1094}
1095/**
1096 * returns whether boundaryPoint is right edge or not.
1097 *
1098 * @param {BoundaryPoint} point
1099 * @return {Boolean}
1100 */
1101function isRightEdgePoint(point) {
1102    return point.offset === nodeLength(point.node);
1103}
1104/**
1105 * returns whether boundaryPoint is edge or not.
1106 *
1107 * @param {BoundaryPoint} point
1108 * @return {Boolean}
1109 */
1110function isEdgePoint(point) {
1111    return isLeftEdgePoint(point) || isRightEdgePoint(point);
1112}
1113/**
1114 * returns whether node is left edge of ancestor or not.
1115 *
1116 * @param {Node} node
1117 * @param {Node} ancestor
1118 * @return {Boolean}
1119 */
1120function isLeftEdgeOf(node, ancestor) {
1121    while (node && node !== ancestor) {
1122        if (position(node) !== 0) {
1123            return false;
1124        }
1125        node = node.parentNode;
1126    }
1127    return true;
1128}
1129/**
1130 * returns whether node is right edge of ancestor or not.
1131 *
1132 * @param {Node} node
1133 * @param {Node} ancestor
1134 * @return {Boolean}
1135 */
1136function isRightEdgeOf(node, ancestor) {
1137    if (!ancestor) {
1138        return false;
1139    }
1140    while (node && node !== ancestor) {
1141        if (position(node) !== nodeLength(node.parentNode) - 1) {
1142            return false;
1143        }
1144        node = node.parentNode;
1145    }
1146    return true;
1147}
1148/**
1149 * returns whether point is left edge of ancestor or not.
1150 * @param {BoundaryPoint} point
1151 * @param {Node} ancestor
1152 * @return {Boolean}
1153 */
1154function isLeftEdgePointOf(point, ancestor) {
1155    return isLeftEdgePoint(point) && isLeftEdgeOf(point.node, ancestor);
1156}
1157/**
1158 * returns whether point is right edge of ancestor or not.
1159 * @param {BoundaryPoint} point
1160 * @param {Node} ancestor
1161 * @return {Boolean}
1162 */
1163function isRightEdgePointOf(point, ancestor) {
1164    return isRightEdgePoint(point) && isRightEdgeOf(point.node, ancestor);
1165}
1166/**
1167 * returns offset from parent.
1168 *
1169 * @param {Node} node
1170 */
1171function position(node) {
1172    var offset = 0;
1173    while ((node = node.previousSibling)) {
1174        offset += 1;
1175    }
1176    return offset;
1177}
1178function hasChildren(node) {
1179    return !!(node && node.childNodes && node.childNodes.length);
1180}
1181/**
1182 * returns previous boundaryPoint
1183 *
1184 * @param {BoundaryPoint} point
1185 * @param {Boolean} isSkipInnerOffset
1186 * @return {BoundaryPoint}
1187 */
1188function prevPoint(point, isSkipInnerOffset) {
1189    var node;
1190    var offset;
1191    if (point.offset === 0) {
1192        if (isEditable(point.node)) {
1193            return null;
1194        }
1195        node = point.node.parentNode;
1196        offset = position(point.node);
1197    }
1198    else if (hasChildren(point.node)) {
1199        node = point.node.childNodes[point.offset - 1];
1200        offset = nodeLength(node);
1201    }
1202    else {
1203        node = point.node;

1204        offset = isSkipInnerOffset ? 0 : point.offset - 1;
1205    }
1206    return {
1207        node: node,
1208        offset: offset
1209    };
1210}
1211/**
1212 * returns next boundaryPoint
1213 *
1214 * @param {BoundaryPoint} point
1215 * @param {Boolean} isSkipInnerOffset
1216 * @return {BoundaryPoint}
1217 */
1218function nextPoint(point, isSkipInnerOffset) {
1219    var node, offset;
1220    if (nodeLength(point.node) === point.offset) {
1221        if (isEditable(point.node)) {
1222            return null;
1223        }
1224        node = point.node.parentNode;
1225        offset = position(point.node) + 1;
1226    }
1227    else if (hasChildren(point.node)) {
1228        node = point.node.childNodes[point.offset];
1229        offset = 0;
1230    }
1231    else {
1232        node = point.node;
1233        offset = isSkipInnerOffset ? nodeLength(point.node) : point.offset + 1;
1234    }
1235    return {
1236        node: node,
1237        offset: offset
1238    };
1239}
1240/**
1241 * returns whether pointA and pointB is same or not.
1242 *
1243 * @param {BoundaryPoint} pointA
1244 * @param {BoundaryPoint} pointB
1245 * @return {Boolean}
1246 */
1247function isSamePoint(pointA, pointB) {
1248    return pointA.node === pointB.node && pointA.offset === pointB.offset;
1249}
1250/**
1251 * returns whether point is visible (can set cursor) or not.
1252 *
1253 * @param {BoundaryPoint} point
1254 * @return {Boolean}
1255 */
1256function isVisiblePoint(point) {
1257    if (isText(point.node) || !hasChildren(point.node) || isEmpty(point.node)) {
1258        return true;
1259    }
1260    var leftNode = point.node.childNodes[point.offset - 1];
1261    var rightNode = point.node.childNodes[point.offset];
1262    if ((!leftNode || isVoid(leftNode)) && (!rightNode || isVoid(rightNode))) {
1263        return true;
1264    }
1265    return false;
1266}
1267/**
1268 * @method prevPointUtil
1269 *
1270 * @param {BoundaryPoint} point
1271 * @param {Function} pred
1272 * @return {BoundaryPoint}
1273 */
1274function prevPointUntil(point, pred) {
1275    while (point) {
1276        if (pred(point)) {
1277            return point;
1278        }
1279        point = prevPoint(point);
1280    }
1281    return null;
1282}
1283/**
1284 * @method nextPointUntil
1285 *
1286 * @param {BoundaryPoint} point
1287 * @param {Function} pred
1288 * @return {BoundaryPoint}
1289 */
1290function nextPointUntil(point, pred) {
1291    while (point) {
1292        if (pred(point)) {
1293            return point;
1294        }
1295        point = nextPoint(point);
1296    }
1297    return null;
1298}
1299/**
1300 * returns whether point has character or not.
1301 *
1302 * @param {Point} point
1303 * @return {Boolean}
1304 */
1305function isCharPoint(point) {
1306    if (!isText(point.node)) {
1307        return false;
1308    }
1309    var ch = point.node.nodeValue.charAt(point.offset - 1);
1310    return ch && (ch !== ' ' && ch !== NBSP_CHAR);
1311}
1312/**
1313 * @method walkPoint
1314 *
1315 * @param {BoundaryPoint} startPoint
1316 * @param {BoundaryPoint} endPoint
1317 * @param {Function} handler
1318 * @param {Boolean} isSkipInnerOffset
1319 */
1320function walkPoint(startPoint, endPoint, handler, isSkipInnerOffset) {
1321    var point = startPoint;
1322    while (point) {
1323        handler(point);
1324        if (isSamePoint(point, endPoint)) {
1325            break;
1326        }
1327        var isSkipOffset = isSkipInnerOffset &&
1328            startPoint.node !== point.node &&
1329            endPoint.node !== point.node;

1383        }
1384        else if (isRightEdgePoint(point)) {
1385            return point.node.nextSibling;
1386        }
1387    }
1388    // split #text
1389    if (isText(point.node)) {
1390        return point.node.splitText(point.offset);
1391    }
1392    else {
1393        var childNode = point.node.childNodes[point.offset];
1394        var clone = insertAfter(point.node.cloneNode(false), point.node);
1395        appendChildNodes(clone, listNext(childNode));
1396        if (!isSkipPaddingBlankHTML) {
1397            paddingBlankHTML(point.node);
1398            paddingBlankHTML(clone);
1399        }
1400        return clone;
1401    }
1402}
1403/**
1404 * @method splitTree
1405 *
1406 * split tree by point
1407 *
1408 * @param {Node} root - split root
1409 * @param {BoundaryPoint} point
1410 * @param {Object} [options]
1411 * @param {Boolean} [options.isSkipPaddingBlankHTML] - default: false
1412 * @param {Boolean} [options.isNotSplitEdgePoint] - default: false
1413 * @return {Node} right node of boundaryPoint
1414 */
1415function splitTree(root, point, options) {
1416    // ex) [#text, <span>, <p>]
1417    var ancestors = listAncestor(point.node, func.eq(root));
1418    if (!ancestors.length) {
1419        return null;
1420    }
1421    else if (ancestors.length === 1) {
1422        return splitNode(point, options);
1423    }
1424    return ancestors.reduce(function (node, parent) {
1425        if (node === point.node) {
1426            node = splitNode(point, options);
1427        }
1428        return splitNode({
1429            node: parent,
1430            offset: node ? position(node) : nodeLength(parent)
1431        }, options);
1432    });
1433}
1434/**
1435 * split point
1436 *
1437 * @param {Point} point
1438 * @param {Boolean} isInline
1439 * @return {Object}
1440 */
1441function splitPoint(point, isInline) {
1442    // find splitRoot, container
1443    //  - inline: splitRoot is a child of paragraph
1444    //  - block: splitRoot is a child of bodyContainer
1445    var pred = isInline ? isPara : isBodyContainer;
1446    var ancestors = listAncestor(point.node, pred);
1447    var topAncestor = lists.last(ancestors) || point.node;
1448    var splitRoot, container;
1449    if (pred(topAncestor)) {
1450        splitRoot = ancestors[ancestors.length - 2];
1451        container = topAncestor;
1452    }
1453    else {
1454        splitRoot = topAncestor;
1455        container = splitRoot.parentNode;
1456    }
1457    // if splitRoot is exists, split with splitTree
1458    var pivot = splitRoot && splitTree(splitRoot, point, {
1459        isSkipPaddingBlankHTML: isInline,
1460        isNotSplitEdgePoint: isInline
1461    });
1462    // if container is point.node, find pivot with point.offset
1463    if (!pivot && container === point.node) {
1464        pivot = point.node.childNodes[point.offset];
1465    }
1466    return {
1467        rightNode: pivot,
1468        container: container
1469    };
1470}
1471function create(nodeName) {
1472    return document.createElement(nodeName);
1473}
1474function createText(text) {
1475    return document.createTextNode(text);
1476}
1477/**
1478 * @method remove
1479 *
1480 * remove node, (isRemoveChild: remove child or not)
1481 *
1482 * @param {Node} node
1483 * @param {Boolean} isRemoveChild
1484 */
1485function remove(node, isRemoveChild) {
1486    if (!node || !node.parentNode) {
1487        return;
1488    }
1489    if (node.removeNode) {
1490        return node.removeNode(isRemoveChild);
1491    }
1492    var parent = node.parentNode;
1493    if (!isRemoveChild) {
1494        var nodes = [];
1495        for (var i = 0, len = node.childNodes.length; i < len; i++) {
1496            nodes.push(node.childNodes[i]);
1497        }
1498        for (var i = 0, len = nodes.length; i < len; i++) {
1499            parent.insertBefore(nodes[i], node);
1500        }
1501    }
1502    parent.removeChild(node);
1503}
1504/**
1505 * @method removeWhile
1506 *
1507 * @param {Node} node
1508 * @param {Function} pred
1509 */
1510function removeWhile(node, pred) {
1511    while (node) {
1512        if (isEditable(node) || !pred(node)) {
1513            break;
1514        }
1515        var parent = node.parentNode;
1516        remove(node);
1517        node = parent;
1518    }
1519}
1520/**
1521 * @method replace
1522 *
1523 * replace node with provided nodeName
1524 *
1525 * @param {Node} node
1526 * @param {String} nodeName
1527 * @return {Node} - new node
1528 */
1529function replace(node, nodeName) {
1530    if (node.nodeName.toUpperCase() === nodeName.toUpperCase()) {
1531        return node;
1532    }
1533    var newNode = create(nodeName);
1534    if (node.style.cssText) {
1535        newNode.style.cssText = node.style.cssText;
1536    }
1537    appendChildNodes(newNode, lists.from(node.childNodes));
1538    insertAfter(newNode, node);
1539    remove(node);
1540    return newNode;
1541}
1542var isTextarea = makePredByNodeName('TEXTAREA');
1543/**
1544 * @param {jQuery} $node
1545 * @param {Boolean} [stripLinebreaks] - default: false
1546 */
1547function value($node, stripLinebreaks) {
1548    var val = isTextarea($node[0]) ? $node.val() : $node.html();
1549    if (stripLinebreaks) {
1550        return val.replace(/[\n\r]/g, '');
1551    }
1552    return val;
1553}
1554/**
1555 * @method html
1556 *
1557 * get the HTML contents of node
1558 *
1559 * @param {jQuery} $node
1560 * @param {Boolean} [isNewlineOnBlock]
1561 */
1562function html($node, isNewlineOnBlock) {
1563    var markup = value($node);
1564    if (isNewlineOnBlock) {
1565        var regexTag = /<(\/?)(\b(?!!)[^>\s]*)(.*?)(\s*\/?>)/g;
1566        markup = markup.replace(regexTag, function (match, endSlash, name) {
1567            name = name.toUpperCase();
1568            var isEndOfInlineContainer = /^DIV|^TD|^TH|^P|^LI|^H[1-7]/.test(name) &&
1569                !!endSlash;
1570            var isBlockNode = /^BLOCKQUOTE|^TABLE|^TBODY|^TR|^HR|^UL|^OL/.test(name);
1571            return match + ((isEndOfInlineContainer || isBlockNode) ? '\n' : '');
1572        });
1573        markup = $$1.trim(markup);
1574    }
1575    return markup;
1576}
1577function posFromPlaceholder(placeholder) {
1578    var $placeholder = $$1(placeholder);
1579    var pos = $placeholder.offset();
1580    var height = $placeholder.outerHeight(true); // include margin
1581    return {
1582        left: pos.left,
1583        top: pos.top + height
1584    };
1585}
1586function attachEvents($node, events) {

1915            KEY_MAP.DELETE
1916        ], keyCode);
1917    },
1918    /**
1919     * @method isMove
1920     *
1921     * @param {Number} keyCode
1922     * @return {Boolean}
1923     */
1924    isMove: function (keyCode) {
1925        return lists.contains([
1926            KEY_MAP.LEFT,
1927            KEY_MAP.UP,
1928            KEY_MAP.RIGHT,
1929            KEY_MAP.DOWN
1930        ], keyCode);
1931    },
1932    /**
1933     * @property {Object} nameFromCode
1934     * @property {String} nameFromCode.8 "BACKSPACE"
1935     */
1936    nameFromCode: func.invertObject(KEY_MAP),
1937    code: KEY_MAP
1938};
1939
1940/**
1941 * return boundaryPoint from TextRange, inspired by Andy Na's HuskyRange.js
1942 *
1943 * @param {TextRange} textRange
1944 * @param {Boolean} isStart
1945 * @return {BoundaryPoint}
1946 *
1947 * @see http://msdn.microsoft.com/en-us/library/ie/ms535872(v=vs.85).aspx
1948 */
1949function textRangeToPoint(textRange, isStart) {
1950    var container = textRange.parentElement();
1951    var offset;
1952    var tester = document.body.createTextRange();
1953    var prevContainer;
1954    var childNodes = lists.from(container.childNodes);
1955    for (offset = 0; offset < childNodes.length; offset++) {
1956        if (dom.isText(childNodes[offset])) {
1957            continue;
1958        }
1959        tester.moveToElementText(childNodes[offset]);
1960        if (tester.compareEndPoints('StartToStart', textRange) >= 0) {
1961            break;
1962        }
1963        prevContainer = childNodes[offset];
1964    }
1965    if (offset !== 0 && dom.isText(childNodes[offset - 1])) {
1966        var textRangeStart = document.body.createTextRange();
1967        var curTextNode = null;
1968        textRangeStart.moveToElementText(prevContainer || container);
1969        textRangeStart.collapse(!prevContainer);
1970        curTextNode = prevContainer ? prevContainer.nextSibling : container.firstChild;
1971        var pointTester = textRange.duplicate();
1972        pointTester.setEndPoint('StartToStart', textRangeStart);
1973        var textCount = pointTester.text.replace(/[\r\n]/g, '').length;
1974        while (textCount > curTextNode.nodeValue.length && curTextNode.nextSibling) {
1975            textCount -= curTextNode.nodeValue.length;
1976            curTextNode = curTextNode.nextSibling;
1977        }
1978        // [workaround] enforce IE to re-reference curTextNode, hack
1979        var dummy = curTextNode.nodeValue; // eslint-disable-line
1980        if (isStart && curTextNode.nextSibling && dom.isText(curTextNode.nextSibling) &&
1981            textCount === curTextNode.nodeValue.length) {
1982            textCount -= curTextNode.nodeValue.length;
1983            curTextNode = curTextNode.nextSibling;
1984        }
1985        container = curTextNode;
1986        offset = textCount;
1987    }
1988    return {
1989        cont: container,
1990        offset: offset
1991    };
1992}
1993/**
1994 * return TextRange from boundary point (inspired by google closure-library)
1995 * @param {BoundaryPoint} point
1996 * @return {TextRange}
1997 */
1998function pointToTextRange(point) {
1999    var textRangeInfo = function (container, offset) {
2000        var node, isCollapseToStart;
2001        if (dom.isText(container)) {
2002            var prevTextNodes = dom.listPrev(container, func.not(dom.isText));
2003            var prevContainer = lists.last(prevTextNodes).previousSibling;
2004            node = prevContainer || container.parentNode;
2005            offset += lists.sum(lists.tail(prevTextNodes), dom.nodeLength);
2006            isCollapseToStart = !prevContainer;
2007        }
2008        else {
2009            node = container.childNodes[offset] || container;
2010            if (dom.isText(node)) {
2011                return textRangeInfo(node, 0);
2012            }
2013            offset = 0;
2014            isCollapseToStart = false;

2172        // TODO compare points and sort
2173        var startPoint = this.getStartPoint();
2174        var endPoint = this.getEndPoint();
2175        var nodes = [];
2176        var leftEdgeNodes = [];
2177        dom.walkPoint(startPoint, endPoint, function (point) {
2178            if (dom.isEditable(point.node)) {
2179                return;
2180            }
2181            var node;
2182            if (fullyContains) {
2183                if (dom.isLeftEdgePoint(point)) {
2184                    leftEdgeNodes.push(point.node);
2185                }
2186                if (dom.isRightEdgePoint(point) && lists.contains(leftEdgeNodes, point.node)) {
2187                    node = point.node;
2188                }
2189            }
2190            else if (includeAncestor) {
2191                node = dom.ancestor(point.node, pred);
2192            }
2193            else {
2194                node = point.node;
2195            }
2196            if (node && pred(node)) {
2197                nodes.push(node);
2198            }
2199        }, true);
2200        return lists.unique(nodes);
2201    };
2202    /**
2203     * returns commonAncestor of range
2204     * @return {Element} - commonAncestor
2205     */
2206    WrappedRange.prototype.commonAncestor = function () {
2207        return dom.commonAncestor(this.sc, this.ec);
2208    };
2209    /**
2210     * returns expanded range by pred
2211     *
2212     * @param {Function} pred - predicate function
2213     * @return {WrappedRange}
2214     */
2215    WrappedRange.prototype.expand = function (pred) {
2216        var startAncestor = dom.ancestor(this.sc, pred);
2217        var endAncestor = dom.ancestor(this.ec, pred);
2218        if (!startAncestor && !endAncestor) {
2219            return new WrappedRange(this.sc, this.so, this.ec, this.eo);
2220        }
2221        var boundaryPoints = this.getPoints();
2222        if (startAncestor) {
2223            boundaryPoints.sc = startAncestor;
2224            boundaryPoints.so = 0;
2225        }
2226        if (endAncestor) {
2227            boundaryPoints.ec = endAncestor;
2228            boundaryPoints.eo = dom.nodeLength(endAncestor);
2229        }
2230        return new WrappedRange(boundaryPoints.sc, boundaryPoints.so, boundaryPoints.ec, boundaryPoints.eo);
2231    };
2232    /**
2233     * @param {Boolean} isCollapseToStart
2234     * @return {WrappedRange}
2235     */
2236    WrappedRange.prototype.collapse = function (isCollapseToStart) {
2237        if (isCollapseToStart) {
2238            return new WrappedRange(this.sc, this.so, this.sc, this.so);
2239        }
2240        else {
2241            return new WrappedRange(this.ec, this.eo, this.ec, this.eo);
2242        }
2243    };
2244    /**
2245     * splitText on range
2246     */
2247    WrappedRange.prototype.splitText = function () {
2248        var isSameContainer = this.sc === this.ec;
2249        var boundaryPoints = this.getPoints();
2250        if (dom.isText(this.ec) && !dom.isEdgePoint(this.getEndPoint())) {
2251            this.ec.splitText(this.eo);
2252        }
2253        if (dom.isText(this.sc) && !dom.isEdgePoint(this.getStartPoint())) {
2254            boundaryPoints.sc = this.sc.splitText(this.so);
2255            boundaryPoints.so = 0;
2256            if (isSameContainer) {
2257                boundaryPoints.ec = boundaryPoints.sc;
2258                boundaryPoints.eo = this.eo - this.so;
2259            }
2260        }
2261        return new WrappedRange(boundaryPoints.sc, boundaryPoints.so, boundaryPoints.ec, boundaryPoints.eo);
2262    };
2263    /**
2264     * delete contents on range
2265     * @return {WrappedRange}
2266     */
2267    WrappedRange.prototype.deleteContents = function () {
2268        if (this.isCollapsed()) {
2269            return this;
2270        }
2271        var rng = this.splitText();
2272        var nodes = rng.nodes(null, {
2273            fullyContains: true
2274        });
2275        // find new cursor point
2276        var point = dom.prevPointUntil(rng.getStartPoint(), function (point) {
2277            return !lists.contains(nodes, point.node);
2278        });
2279        var emptyParents = [];
2280        $$1.each(nodes, function (idx, node) {
2281            // find empty parents
2282            var parent = node.parentNode;
2283            if (point.node !== parent && dom.nodeLength(parent) === 1) {
2284                emptyParents.push(parent);
2285            }
2286            dom.remove(node, false);
2287        });
2288        // remove empty parents
2289        $$1.each(emptyParents, function (idx, node) {
2290            dom.remove(node, false);
2291        });
2292        return new WrappedRange(point.node, point.offset, point.node, point.offset).normalize();
2293    };
2294    /**
2295     * makeIsOn: return isOn(pred) function
2296     */
2297    WrappedRange.prototype.makeIsOn = function (pred) {
2298        return function () {
2299            var ancestor = dom.ancestor(this.sc, pred);
2300            return !!ancestor && (ancestor === dom.ancestor(this.ec, pred));
2301        };
2302    };
2303    /**
2304     * @param {Function} pred
2305     * @return {Boolean}
2306     */
2307    WrappedRange.prototype.isLeftEdgeOf = function (pred) {
2308        if (!dom.isLeftEdgePoint(this.getStartPoint())) {
2309            return false;
2310        }
2311        var node = dom.ancestor(this.sc, pred);
2312        return node && dom.isLeftEdgeOf(this.sc, node);
2313    };
2314    /**
2315     * returns whether range was collapsed or not
2316     */
2317    WrappedRange.prototype.isCollapsed = function () {
2318        return this.sc === this.ec && this.so === this.eo;
2319    };
2320    /**
2321     * wrap inline nodes which children of body with paragraph
2322     *
2323     * @return {WrappedRange}
2324     */
2325    WrappedRange.prototype.wrapBodyInlineWithPara = function () {
2326        if (dom.isBodyContainer(this.sc) && dom.isEmpty(this.sc)) {
2327            this.sc.innerHTML = dom.emptyPara;
2328            return new WrappedRange(this.sc.firstChild, 0, this.sc.firstChild, 0);
2329        }
2330        /**
2331         * [workaround] firefox often create range on not visible point. so normalize here.
2332         *  - firefox: |<p>text</p>|
2333         *  - chrome: <p>|text|</p>
2334         */
2335        var rng = this.normalize();
2336        if (dom.isParaInline(this.sc) || dom.isPara(this.sc)) {
2337            return rng;
2338        }
2339        // find inline top ancestor
2340        var topAncestor;
2341        if (dom.isInline(rng.sc)) {
2342            var ancestors = dom.listAncestor(rng.sc, func.not(dom.isInline));
2343            topAncestor = lists.last(ancestors);
2344            if (!dom.isInline(topAncestor)) {
2345                topAncestor = ancestors[ancestors.length - 2] || rng.sc.childNodes[rng.so];
2346            }
2347        }
2348        else {
2349            topAncestor = rng.sc.childNodes[rng.so > 0 ? rng.so - 1 : 0];
2350        }
2351        // siblings not in paragraph
2352        var inlineSiblings = dom.listPrev(topAncestor, dom.isParaInline).reverse();
2353        inlineSiblings = inlineSiblings.concat(dom.listNext(topAncestor.nextSibling, dom.isParaInline));
2354        // wrap with paragraph
2355        if (inlineSiblings.length) {
2356            var para = dom.wrap(lists.head(inlineSiblings), 'p');
2357            dom.appendChildNodes(para, lists.tail(inlineSiblings));
2358        }
2359        return this.normalize();
2360    };
2361    /**
2362     * insert node at current cursor
2363     *
2364     * @param {Node} node
2365     * @return {Node}
2366     */
2367    WrappedRange.prototype.insertNode = function (node) {
2368        var rng = this.wrapBodyInlineWithPara().deleteContents();
2369        var info = dom.splitPoint(rng.getStartPoint(), dom.isInline(node));
2370        if (info.rightNode) {
2371            info.rightNode.parentNode.insertBefore(node, info.rightNode);
2372        }
2373        else {
2374            info.container.appendChild(node);
2375        }
2376        return node;
2377    };
2378    /**
2379     * insert html at current cursor
2380     */
2381    WrappedRange.prototype.pasteHTML = function (markup) {
2382        var contentsContainer = $$1('<div></div>').html(markup)[0];
2383        var childNodes = lists.from(contentsContainer.childNodes);
2384        var rng = this.wrapBodyInlineWithPara().deleteContents();
2385        return childNodes.reverse().map(function (childNode) {
2386            return rng.insertNode(childNode);
2387        }).reverse();
2388    };
2389    /**
2390     * returns text in range
2391     *
2392     * @return {String}
2393     */
2394    WrappedRange.prototype.toString = function () {
2395        var nativeRng = this.nativeRange();
2396        return env.isW3CRangeSupport ? nativeRng.toString() : nativeRng.text;
2397    };
2398    /**
2399     * returns range for word before cursor
2400     *
2401     * @param {Boolean} [findAfter] - find after cursor, default: false
2402     * @return {WrappedRange}
2403     */
2404    WrappedRange.prototype.getWordRange = function (findAfter) {
2405        var endPoint = this.getEndPoint();
2406        if (!dom.isCharPoint(endPoint)) {
2407            return this;
2408        }
2409        var startPoint = dom.prevPointUntil(endPoint, function (point) {
2410            return !dom.isCharPoint(point);
2411        });
2412        if (findAfter) {
2413            endPoint = dom.nextPointUntil(endPoint, function (point) {
2414                return !dom.isCharPoint(point);
2415            });
2416        }
2417        return new WrappedRange(startPoint.node, startPoint.offset, endPoint.node, endPoint.offset);
2418    };
2419    /**
2420     * create offsetPath bookmark
2421     *
2422     * @param {Node} editable
2423     */
2424    WrappedRange.prototype.bookmark = function (editable) {
2425        return {
2426            s: {
2427                path: dom.makeOffsetPath(editable, this.sc),
2428                offset: this.so
2429            },
2430            e: {
2431                path: dom.makeOffsetPath(editable, this.ec),
2432                offset: this.eo
2433            }
2434        };
2435    };
2436    /**
2437     * create offsetPath bookmark base on paragraph
2438     *
2439     * @param {Node[]} paras
2440     */
2441    WrappedRange.prototype.paraBookmark = function (paras) {
2442        return {
2443            s: {
2444                path: lists.tail(dom.makeOffsetPath(lists.head(paras), this.sc)),
2445                offset: this.so
2446            },
2447            e: {
2448                path: lists.tail(dom.makeOffsetPath(lists.last(paras), this.ec)),
2449                offset: this.eo
2450            }
2451        };
2452    };
2453    /**
2454     * getClientRects
2455     * @return {Rect[]}
2456     */
2457    WrappedRange.prototype.getClientRects = function () {
2458        var nativeRng = this.nativeRange();
2459        return nativeRng.getClientRects();
2460    };
2461    return WrappedRange;
2462}());
2463/**
2464 * Data structure
2465 *  * BoundaryPoint: a point of dom tree
2466 *  * BoundaryPoints: two boundaryPoints corresponding to the start and the end of the Range
2467 *
2468 * See to http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html#Level-2-Range-Position
2469 */
2470var range = {
2471    /**
2472     * create Range Object From arguments or Browser Selection
2473     *
2474     * @param {Node} sc - start container
2475     * @param {Number} so - start offset
2476     * @param {Node} ec - end container
2477     * @param {Number} eo - end offset
2478     * @return {WrappedRange}
2479     */
2480    create: function (sc, so, ec, eo) {
2481        if (arguments.length === 4) {
2482            return new WrappedRange(sc, so, ec, eo);
2483        }
2484        else if (arguments.length === 2) {
2485            ec = sc;
2486            eo = so;
2487            return new WrappedRange(sc, so, ec, eo);
2488        }
2489        else {
2490            var wrappedRange = this.createFromSelection();
2491            if (!wrappedRange && arguments.length === 1) {
2492                wrappedRange = this.createFromNode(arguments[0]);
2493                return wrappedRange.collapse(dom.emptyPara === arguments[0].innerHTML);
2494            }
2495            return wrappedRange;
2496        }
2497    },
2498    createFromSelection: function () {
2499        var sc, so, ec, eo;
2500        if (env.isW3CRangeSupport) {
2501            var selection = document.getSelection();
2502            if (!selection || selection.rangeCount === 0) {
2503                return null;
2504            }
2505            else if (dom.isBody(selection.anchorNode)) {
2506                // Firefox: returns entire body as range on initialization.
2507                // We won't never need it.
2508                return null;
2509            }
2510            var nativeRng = selection.getRangeAt(0);
2511            sc = nativeRng.startContainer;
2512            so = nativeRng.startOffset;
2513            ec = nativeRng.endContainer;
2514            eo = nativeRng.endOffset;
2515        }
2516        else {
2517            var textRange = document.selection.createRange();
2518            var textRangeEnd = textRange.duplicate();
2519            textRangeEnd.collapse(false);
2520            var textRangeStart = textRange;
2521            textRangeStart.collapse(true);
2522            var startPoint = textRangeToPoint(textRangeStart, true);
2523            var endPoint = textRangeToPoint(textRangeEnd, false);
2524            // same visible point case: range was collapsed.
2525            if (dom.isText(startPoint.node) && dom.isLeftEdgePoint(startPoint) &&
2526                dom.isTextNode(endPoint.node) && dom.isRightEdgePoint(endPoint) &&
2527                endPoint.node.nextSibling === startPoint.node) {
2528                startPoint = endPoint;
2529            }
2530            sc = startPoint.cont;
2531            so = startPoint.offset;
2532            ec = endPoint.cont;
2533            eo = endPoint.offset;
2534        }
2535        return new WrappedRange(sc, so, ec, eo);
2536    },
2537    /**
2538     * @method
2539     *
2540     * create WrappedRange from node
2541     *
2542     * @param {Node} node
2543     * @return {WrappedRange}
2544     */
2545    createFromNode: function (node) {
2546        var sc = node;
2547        var so = 0;
2548        var ec = node;
2549        var eo = dom.nodeLength(ec);
2550        // browsers can't target a picture or void node
2551        if (dom.isVoid(sc)) {
2552            so = dom.listPrev(sc).length - 1;
2553            sc = sc.parentNode;
2554        }
2555        if (dom.isBR(ec)) {
2556            eo = dom.listPrev(ec).length - 1;
2557            ec = ec.parentNode;
2558        }
2559        else if (dom.isVoid(ec)) {
2560            eo = dom.listPrev(ec).length;
2561            ec = ec.parentNode;
2562        }
2563        return this.create(sc, so, ec, eo);
2564    },
2565    /**
2566     * create WrappedRange from node after position
2567     *
2568     * @param {Node} node
2569     * @return {WrappedRange}
2570     */
2571    createFromNodeBefore: function (node) {
2572        return this.createFromNode(node).collapse(true);
2573    },
2574    /**
2575     * create WrappedRange from node after position
2576     *
2577     * @param {Node} node
2578     * @return {WrappedRange}
2579     */
2580    createFromNodeAfter: function (node) {
2581        return this.createFromNode(node).collapse();
2582    },
2583    /**
2584     * @method
2585     *
2586     * create WrappedRange from bookmark
2587     *
2588     * @param {Node} editable
2589     * @param {Object} bookmark
2590     * @return {WrappedRange}
2591     */
2592    createFromBookmark: function (editable, bookmark) {
2593        var sc = dom.fromOffsetPath(editable, bookmark.s.path);
2594        var so = bookmark.s.offset;
2595        var ec = dom.fromOffsetPath(editable, bookmark.e.path);
2596        var eo = bookmark.e.offset;
2597        return new WrappedRange(sc, so, ec, eo);
2598    },
2599    /**
2600     * @method
2601     *
2602     * create WrappedRange from paraBookmark
2603     *
2604     * @param {Object} bookmark
2605     * @param {Node[]} paras
2606     * @return {WrappedRange}
2607     */
2608    createFromParaBookmark: function (bookmark, paras) {
2609        var so = bookmark.s.offset;
2610        var eo = bookmark.e.offset;
2611        var sc = dom.fromOffsetPath(lists.head(paras), bookmark.s.path);
2612        var ec = dom.fromOffsetPath(lists.last(paras), bookmark.e.path);
2613        return new WrappedRange(sc, so, ec, eo);
2614    }
2615};
2616
2617/**
2618 * @method readFileAsDataURL
2619 *
2620 * read contents of file as representing URL
2621 *
2622 * @param {File} file
2623 * @return {Promise} - then: dataUrl
2624 */
2625function readFileAsDataURL(file) {
2626    return $$1.Deferred(function (deferred) {
2627        $$1.extend(new FileReader(), {
2628            onload: function (e) {
2629                var dataURL = e.target.result;
2630                deferred.resolve(dataURL);
2631            },
2632            onerror: function (err) {
2633                deferred.reject(err);
2634            }
2635        }).readAsDataURL(file);
2636    }).promise();
2637}
2638/**
2639 * @method createImage
2640 *
2641 * create `<image>` from url string
2642 *
2643 * @param {String} url
2644 * @return {Promise} - then: $image
2645 */
2646function createImage(url) {
2647    return $$1.Deferred(function (deferred) {
2648        var $img = $$1('<img>');
2649        $img.one('load', function () {
2650            $img.off('error abort');
2651            deferred.resolve($img);
2652        }).one('error abort', function () {
2653            $img.off('load').detach();
2654            deferred.reject($img);
2655        }).css({
2656            display: 'none'
2657        }).appendTo(document.body).attr('src', url);
2658    }).promise();
2659}
2660
2661var History = /** @class */ (function () {
2662    function History($editable) {
2663        this.stack = [];
2664        this.stackOffset = -1;
2665        this.$editable = $editable;
2666        this.editable = $editable[0];
2667    }
2668    History.prototype.makeSnapshot = function () {
2669        var rng = range.create(this.editable);
2670        var emptyBookmark = { s: { path: [], offset: 0 }, e: { path: [], offset: 0 } };
2671        return {
2672            contents: this.$editable.html(),
2673            bookmark: (rng ? rng.bookmark(this.editable) : emptyBookmark)
2674        };
2675    };