https://finite.solutions/front-v2.2.1/assets/vendor/summernote/dist/summernote-lite.js

388                children: opt.items[1]
389            })
390        ])
391    ]).render();
392};
393var tableMoveHandler = function (event, col, row) {
394    var PX_PER_EM = 18;
395    var $picker = $(event.target.parentNode); // target is mousecatcher
396    var $dimensionDisplay = $picker.next();
397    var $catcher = $picker.find('.note-dimension-picker-mousecatcher');
398    var $highlighted = $picker.find('.note-dimension-picker-highlighted');
399    var $unhighlighted = $picker.find('.note-dimension-picker-unhighlighted');
400    var posOffset;
401    // HTML5 with jQuery - e.offsetX is undefined in Firefox
402    if (event.offsetX === undefined) {
403        var posCatcher = $(event.target).offset();
404        posOffset = {
405            x: event.pageX - posCatcher.left,
406            y: event.pageY - posCatcher.top
407        };
408    }
409    else {
410        posOffset = {
411            x: event.offsetX,
412            y: event.offsetY
413        };
414    }
415    var dim = {
416        c: Math.ceil(posOffset.x / PX_PER_EM) || 1,
417        r: Math.ceil(posOffset.y / PX_PER_EM) || 1
418    };
419    $highlighted.css({ width: dim.c + 'em', height: dim.r + 'em' });
420    $catcher.data('value', dim.c + 'x' + dim.r);
421    if (dim.c > 3 && dim.c < col) {
422        $unhighlighted.css({ width: dim.c + 1 + 'em' });
423    }
424    if (dim.r > 3 && dim.r < row) {
425        $unhighlighted.css({ height: dim.r + 1 + 'em' });
426    }
427    $dimensionDisplay.html(dim.c + ' x ' + dim.r);
428};
429var tableDropdownButton = function (opt) {
430    return buttonGroup([
431        button({
432            className: 'dropdown-toggle',
433            contents: opt.title + ' ' + icon('note-icon-caret'),
434            tooltip: opt.tooltip,
435            data: {
436                toggle: 'dropdown'
437            }
438        }),
439        dropdown({
440            className: 'note-table',
441            items: [
442                '<div class="note-dimension-picker">',
443                '  <div class="note-dimension-picker-mousecatcher" data-event="insertTable" data-value="1x1"/>',
444                '  <div class="note-dimension-picker-highlighted"/>',
445                '  <div class="note-dimension-picker-unhighlighted"/>',
446                '</div>',
447                '<div class="note-dimension-display">1 x 1</div>'
448            ].join('')
449        })
450    ], {
451        callback: function ($node) {
452            var $catcher = $node.find('.note-dimension-picker-mousecatcher');
453            $catcher.css({
454                width: opt.col + 'em',
455                height: opt.row + 'em'
456            })
457                .mousedown(opt.itemClick)
458                .mousemove(function (e) {
459                tableMoveHandler(e, opt.col, opt.row);
460            });
461        }
462    }).render();
463};
464var palette = renderer.create('<div class="note-color-palette"/>', function ($node, options) {
465    var contents = [];
466    for (var row = 0, rowSize = options.colors.length; row < rowSize; row++) {
467        var eventName = options.eventName;
468        var colors = options.colors[row];
469        var colorsName = options.colorsName[row];
470        var buttons = [];
471        for (var col = 0, colSize = colors.length; col < colSize; col++) {
472            var color = colors[col];
473            var colorName = colorsName[col];
474            buttons.push([
475                '<button type="button" class="note-btn note-color-btn"',
476                'style="background-color:', color, '" ',
477                'data-event="', eventName, '" ',
478                'data-value="', color, '" ',
479                'title="', colorName, '" ',
480                'aria-label="', colorName, '" ',
481                'data-toggle="button" tabindex="-1"></button>'
482            ].join(''));
483        }
484        contents.push('<div class="note-color-row">' + buttons.join('') + '</div>');
485    }
486    $node.html(contents.join(''));
487    $node.find('.note-color-btn').each(function () {
488        $(this).data('_lite_tooltip', new TooltipUI($(this), {
489            container: options.container
490        }));
491    });
492});
493var colorDropdownButton = function (opt, type) {
494    return buttonGroup({
495        className: 'note-color',
496        children: [
497            button({
498                className: 'note-current-color-button',
499                contents: opt.title,
500                tooltip: opt.lang.color.recent,
501                click: opt.currentClick,
502                callback: function ($button) {
503                    var $recentColor = $button.find('.note-recent-color');
504                    if (type !== 'foreColor') {
505                        $recentColor.css('background-color', '#FFFF00');
506                        $button.attr('data-backColor', '#FFFF00');
507                    }
508                }
509            }),
510            button({
511                className: 'dropdown-toggle',

1178                func.apply(context, args);
1179            }
1180        };
1181        var callNow = immediate && !timeout;
1182        clearTimeout(timeout);
1183        timeout = setTimeout(later, wait);
1184        if (callNow) {
1185            func.apply(context, args);
1186        }
1187    };
1188}
1189var func = {
1190    eq: eq,
1191    eq2: eq2,
1192    peq2: peq2,
1193    ok: ok,
1194    fail: fail,
1195    self: self,
1196    not: not,
1197    and: and,
1198    invoke: invoke,
1199    uniqueId: uniqueId,
1200    rect2bnd: rect2bnd,
1201    invertObject: invertObject,
1202    namespaceToCamel: namespaceToCamel,
1203    debounce: debounce
1204};
1205
1206/**
1207 * returns the first item of an array.
1208 *
1209 * @param {Array} array
1210 */
1211function head(array) {
1212    return array[0];
1213}
1214/**
1215 * returns the last item of an array.
1216 *
1217 * @param {Array} array
1218 */
1219function last(array) {
1220    return array[array.length - 1];
1221}
1222/**
1223 * returns everything but the last entry of the array.
1224 *
1225 * @param {Array} array
1226 */
1227function initial(array) {
1228    return array.slice(0, array.length - 1);
1229}
1230/**
1231 * returns the rest of the items in an array.
1232 *
1233 * @param {Array} array
1234 */
1235function tail(array) {
1236    return array.slice(1);
1237}
1238/**
1239 * returns item of array
1240 */
1241function find(array, pred) {
1242    for (var idx = 0, len = array.length; idx < len; idx++) {
1243        var item = array[idx];
1244        if (pred(item)) {
1245            return item;
1246        }
1247    }
1248}
1249/**
1250 * returns true if all of the values in the array pass the predicate truth test.
1251 */
1252function all(array, pred) {
1253    for (var idx = 0, len = array.length; idx < len; idx++) {
1254        if (!pred(array[idx])) {
1255            return false;
1256        }
1257    }
1258    return true;
1259}
1260/**
1261 * returns index of item
1262 */
1263function indexOf(array, item) {
1264    return $$1.inArray(item, array);
1265}
1266/**
1267 * returns true if the value is present in the list.
1268 */
1269function contains(array, item) {
1270    return indexOf(array, item) !== -1;
1271}
1272/**
1273 * get sum from a list
1274 *
1275 * @param {Array} array - array
1276 * @param {Function} fn - iterator
1277 */
1278function sum(array, fn) {
1279    fn = fn || func.self;
1280    return array.reduce(function (memo, v) {
1281        return memo + fn(v);
1282    }, 0);
1283}
1284/**
1285 * returns a copy of the collection with array type.
1286 * @param {Collection} collection - collection eg) node.childNodes, ...
1287 */
1288function from(collection) {
1289    var result = [];
1290    var length = collection.length;
1291    var idx = -1;
1292    while (++idx < length) {
1293        result[idx] = collection[idx];
1294    }
1295    return result;
1296}
1297/**
1298 * returns whether list is empty or not
1299 */
1300function isEmpty(array) {
1301    return !array || !array.length;
1302}
1303/**
1304 * cluster elements by predicate function.
1305 *
1306 * @param {Array} array - array
1307 * @param {Function} fn - predicate function for cluster rule
1308 * @param {Array[]}
1309 */
1310function clusterBy(array, fn) {
1311    if (!array.length) {
1312        return [];
1313    }
1314    var aTail = tail(array);
1315    return aTail.reduce(function (memo, v) {
1316        var aLast = last(memo);
1317        if (fn(last(aLast), v)) {
1318            aLast[aLast.length] = v;
1319        }
1320        else {
1321            memo[memo.length] = [v];
1322        }
1323        return memo;
1324    }, [[head(array)]]);
1325}
1326/**
1327 * returns a copy of the array with all false values removed
1328 *
1329 * @param {Array} array - array
1330 * @param {Function} fn - predicate function for cluster rule
1331 */
1332function compact(array) {
1333    var aResult = [];
1334    for (var idx = 0, len = array.length; idx < len; idx++) {
1335        if (array[idx]) {
1336            aResult.push(array[idx]);
1337        }
1338    }
1339    return aResult;
1340}
1341/**
1342 * produces a duplicate-free version of the array
1343 *
1344 * @param {Array} array
1345 */
1346function unique(array) {
1347    var results = [];
1348    for (var idx = 0, len = array.length; idx < len; idx++) {
1349        if (!contains(results, array[idx])) {
1350            results.push(array[idx]);
1351        }
1352    }
1353    return results;
1354}
1355/**
1356 * returns next item.
1357 * @param {Array} array
1358 */
1359function next(array, item) {
1360    var idx = indexOf(array, item);
1361    if (idx === -1) {
1362        return null;
1363    }
1364    return array[idx + 1];

1463            KEY_MAP.DELETE
1464        ], keyCode);
1465    },
1466    /**
1467     * @method isMove
1468     *
1469     * @param {Number} keyCode
1470     * @return {Boolean}
1471     */
1472    isMove: function (keyCode) {
1473        return lists.contains([
1474            KEY_MAP.LEFT,
1475            KEY_MAP.UP,
1476            KEY_MAP.RIGHT,
1477            KEY_MAP.DOWN
1478        ], keyCode);
1479    },
1480    /**
1481     * @property {Object} nameFromCode
1482     * @property {String} nameFromCode.8 "BACKSPACE"
1483     */
1484    nameFromCode: func.invertObject(KEY_MAP),
1485    code: KEY_MAP
1486};
1487
1488var NBSP_CHAR = String.fromCharCode(160);
1489var ZERO_WIDTH_NBSP_CHAR = '\ufeff';
1490/**
1491 * @method isEditable
1492 *
1493 * returns whether node is `note-editable` or not.
1494 *
1495 * @param {Node} node
1496 * @return {Boolean}
1497 */
1498function isEditable(node) {
1499    return node && $$1(node).hasClass('note-editable');
1500}
1501/**
1502 * @method isControlSizing
1503 *
1504 * returns whether node is `note-control-sizing` or not.
1505 *
1506 * @param {Node} node
1507 * @return {Boolean}
1508 */
1509function isControlSizing(node) {
1510    return node && $$1(node).hasClass('note-control-sizing');
1511}
1512/**
1513 * @method makePredByNodeName
1514 *
1515 * returns predicate which judge whether nodeName is same
1516 *
1517 * @param {String} nodeName
1518 * @return {Function}
1519 */
1520function makePredByNodeName(nodeName) {
1521    nodeName = nodeName.toUpperCase();
1522    return function (node) {
1523        return node && node.nodeName.toUpperCase() === nodeName;
1524    };
1525}
1526/**
1527 * @method isText
1528 *
1529 *
1530 *
1531 * @param {Node} node
1532 * @return {Boolean} true if node's type is text(3)
1533 */
1534function isText(node) {
1535    return node && node.nodeType === 3;
1536}
1537/**
1538 * @method isElement
1539 *
1540 *
1541 *
1542 * @param {Node} node
1543 * @return {Boolean} true if node's type is element(1)
1544 */
1545function isElement(node) {
1546    return node && node.nodeType === 1;
1547}
1548/**
1549 * ex) br, col, embed, hr, img, input, ...
1550 * @see http://www.w3.org/html/wg/drafts/html/master/syntax.html#void-elements
1551 */
1552function isVoid(node) {
1553    return node && /^BR|^IMG|^HR|^IFRAME|^BUTTON|^INPUT/.test(node.nodeName.toUpperCase());
1554}
1555function isPara(node) {
1556    if (isEditable(node)) {
1557        return false;
1558    }
1559    // Chrome(v31.0), FF(v25.0.1) use DIV for paragraph
1560    return node && /^DIV|^P|^LI|^H[1-7]/.test(node.nodeName.toUpperCase());
1561}
1562function isHeading(node) {
1563    return node && /^H[1-7]/.test(node.nodeName.toUpperCase());
1564}
1565var isPre = makePredByNodeName('PRE');
1566var isLi = makePredByNodeName('LI');
1567function isPurePara(node) {
1568    return isPara(node) && !isLi(node);
1569}
1570var isTable = makePredByNodeName('TABLE');
1571var isData = makePredByNodeName('DATA');
1572function isInline(node) {
1573    return !isBodyContainer(node) &&
1574        !isList(node) &&
1575        !isHr(node) &&
1576        !isPara(node) &&
1577        !isTable(node) &&
1578        !isBlockquote(node) &&
1579        !isData(node);
1580}
1581function isList(node) {
1582    return node && /^UL|^OL/.test(node.nodeName.toUpperCase());
1583}
1584var isHr = makePredByNodeName('HR');
1585function isCell(node) {
1586    return node && /^TD|^TH/.test(node.nodeName.toUpperCase());
1587}
1588var isBlockquote = makePredByNodeName('BLOCKQUOTE');
1589function isBodyContainer(node) {
1590    return isCell(node) || isBlockquote(node) || isEditable(node);
1591}
1592var isAnchor = makePredByNodeName('A');
1593function isParaInline(node) {
1594    return isInline(node) && !!ancestor(node, isPara);
1595}
1596function isBodyInline(node) {
1597    return isInline(node) && !ancestor(node, isPara);
1598}
1599var isBody = makePredByNodeName('BODY');
1600/**
1601 * returns whether nodeB is closest sibling of nodeA
1602 *
1603 * @param {Node} nodeA
1604 * @param {Node} nodeB
1605 * @return {Boolean}
1606 */
1607function isClosestSibling(nodeA, nodeB) {
1608    return nodeA.nextSibling === nodeB ||
1609        nodeA.previousSibling === nodeB;
1610}
1611/**
1612 * returns array of closest siblings with node
1613 *
1614 * @param {Node} node
1615 * @param {function} [pred] - predicate function
1616 * @return {Node[]}
1617 */
1618function withClosestSiblings(node, pred) {
1619    pred = pred || func.ok;
1620    var siblings = [];
1621    if (node.previousSibling && pred(node.previousSibling)) {
1622        siblings.push(node.previousSibling);
1623    }
1624    siblings.push(node);
1625    if (node.nextSibling && pred(node.nextSibling)) {
1626        siblings.push(node.nextSibling);
1627    }
1628    return siblings;
1629}
1630/**
1631 * blank HTML for cursor position
1632 * - [workaround] old IE only works with  
1633 * - [workaround] IE11 and other browser works with bogus br
1634 */
1635var blankHTML = env.isMSIE && env.browserVersion < 11 ? '&nbsp;' : '<br>';
1636/**
1637 * @method nodeLength
1638 *
1639 * returns #text's text size or element's childNodes size
1640 *
1641 * @param {Node} node
1642 */
1643function nodeLength(node) {
1644    if (isText(node)) {
1645        return node.nodeValue.length;
1646    }
1647    if (node) {
1648        return node.childNodes.length;
1649    }
1650    return 0;
1651}
1652/**
1653 * returns whether node is empty or not.
1654 *
1655 * @param {Node} node
1656 * @return {Boolean}
1657 */
1658function isEmpty$1(node) {
1659    var len = nodeLength(node);
1660    if (len === 0) {
1661        return true;
1662    }
1663    else if (!isText(node) && len === 1 && node.innerHTML === blankHTML) {
1664        // ex) <p><br></p>, <span><br></span>
1665        return true;
1666    }
1667    else if (lists.all(node.childNodes, isText) && node.innerHTML === '') {
1668        // ex) <p></p>, <span></span>
1669        return true;
1670    }
1671    return false;
1672}
1673/**
1674 * padding blankHTML if node is empty (for cursor position)
1675 */
1676function paddingBlankHTML(node) {
1677    if (!isVoid(node) && !nodeLength(node)) {
1678        node.innerHTML = blankHTML;
1679    }
1680}
1681/**
1682 * find nearest ancestor predicate hit
1683 *
1684 * @param {Node} node
1685 * @param {Function} pred - predicate function
1686 */
1687function ancestor(node, pred) {
1688    while (node) {
1689        if (pred(node)) {
1690            return node;
1691        }
1692        if (isEditable(node)) {
1693            break;
1694        }
1695        node = node.parentNode;
1696    }
1697    return null;
1698}
1699/**
1700 * find nearest ancestor only single child blood line and predicate hit
1701 *
1702 * @param {Node} node
1703 * @param {Function} pred - predicate function
1704 */
1705function singleChildAncestor(node, pred) {
1706    node = node.parentNode;
1707    while (node) {
1708        if (nodeLength(node) !== 1) {
1709            break;
1710        }
1711        if (pred(node)) {
1712            return node;
1713        }
1714        if (isEditable(node)) {
1715            break;
1716        }
1717        node = node.parentNode;
1718    }
1719    return null;
1720}
1721/**
1722 * returns new array of ancestor nodes (until predicate hit).
1723 *
1724 * @param {Node} node
1725 * @param {Function} [optional] pred - predicate function
1726 */
1727function listAncestor(node, pred) {
1728    pred = pred || func.fail;
1729    var ancestors = [];
1730    ancestor(node, function (el) {
1731        if (!isEditable(el)) {
1732            ancestors.push(el);
1733        }
1734        return pred(el);
1735    });
1736    return ancestors;
1737}
1738/**
1739 * find farthest ancestor predicate hit
1740 */
1741function lastAncestor(node, pred) {
1742    var ancestors = listAncestor(node);
1743    return lists.last(ancestors.filter(pred));
1744}
1745/**
1746 * returns common ancestor node between two nodes.
1747 *
1748 * @param {Node} nodeA
1749 * @param {Node} nodeB
1750 */
1751function commonAncestor(nodeA, nodeB) {
1752    var ancestors = listAncestor(nodeA);
1753    for (var n = nodeB; n; n = n.parentNode) {
1754        if ($$1.inArray(n, ancestors) > -1) {
1755            return n;
1756        }
1757    }
1758    return null; // difference document area
1759}
1760/**
1761 * listing all previous siblings (until predicate hit).
1762 *
1763 * @param {Node} node
1764 * @param {Function} [optional] pred - predicate function
1765 */
1766function listPrev(node, pred) {
1767    pred = pred || func.fail;
1768    var nodes = [];
1769    while (node) {
1770        if (pred(node)) {
1771            break;
1772        }
1773        nodes.push(node);
1774        node = node.previousSibling;
1775    }
1776    return nodes;
1777}
1778/**
1779 * listing next siblings (until predicate hit).
1780 *
1781 * @param {Node} node
1782 * @param {Function} [pred] - predicate function
1783 */
1784function listNext(node, pred) {
1785    pred = pred || func.fail;
1786    var nodes = [];
1787    while (node) {
1788        if (pred(node)) {
1789            break;
1790        }
1791        nodes.push(node);
1792        node = node.nextSibling;
1793    }
1794    return nodes;
1795}
1796/**
1797 * listing descendant nodes
1798 *
1799 * @param {Node} node
1800 * @param {Function} [pred] - predicate function
1801 */
1802function listDescendant(node, pred) {
1803    var descendants = [];
1804    pred = pred || func.ok;
1805    // start DFS(depth first search) with node
1806    (function fnWalk(current) {
1807        if (node !== current && pred(current)) {
1808            descendants.push(current);
1809        }
1810        for (var idx = 0, len = current.childNodes.length; idx < len; idx++) {
1811            fnWalk(current.childNodes[idx]);
1812        }
1813    })(node);
1814    return descendants;
1815}
1816/**
1817 * wrap node with new tag.
1818 *
1819 * @param {Node} node
1820 * @param {Node} tagName of wrapper
1821 * @return {Node} - wrapper
1822 */
1823function wrap(node, wrapperName) {
1824    var parent = node.parentNode;
1825    var wrapper = $$1('<' + wrapperName + '>')[0];
1826    parent.insertBefore(wrapper, node);
1827    wrapper.appendChild(node);
1828    return wrapper;
1829}
1830/**
1831 * insert node after preceding
1832 *
1833 * @param {Node} node
1834 * @param {Node} preceding - predicate function
1835 */
1836function insertAfter(node, preceding) {
1837    var next = preceding.nextSibling;
1838    var parent = preceding.parentNode;
1839    if (next) {
1840        parent.insertBefore(node, next);
1841    }
1842    else {
1843        parent.appendChild(node);
1844    }
1845    return node;
1846}
1847/**
1848 * append elements.
1849 *
1850 * @param {Node} node
1851 * @param {Collection} aChild
1852 */
1853function appendChildNodes(node, aChild) {
1854    $$1.each(aChild, function (idx, child) {
1855        node.appendChild(child);
1856    });
1857    return node;
1858}
1859/**
1860 * returns whether boundaryPoint is left edge or not.
1861 *
1862 * @param {BoundaryPoint} point
1863 * @return {Boolean}
1864 */
1865function isLeftEdgePoint(point) {
1866    return point.offset === 0;
1867}
1868/**
1869 * returns whether boundaryPoint is right edge or not.
1870 *
1871 * @param {BoundaryPoint} point
1872 * @return {Boolean}
1873 */
1874function isRightEdgePoint(point) {
1875    return point.offset === nodeLength(point.node);
1876}
1877/**
1878 * returns whether boundaryPoint is edge or not.
1879 *
1880 * @param {BoundaryPoint} point
1881 * @return {Boolean}
1882 */
1883function isEdgePoint(point) {
1884    return isLeftEdgePoint(point) || isRightEdgePoint(point);
1885}
1886/**
1887 * returns whether node is left edge of ancestor or not.
1888 *
1889 * @param {Node} node
1890 * @param {Node} ancestor
1891 * @return {Boolean}
1892 */
1893function isLeftEdgeOf(node, ancestor) {
1894    while (node && node !== ancestor) {
1895        if (position(node) !== 0) {
1896            return false;
1897        }
1898        node = node.parentNode;
1899    }
1900    return true;
1901}
1902/**
1903 * returns whether node is right edge of ancestor or not.
1904 *
1905 * @param {Node} node
1906 * @param {Node} ancestor
1907 * @return {Boolean}
1908 */
1909function isRightEdgeOf(node, ancestor) {
1910    if (!ancestor) {
1911        return false;
1912    }
1913    while (node && node !== ancestor) {
1914        if (position(node) !== nodeLength(node.parentNode) - 1) {
1915            return false;
1916        }
1917        node = node.parentNode;
1918    }
1919    return true;
1920}
1921/**
1922 * returns whether point is left edge of ancestor or not.
1923 * @param {BoundaryPoint} point
1924 * @param {Node} ancestor
1925 * @return {Boolean}
1926 */

1927function isLeftEdgePointOf(point, ancestor) {
1928    return isLeftEdgePoint(point) && isLeftEdgeOf(point.node, ancestor);
1929}
1930/**
1931 * returns whether point is right edge of ancestor or not.
1932 * @param {BoundaryPoint} point
1933 * @param {Node} ancestor
1934 * @return {Boolean}
1935 */
1936function isRightEdgePointOf(point, ancestor) {
1937    return isRightEdgePoint(point) && isRightEdgeOf(point.node, ancestor);
1938}
1939/**
1940 * returns offset from parent.
1941 *
1942 * @param {Node} node
1943 */
1944function position(node) {
1945    var offset = 0;
1946    while ((node = node.previousSibling)) {
1947        offset += 1;
1948    }
1949    return offset;
1950}
1951function hasChildren(node) {
1952    return !!(node && node.childNodes && node.childNodes.length);
1953}
1954/**
1955 * returns previous boundaryPoint
1956 *
1957 * @param {BoundaryPoint} point
1958 * @param {Boolean} isSkipInnerOffset
1959 * @return {BoundaryPoint}
1960 */
1961function prevPoint(point, isSkipInnerOffset) {
1962    var node;
1963    var offset;
1964    if (point.offset === 0) {
1965        if (isEditable(point.node)) {
1966            return null;
1967        }
1968        node = point.node.parentNode;
1969        offset = position(point.node);
1970    }
1971    else if (hasChildren(point.node)) {
1972        node = point.node.childNodes[point.offset - 1];
1973        offset = nodeLength(node);
1974    }
1975    else {
1976        node = point.node;
1977        offset = isSkipInnerOffset ? 0 : point.offset - 1;
1978    }
1979    return {
1980        node: node,
1981        offset: offset
1982    };
1983}
1984/**
1985 * returns next boundaryPoint
1986 *
1987 * @param {BoundaryPoint} point
1988 * @param {Boolean} isSkipInnerOffset
1989 * @return {BoundaryPoint}
1990 */
1991function nextPoint(point, isSkipInnerOffset) {
1992    var node, offset;
1993    if (nodeLength(point.node) === point.offset) {
1994        if (isEditable(point.node)) {
1995            return null;
1996        }
1997        node = point.node.parentNode;
1998        offset = position(point.node) + 1;
1999    }
2000    else if (hasChildren(point.node)) {
2001        node = point.node.childNodes[point.offset];
2002        offset = 0;
2003    }
2004    else {
2005        node = point.node;
2006        offset = isSkipInnerOffset ? nodeLength(point.node) : point.offset + 1;
2007    }
2008    return {
2009        node: node,
2010        offset: offset
2011    };
2012}
2013/**
2014 * returns whether pointA and pointB is same or not.
2015 *
2016 * @param {BoundaryPoint} pointA
2017 * @param {BoundaryPoint} pointB
2018 * @return {Boolean}
2019 */
2020function isSamePoint(pointA, pointB) {
2021    return pointA.node === pointB.node && pointA.offset === pointB.offset;
2022}
2023/**
2024 * returns whether point is visible (can set cursor) or not.
2025 *
2026 * @param {BoundaryPoint} point
2027 * @return {Boolean}
2028 */
2029function isVisiblePoint(point) {
2030    if (isText(point.node) || !hasChildren(point.node) || isEmpty$1(point.node)) {
2031        return true;
2032    }
2033    var leftNode = point.node.childNodes[point.offset - 1];
2034    var rightNode = point.node.childNodes[point.offset];
2035    if ((!leftNode || isVoid(leftNode)) && (!rightNode || isVoid(rightNode))) {
2036        return true;
2037    }
2038    return false;
2039}
2040/**
2041 * @method prevPointUtil
2042 *
2043 * @param {BoundaryPoint} point
2044 * @param {Function} pred
2045 * @return {BoundaryPoint}
2046 */
2047function prevPointUntil(point, pred) {
2048    while (point) {
2049        if (pred(point)) {
2050            return point;
2051        }
2052        point = prevPoint(point);
2053    }
2054    return null;
2055}
2056/**
2057 * @method nextPointUntil
2058 *
2059 * @param {BoundaryPoint} point
2060 * @param {Function} pred
2061 * @return {BoundaryPoint}
2062 */
2063function nextPointUntil(point, pred) {
2064    while (point) {
2065        if (pred(point)) {
2066            return point;
2067        }
2068        point = nextPoint(point);
2069    }
2070    return null;
2071}
2072/**
2073 * returns whether point has character or not.
2074 *
2075 * @param {Point} point
2076 * @return {Boolean}
2077 */
2078function isCharPoint(point) {
2079    if (!isText(point.node)) {
2080        return false;
2081    }
2082    var ch = point.node.nodeValue.charAt(point.offset - 1);
2083    return ch && (ch !== ' ' && ch !== NBSP_CHAR);
2084}
2085/**
2086 * @method walkPoint
2087 *
2088 * @param {BoundaryPoint} startPoint
2089 * @param {BoundaryPoint} endPoint
2090 * @param {Function} handler
2091 * @param {Boolean} isSkipInnerOffset
2092 */
2093function walkPoint(startPoint, endPoint, handler, isSkipInnerOffset) {
2094    var point = startPoint;
2095    while (point) {
2096        handler(point);
2097        if (isSamePoint(point, endPoint)) {
2098            break;
2099        }
2100        var isSkipOffset = isSkipInnerOffset &&
2101            startPoint.node !== point.node &&
2102            endPoint.node !== point.node;
2103        point = nextPoint(point, isSkipOffset);
2104    }
2105}
2106/**
2107 * @method makeOffsetPath
2108 *
2109 * return offsetPath(array of offset) from ancestor
2110 *
2111 * @param {Node} ancestor - ancestor node
2112 * @param {Node} node
2113 */
2114function makeOffsetPath(ancestor, node) {
2115    var ancestors = listAncestor(node, func.eq(ancestor));
2116    return ancestors.map(position).reverse();
2117}
2118/**
2119 * @method fromOffsetPath
2120 *
2121 * return element from offsetPath(array of offset)
2122 *
2123 * @param {Node} ancestor - ancestor node
2124 * @param {array} offsets - offsetPath
2125 */
2126function fromOffsetPath(ancestor, offsets) {
2127    var current = ancestor;
2128    for (var i = 0, len = offsets.length; i < len; i++) {
2129        if (current.childNodes.length <= offsets[i]) {
2130            current = current.childNodes[current.childNodes.length - 1];
2131        }
2132        else {
2133            current = current.childNodes[offsets[i]];
2134        }
2135    }
2136    return current;
2137}
2138/**
2139 * @method splitNode
2140 *
2141 * split element or #text
2142 *
2143 * @param {BoundaryPoint} point
2144 * @param {Object} [options]
2145 * @param {Boolean} [options.isSkipPaddingBlankHTML] - default: false
2146 * @param {Boolean} [options.isNotSplitEdgePoint] - default: false
2147 * @return {Node} right node of boundaryPoint
2148 */
2149function splitNode(point, options) {
2150    var isSkipPaddingBlankHTML = options && options.isSkipPaddingBlankHTML;
2151    var isNotSplitEdgePoint = options && options.isNotSplitEdgePoint;
2152    // edge case
2153    if (isEdgePoint(point) && (isText(point.node) || isNotSplitEdgePoint)) {
2154        if (isLeftEdgePoint(point)) {
2155            return point.node;
2156        }
2157        else if (isRightEdgePoint(point)) {
2158            return point.node.nextSibling;
2159        }
2160    }
2161    // split #text
2162    if (isText(point.node)) {
2163        return point.node.splitText(point.offset);
2164    }
2165    else {
2166        var childNode = point.node.childNodes[point.offset];
2167        var clone = insertAfter(point.node.cloneNode(false), point.node);
2168        appendChildNodes(clone, listNext(childNode));
2169        if (!isSkipPaddingBlankHTML) {
2170            paddingBlankHTML(point.node);
2171            paddingBlankHTML(clone);
2172        }
2173        return clone;
2174    }
2175}
2176/**
2177 * @method splitTree
2178 *
2179 * split tree by point
2180 *
2181 * @param {Node} root - split root
2182 * @param {BoundaryPoint} point
2183 * @param {Object} [options]
2184 * @param {Boolean} [options.isSkipPaddingBlankHTML] - default: false
2185 * @param {Boolean} [options.isNotSplitEdgePoint] - default: false
2186 * @return {Node} right node of boundaryPoint
2187 */
2188function splitTree(root, point, options) {
2189    // ex) [#text, <span>, <p>]
2190    var ancestors = listAncestor(point.node, func.eq(root));
2191    if (!ancestors.length) {
2192        return null;
2193    }
2194    else if (ancestors.length === 1) {
2195        return splitNode(point, options);
2196    }
2197    return ancestors.reduce(function (node, parent) {
2198        if (node === point.node) {
2199            node = splitNode(point, options);
2200        }
2201        return splitNode({
2202            node: parent,
2203            offset: node ? position(node) : nodeLength(parent)
2204        }, options);
2205    });
2206}
2207/**
2208 * split point
2209 *
2210 * @param {Point} point
2211 * @param {Boolean} isInline
2212 * @return {Object}
2213 */
2214function splitPoint(point, isInline) {
2215    // find splitRoot, container
2216    //  - inline: splitRoot is a child of paragraph
2217    //  - block: splitRoot is a child of bodyContainer
2218    var pred = isInline ? isPara : isBodyContainer;
2219    var ancestors = listAncestor(point.node, pred);
2220    var topAncestor = lists.last(ancestors) || point.node;
2221    var splitRoot, container;
2222    if (pred(topAncestor)) {
2223        splitRoot = ancestors[ancestors.length - 2];
2224        container = topAncestor;
2225    }
2226    else {
2227        splitRoot = topAncestor;
2228        container = splitRoot.parentNode;
2229    }
2230    // if splitRoot is exists, split with splitTree
2231    var pivot = splitRoot && splitTree(splitRoot, point, {
2232        isSkipPaddingBlankHTML: isInline,
2233        isNotSplitEdgePoint: isInline
2234    });
2235    // if container is point.node, find pivot with point.offset
2236    if (!pivot && container === point.node) {
2237        pivot = point.node.childNodes[point.offset];
2238    }
2239    return {
2240        rightNode: pivot,
2241        container: container
2242    };
2243}
2244function create(nodeName) {
2245    return document.createElement(nodeName);
2246}
2247function createText(text) {
2248    return document.createTextNode(text);
2249}
2250/**
2251 * @method remove
2252 *
2253 * remove node, (isRemoveChild: remove child or not)
2254 *
2255 * @param {Node} node
2256 * @param {Boolean} isRemoveChild
2257 */
2258function remove(node, isRemoveChild) {
2259    if (!node || !node.parentNode) {
2260        return;
2261    }
2262    if (node.removeNode) {
2263        return node.removeNode(isRemoveChild);
2264    }
2265    var parent = node.parentNode;
2266    if (!isRemoveChild) {
2267        var nodes = [];
2268        for (var i = 0, len = node.childNodes.length; i < len; i++) {
2269            nodes.push(node.childNodes[i]);
2270        }
2271        for (var i = 0, len = nodes.length; i < len; i++) {
2272            parent.insertBefore(nodes[i], node);
2273        }
2274    }
2275    parent.removeChild(node);
2276}
2277/**
2278 * @method removeWhile
2279 *
2280 * @param {Node} node
2281 * @param {Function} pred
2282 */
2283function removeWhile(node, pred) {
2284    while (node) {
2285        if (isEditable(node) || !pred(node)) {
2286            break;
2287        }
2288        var parent = node.parentNode;
2289        remove(node);
2290        node = parent;
2291    }
2292}
2293/**
2294 * @method replace
2295 *
2296 * replace node with provided nodeName
2297 *
2298 * @param {Node} node
2299 * @param {String} nodeName
2300 * @return {Node} - new node
2301 */
2302function replace(node, nodeName) {
2303    if (node.nodeName.toUpperCase() === nodeName.toUpperCase()) {
2304        return node;
2305    }
2306    var newNode = create(nodeName);
2307    if (node.style.cssText) {
2308        newNode.style.cssText = node.style.cssText;
2309    }
2310    appendChildNodes(newNode, lists.from(node.childNodes));
2311    insertAfter(newNode, node);
2312    remove(node);
2313    return newNode;
2314}
2315var isTextarea = makePredByNodeName('TEXTAREA');
2316/**
2317 * @param {jQuery} $node
2318 * @param {Boolean} [stripLinebreaks] - default: false
2319 */
2320function value($node, stripLinebreaks) {
2321    var val = isTextarea($node[0]) ? $node.val() : $node.html();
2322    if (stripLinebreaks) {
2323        return val.replace(/[\n\r]/g, '');
2324    }
2325    return val;
2326}
2327/**
2328 * @method html
2329 *
2330 * get the HTML contents of node
2331 *
2332 * @param {jQuery} $node
2333 * @param {Boolean} [isNewlineOnBlock]
2334 */
2335function html($node, isNewlineOnBlock) {
2336    var markup = value($node);
2337    if (isNewlineOnBlock) {
2338        var regexTag = /<(\/?)(\b(?!!)[^>\s]*)(.*?)(\s*\/?>)/g;
2339        markup = markup.replace(regexTag, function (match, endSlash, name) {
2340            name = name.toUpperCase();
2341            var isEndOfInlineContainer = /^DIV|^TD|^TH|^P|^LI|^H[1-7]/.test(name) &&
2342                !!endSlash;
2343            var isBlockNode = /^BLOCKQUOTE|^TABLE|^TBODY|^TR|^HR|^UL|^OL/.test(name);
2344            return match + ((isEndOfInlineContainer || isBlockNode) ? '\n' : '');
2345        });
2346        markup = $$1.trim(markup);
2347    }
2348    return markup;
2349}
2350function posFromPlaceholder(placeholder) {
2351    var $placeholder = $$1(placeholder);
2352    var pos = $placeholder.offset();
2353    var height = $placeholder.outerHeight(true); // include margin
2354    return {
2355        left: pos.left,
2356        top: pos.top + height
2357    };
2358}
2359function attachEvents($node, events) {

2360    Object.keys(events).forEach(function (key) {
2361        $node.on(key, events[key]);
2362    });
2363}
2364function detachEvents($node, events) {
2365    Object.keys(events).forEach(function (key) {
2366        $node.off(key, events[key]);
2367    });
2368}
2369/**
2370 * @method isCustomStyleTag
2371 *
2372 * assert if a node contains a "note-styletag" class,
2373 * which implies that's a custom-made style tag node
2374 *
2375 * @param {Node} an HTML DOM node
2376 */
2377function isCustomStyleTag(node) {
2378    return node && !isText(node) && lists.contains(node.classList, 'note-styletag');
2379}
2380var dom = {
2381    /** @property {String} NBSP_CHAR */
2382    NBSP_CHAR: NBSP_CHAR,
2383    /** @property {String} ZERO_WIDTH_NBSP_CHAR */
2384    ZERO_WIDTH_NBSP_CHAR: ZERO_WIDTH_NBSP_CHAR,
2385    /** @property {String} blank */
2386    blank: blankHTML,
2387    /** @property {String} emptyPara */
2388    emptyPara: "<p>" + blankHTML + "</p>",
2389    makePredByNodeName: makePredByNodeName,
2390    isEditable: isEditable,
2391    isControlSizing: isControlSizing,
2392    isText: isText,
2393    isElement: isElement,
2394    isVoid: isVoid,
2395    isPara: isPara,
2396    isPurePara: isPurePara,
2397    isHeading: isHeading,
2398    isInline: isInline,
2399    isBlock: func.not(isInline),
2400    isBodyInline: isBodyInline,
2401    isBody: isBody,
2402    isParaInline: isParaInline,
2403    isPre: isPre,
2404    isList: isList,
2405    isTable: isTable,
2406    isData: isData,
2407    isCell: isCell,
2408    isBlockquote: isBlockquote,
2409    isBodyContainer: isBodyContainer,
2410    isAnchor: isAnchor,
2411    isDiv: makePredByNodeName('DIV'),
2412    isLi: isLi,
2413    isBR: makePredByNodeName('BR'),
2414    isSpan: makePredByNodeName('SPAN'),
2415    isB: makePredByNodeName('B'),
2416    isU: makePredByNodeName('U'),
2417    isS: makePredByNodeName('S'),
2418    isI: makePredByNodeName('I'),
2419    isImg: makePredByNodeName('IMG'),
2420    isTextarea: isTextarea,
2421    isEmpty: isEmpty$1,
2422    isEmptyAnchor: func.and(isAnchor, isEmpty$1),
2423    isClosestSibling: isClosestSibling,
2424    withClosestSiblings: withClosestSiblings,
2425    nodeLength: nodeLength,
2426    isLeftEdgePoint: isLeftEdgePoint,
2427    isRightEdgePoint: isRightEdgePoint,
2428    isEdgePoint: isEdgePoint,
2429    isLeftEdgeOf: isLeftEdgeOf,
2430    isRightEdgeOf: isRightEdgeOf,
2431    isLeftEdgePointOf: isLeftEdgePointOf,
2432    isRightEdgePointOf: isRightEdgePointOf,
2433    prevPoint: prevPoint,
2434    nextPoint: nextPoint,
2435    isSamePoint: isSamePoint,
2436    isVisiblePoint: isVisiblePoint,
2437    prevPointUntil: prevPointUntil,
2438    nextPointUntil: nextPointUntil,
2439    isCharPoint: isCharPoint,
2440    walkPoint: walkPoint,
2441    ancestor: ancestor,
2442    singleChildAncestor: singleChildAncestor,
2443    listAncestor: listAncestor,
2444    lastAncestor: lastAncestor,
2445    listNext: listNext,
2446    listPrev: listPrev,
2447    listDescendant: listDescendant,
2448    commonAncestor: commonAncestor,
2449    wrap: wrap,
2450    insertAfter: insertAfter,
2451    appendChildNodes: appendChildNodes,
2452    position: position,
2453    hasChildren: hasChildren,
2454    makeOffsetPath: makeOffsetPath,
2455    fromOffsetPath: fromOffsetPath,
2456    splitTree: splitTree,
2457    splitPoint: splitPoint,
2458    create: create,
2459    createText: createText,
2460    remove: remove,
2461    removeWhile: removeWhile,
2462    replace: replace,
2463    html: html,
2464    value: value,
2465    posFromPlaceholder: posFromPlaceholder,
2466    attachEvents: attachEvents,
2467    detachEvents: detachEvents,
2468    isCustomStyleTag: isCustomStyleTag
2469};
2470
2471/**
2472 * return boundaryPoint from TextRange, inspired by Andy Na's HuskyRange.js
2473 *
2474 * @param {TextRange} textRange
2475 * @param {Boolean} isStart
2476 * @return {BoundaryPoint}
2477 *
2478 * @see http://msdn.microsoft.com/en-us/library/ie/ms535872(v=vs.85).aspx
2479 */
2480function textRangeToPoint(textRange, isStart) {
2481    var container = textRange.parentElement();
2482    var offset;
2483    var tester = document.body.createTextRange();
2484    var prevContainer;
2485    var childNodes = lists.from(container.childNodes);
2486    for (offset = 0; offset < childNodes.length; offset++) {
2487        if (dom.isText(childNodes[offset])) {
2488            continue;
2489        }
2490        tester.moveToElementText(childNodes[offset]);
2491        if (tester.compareEndPoints('StartToStart', textRange) >= 0) {
2492            break;
2493        }
2494        prevContainer = childNodes[offset];
2495    }
2496    if (offset !== 0 && dom.isText(childNodes[offset - 1])) {
2497        var textRangeStart = document.body.createTextRange();
2498        var curTextNode = null;
2499        textRangeStart.moveToElementText(prevContainer || container);
2500        textRangeStart.collapse(!prevContainer);
2501        curTextNode = prevContainer ? prevContainer.nextSibling : container.firstChild;
2502        var pointTester = textRange.duplicate();
2503        pointTester.setEndPoint('StartToStart', textRangeStart);
2504        var textCount = pointTester.text.replace(/[\r\n]/g, '').length;
2505        while (textCount > curTextNode.nodeValue.length && curTextNode.nextSibling) {
2506            textCount -= curTextNode.nodeValue.length;
2507            curTextNode = curTextNode.nextSibling;
2508        }
2509        // [workaround] enforce IE to re-reference curTextNode, hack
2510        var dummy = curTextNode.nodeValue; // eslint-disable-line
2511        if (isStart && curTextNode.nextSibling && dom.isText(curTextNode.nextSibling) &&
2512            textCount === curTextNode.nodeValue.length) {
2513            textCount -= curTextNode.nodeValue.length;
2514            curTextNode = curTextNode.nextSibling;
2515        }
2516        container = curTextNode;
2517        offset = textCount;
2518    }
2519    return {
2520        cont: container,
2521        offset: offset
2522    };
2523}
2524/**
2525 * return TextRange from boundary point (inspired by google closure-library)
2526 * @param {BoundaryPoint} point
2527 * @return {TextRange}
2528 */
2529function pointToTextRange(point) {
2530    var textRangeInfo = function (container, offset) {
2531        var node, isCollapseToStart;
2532        if (dom.isText(container)) {
2533            var prevTextNodes = dom.listPrev(container, func.not(dom.isText));
2534            var prevContainer = lists.last(prevTextNodes).previousSibling;
2535            node = prevContainer || container.parentNode;
2536            offset += lists.sum(lists.tail(prevTextNodes), dom.nodeLength);
2537            isCollapseToStart = !prevContainer;
2538        }
2539        else {
2540            node = container.childNodes[offset] || container;
2541            if (dom.isText(node)) {
2542                return textRangeInfo(node, 0);
2543            }
2544            offset = 0;
2545            isCollapseToStart = false;
2546        }
2547        return {
2548            node: node,
2549            collapseToStart: isCollapseToStart,
2550            offset: offset
2551        };
2552    };
2553    var textRange = document.body.createTextRange();
2554    var info = textRangeInfo(point.node, point.offset);
2555    textRange.moveToElementText(info.node);
2556    textRange.collapse(info.collapseToStart);
2557    textRange.moveStart('character', info.offset);
2558    return textRange;
2559}
2560/**
2561   * Wrapped Range
2562   *
2563   * @constructor
2564   * @param {Node} sc - start container
2565   * @param {Number} so - start offset
2566   * @param {Node} ec - end container
2567   * @param {Number} eo - end offset
2568   */
2569var WrappedRange = /** @class */ (function () {
2570    function WrappedRange(sc, so, ec, eo) {
2571        this.sc = sc;
2572        this.so = so;
2573        this.ec = ec;
2574        this.eo = eo;
2575        // isOnEditable: judge whether range is on editable or not
2576        this.isOnEditable = this.makeIsOn(dom.isEditable);
2577        // isOnList: judge whether range is on list node or not
2578        this.isOnList = this.makeIsOn(dom.isList);
2579        // isOnAnchor: judge whether range is on anchor node or not
2580        this.isOnAnchor = this.makeIsOn(dom.isAnchor);
2581        // isOnCell: judge whether range is on cell node or not
2582        this.isOnCell = this.makeIsOn(dom.isCell);
2583        // isOnData: judge whether range is on data node or not
2584        this.isOnData = this.makeIsOn(dom.isData);
2585    }
2586    // nativeRange: get nativeRange from sc, so, ec, eo
2587    WrappedRange.prototype.nativeRange = function () {
2588        if (env.isW3CRangeSupport) {
2589            var w3cRange = document.createRange();
2590            w3cRange.setStart(this.sc, this.so);
2591            w3cRange.setEnd(this.ec, this.eo);
2592            return w3cRange;
2593        }
2594        else {
2595            var textRange = pointToTextRange({
2596                node: this.sc,
2597                offset: this.so
2598            });
2599            textRange.setEndPoint('EndToEnd', pointToTextRange({
2600                node: this.ec,
2601                offset: this.eo
2602            }));
2603            return textRange;
2604        }
2605    };
2606    WrappedRange.prototype.getPoints = function () {
2607        return {
2608            sc: this.sc,
2609            so: this.so,
2610            ec: this.ec,
2611            eo: this.eo
2612        };
2613    };
2614    WrappedRange.prototype.getStartPoint = function () {
2615        return {
2616            node: this.sc,
2617            offset: this.so
2618        };
2619    };
2620    WrappedRange.prototype.getEndPoint = function () {
2621        return {
2622            node: this.ec,
2623            offset: this.eo
2624        };
2625    };
2626    /**
2627     * select update visible range
2628     */
2629    WrappedRange.prototype.select = function () {
2630        var nativeRng = this.nativeRange();
2631        if (env.isW3CRangeSupport) {
2632            var selection = document.getSelection();
2633            if (selection.rangeCount > 0) {
2634                selection.removeAllRanges();
2635            }
2636            selection.addRange(nativeRng);
2637        }
2638        else {
2639            nativeRng.select();
2640        }
2641        return this;
2642    };
2643    /**
2644     * Moves the scrollbar to start container(sc) of current range
2645     *
2646     * @return {WrappedRange}
2647     */
2648    WrappedRange.prototype.scrollIntoView = function (container) {
2649        var height = $$1(container).height();
2650        if (container.scrollTop + height < this.sc.offsetTop) {
2651            container.scrollTop += Math.abs(container.scrollTop + height - this.sc.offsetTop);
2652        }
2653        return this;
2654    };
2655    /**
2656     * @return {WrappedRange}
2657     */
2658    WrappedRange.prototype.normalize = function () {
2659        /**
2660         * @param {BoundaryPoint} point
2661         * @param {Boolean} isLeftToRight
2662         * @return {BoundaryPoint}
2663         */
2664        var getVisiblePoint = function (point, isLeftToRight) {
2665            if ((dom.isVisiblePoint(point) && !dom.isEdgePoint(point)) ||
2666                (dom.isVisiblePoint(point) && dom.isRightEdgePoint(point) && !isLeftToRight) ||
2667                (dom.isVisiblePoint(point) && dom.isLeftEdgePoint(point) && isLeftToRight) ||
2668                (dom.isVisiblePoint(point) && dom.isBlock(point.node) && dom.isEmpty(point.node))) {
2669                return point;
2670            }
2671            // point on block's edge
2672            var block = dom.ancestor(point.node, dom.isBlock);
2673            if (((dom.isLeftEdgePointOf(point, block) || dom.isVoid(dom.prevPoint(point).node)) && !isLeftToRight) ||
2674                ((dom.isRightEdgePointOf(point, block) || dom.isVoid(dom.nextPoint(point).node)) && isLeftToRight)) {
2675                // returns point already on visible point
2676                if (dom.isVisiblePoint(point)) {
2677                    return point;
2678                }
2679                // reverse direction
2680                isLeftToRight = !isLeftToRight;
2681            }
2682            var nextPoint = isLeftToRight ? dom.nextPointUntil(dom.nextPoint(point), dom.isVisiblePoint)
2683                : dom.prevPointUntil(dom.prevPoint(point), dom.isVisiblePoint);
2684            return nextPoint || point;
2685        };
2686        var endPoint = getVisiblePoint(this.getEndPoint(), false);
2687        var startPoint = this.isCollapsed() ? endPoint : getVisiblePoint(this.getStartPoint(), true);
2688        return new WrappedRange(startPoint.node, startPoint.offset, endPoint.node, endPoint.offset);
2689    };
2690    /**
2691     * returns matched nodes on range
2692     *
2693     * @param {Function} [pred] - predicate function
2694     * @param {Object} [options]
2695     * @param {Boolean} [options.includeAncestor]
2696     * @param {Boolean} [options.fullyContains]
2697     * @return {Node[]}
2698     */
2699    WrappedRange.prototype.nodes = function (pred, options) {
2700        pred = pred || func.ok;
2701        var includeAncestor = options && options.includeAncestor;
2702        var fullyContains = options && options.fullyContains;
2703        // TODO compare points and sort
2704        var startPoint = this.getStartPoint();
2705        var endPoint = this.getEndPoint();
2706        var nodes = [];
2707        var leftEdgeNodes = [];
2708        dom.walkPoint(startPoint, endPoint, function (point) {
2709            if (dom.isEditable(point.node)) {
2710                return;
2711            }
2712            var node;
2713            if (fullyContains) {
2714                if (dom.isLeftEdgePoint(point)) {
2715                    leftEdgeNodes.push(point.node);
2716                }
2717                if (dom.isRightEdgePoint(point) && lists.contains(leftEdgeNodes, point.node)) {
2718                    node = point.node;
2719                }
2720            }
2721            else if (includeAncestor) {
2722                node = dom.ancestor(point.node, pred);
2723            }
2724            else {
2725                node = point.node;
2726            }
2727            if (node && pred(node)) {
2728                nodes.push(node);
2729            }
2730        }, true);
2731        return lists.unique(nodes);
2732    };
2733    /**
2734     * returns commonAncestor of range
2735     * @return {Element} - commonAncestor
2736     */
2737    WrappedRange.prototype.commonAncestor = function () {
2738        return dom.commonAncestor(this.sc, this.ec);
2739    };
2740    /**
2741     * returns expanded range by pred
2742     *
2743     * @param {Function} pred - predicate function
2744     * @return {WrappedRange}
2745     */
2746    WrappedRange.prototype.expand = function (pred) {
2747        var startAncestor = dom.ancestor(this.sc, pred);
2748        var endAncestor = dom.ancestor(this.ec, pred);
2749        if (!startAncestor && !endAncestor) {
2750            return new WrappedRange(this.sc, this.so, this.ec, this.eo);
2751        }
2752        var boundaryPoints = this.getPoints();
2753        if (startAncestor) {
2754            boundaryPoints.sc = startAncestor;
2755            boundaryPoints.so = 0;
2756        }
2757        if (endAncestor) {
2758            boundaryPoints.ec = endAncestor;
2759            boundaryPoints.eo = dom.nodeLength(endAncestor);
2760        }
2761        return new WrappedRange(boundaryPoints.sc, boundaryPoints.so, boundaryPoints.ec, boundaryPoints.eo);
2762    };
2763    /**
2764     * @param {Boolean} isCollapseToStart
2765     * @return {WrappedRange}
2766     */
2767    WrappedRange.prototype.collapse = function (isCollapseToStart) {
2768        if (isCollapseToStart) {
2769            return new WrappedRange(this.sc, this.so, this.sc, this.so);
2770        }
2771        else {
2772            return new WrappedRange(this.ec, this.eo, this.ec, this.eo);
2773        }
2774    };
2775    /**
2776     * splitText on range
2777     */
2778    WrappedRange.prototype.splitText = function () {
2779        var isSameContainer = this.sc === this.ec;
2780        var boundaryPoints = this.getPoints();
2781        if (dom.isText(this.ec) && !dom.isEdgePoint(this.getEndPoint())) {
2782            this.ec.splitText(this.eo);
2783        }
2784        if (dom.isText(this.sc) && !dom.isEdgePoint(this.getStartPoint())) {
2785            boundaryPoints.sc = this.sc.splitText(this.so);
2786            boundaryPoints.so = 0;
2787            if (isSameContainer) {
2788                boundaryPoints.ec = boundaryPoints.sc;
2789                boundaryPoints.eo = this.eo - this.so;
2790            }
2791        }
2792        return new WrappedRange(boundaryPoints.sc, boundaryPoints.so, boundaryPoints.ec, boundaryPoints.eo);
2793    };
2794    /**
2795     * delete contents on range
2796     * @return {WrappedRange}
2797     */
2798    WrappedRange.prototype.deleteContents = function () {
2799        if (this.isCollapsed()) {
2800            return this;
2801        }
2802        var rng = this.splitText();
2803        var nodes = rng.nodes(null, {
2804            fullyContains: true
2805        });
2806        // find new cursor point
2807        var point = dom.prevPointUntil(rng.getStartPoint(), function (point) {
2808            return !lists.contains(nodes, point.node);
2809        });
2810        var emptyParents = [];
2811        $$1.each(nodes, function (idx, node) {
2812            // find empty parents
2813            var parent = node.parentNode;
2814            if (point.node !== parent && dom.nodeLength(parent) === 1) {
2815                emptyParents.push(parent);
2816            }
2817            dom.remove(node, false);
2818        });
2819        // remove empty parents
2820        $$1.each(emptyParents, function (idx, node) {
2821            dom.remove(node, false);
2822        });
2823        return new WrappedRange(point.node, point.offset, point.node, point.offset).normalize();
2824    };
2825    /**
2826     * makeIsOn: return isOn(pred) function
2827     */
2828    WrappedRange.prototype.makeIsOn = function (pred) {
2829        return function () {
2830            var ancestor = dom.ancestor(this.sc, pred);
2831            return !!ancestor && (ancestor === dom.ancestor(this.ec, pred));
2832        };
2833    };
2834    /**
2835     * @param {Function} pred
2836     * @return {Boolean}
2837     */
2838    WrappedRange.prototype.isLeftEdgeOf = function (pred) {
2839        if (!dom.isLeftEdgePoint(this.getStartPoint())) {
2840            return false;
2841        }
2842        var node = dom.ancestor(this.sc, pred);
2843        return node && dom.isLeftEdgeOf(this.sc, node);
2844    };
2845    /**
2846     * returns whether range was collapsed or not
2847     */
2848    WrappedRange.prototype.isCollapsed = function () {
2849        return this.sc === this.ec && this.so === this.eo;
2850    };
2851    /**
2852     * wrap inline nodes which children of body with paragraph
2853     *
2854     * @return {WrappedRange}
2855     */
2856    WrappedRange.prototype.wrapBodyInlineWithPara = function () {
2857        if (dom.isBodyContainer(this.sc) && dom.isEmpty(this.sc)) {
2858            this.sc.innerHTML = dom.emptyPara;
2859            return new WrappedRange(this.sc.firstChild, 0, this.sc.firstChild, 0);
2860        }
2861        /**
2862         * [workaround] firefox often create range on not visible point. so normalize here.
2863         *  - firefox: |<p>text</p>|
2864         *  - chrome: <p>|text|</p>
2865         */
2866        var rng = this.normalize();
2867        if (dom.isParaInline(this.sc) || dom.isPara(this.sc)) {
2868            return rng;
2869        }
2870        // find inline top ancestor
2871        var topAncestor;
2872        if (dom.isInline(rng.sc)) {
2873            var ancestors = dom.listAncestor(rng.sc, func.not(dom.isInline));
2874            topAncestor = lists.last(ancestors);
2875            if (!dom.isInline(topAncestor)) {
2876                topAncestor = ancestors[ancestors.length - 2] || rng.sc.childNodes[rng.so];
2877            }
2878        }
2879        else {
2880            topAncestor = rng.sc.childNodes[rng.so > 0 ? rng.so - 1 : 0];
2881        }