var DOKU_BASE = '/';
var DOKU_TPL = '/lib/tpl/sprintdoc/';
var DOKU_COOKIE_PARAM = {
  "path": "\/",
  "secure": true
};
Object.defineProperty(window, 'DOKU_UHN', {
  get: function () {
    console.warn('Using DOKU_UHN is deprecated. Please use JSINFO.useHeadingNavigation instead');
    return JSINFO.useHeadingNavigation;
  }
});
Object.defineProperty(window, 'DOKU_UHC', {
  get: function () {
    console.warn('Using DOKU_UHC is deprecated. Please use JSINFO.useHeadingContent instead');
    return JSINFO.useHeadingContent;
  }
});
LANG = {
  "search_toggle_tools": "Suchwerkzeuge umschalten",
  "willexpire": "Die Sperre zur Bearbeitung dieser Seite l\u00e4uft in einer Minute ab.\\nUm Bearbeitungskonflikte zu vermeiden, solltest du sie durch einen Klick auf den Vorschau-Knopf verl\u00e4ngern.",
  "notsavedyet": "Nicht gespeicherte \u00c4nderungen gehen verloren!",
  "searchmedia": "Suche nach Dateien",
  "keepopen": "Fenster nach Auswahl nicht schlie\u00dfen",
  "hidedetails": "Details ausblenden",
  "mediatitle": "Link-Eigenschaften",
  "mediadisplay": "Linktyp",
  "mediaalign": "Ausrichtung",
  "mediasize": "Bildgr\u00f6\u00dfe",
  "mediatarget": "Linkziel",
  "mediaclose": "Schlie\u00dfen",
  "mediainsert": "Einf\u00fcgen",
  "mediadisplayimg": "Bild anzeigen",
  "mediadisplaylnk": "Nur den Link anzeigen",
  "mediasmall": "Bild in kleiner Aufl\u00f6sung",
  "mediamedium": "Bild in mittlerer Aufl\u00f6sung",
  "medialarge": "Bild in hoher Aufl\u00f6sung",
  "mediaoriginal": "Originalaufl\u00f6sung",
  "medialnk": "Link zur Detailseite",
  "mediadirect": "Direkter Link zum Original",
  "medianolnk": "Kein Link",
  "medianolink": "Bild nicht verlinken",
  "medialeft": "Bild linksb\u00fcndig ausrichten.",
  "mediaright": "Bild rechtsb\u00fcndig ausrichten.",
  "mediacenter": "Bild horizontal zentriert ausrichten",
  "medianoalign": "Bild ohne bestimmte Ausrichtung lassen",
  "nosmblinks": "Das Verlinken von Windows-Freigaben funktioniert nur im Microsoft Internet-Explorer.\\nDer Link kann jedoch zum Einf\u00fcgen kopiert werden.",
  "linkwiz": "Link-Assistent",
  "linkto": "Link zu:",
  "del_confirm": "Die ausgew\u00e4hlten Dateien wirklich l\u00f6schen?",
  "restore_confirm": "Wirklich diese Version wiederherstellen?",
  "media_diff": "Unterschiede anzeigen:",
  "media_diff_both": "Nebeneinander",
  "media_diff_opacity": "\u00dcberblenden",
  "media_diff_portions": "\u00dcbergang",
  "media_select": "Dateien ausw\u00e4hlen\u2026",
  "media_upload_btn": "Hochladen",
  "media_done_btn": "Fertig",
  "media_drop": "Dateien hier hinziehen um sie hochzuladen",
  "media_cancel": "Entfernen",
  "media_overwrt": "Existierende Dateien \u00fcberschreiben",
  "data_insecure": "WARNING: It seems your data directory is not properly secured. Please read about <a href=\"https:\/\/www.dokuwiki.org\/security#web_access_security\">Web Access Security in DokuWiki<\/a>.",
  "plugins": {
    "edittable": {
      "toggle_header": "Kopfzeile an\/aus",
      "align_left": "Links ausrichten",
      "align_center": "Mittig ausrichten",
      "align_right": "Rechts ausrichten",
      "confirmdeleterow": "Zeile wirklich l\u00f6schen?",
      "confirmdeletecol": "Spalte wirklich l\u00f6schen?",
      "row_above": "Zeile dar\u00fcber einf\u00fcgen",
      "remove_row": "Zeile entfernen",
      "row_below": "Zeile darunter einf\u00fcgen",
      "col_left": "Spalte links hinzuf\u00fcgen",
      "remove_col": "Spalte entfernen",
      "col_right": "Spalte rechts hinzuf\u00fcgen",
      "merge_cells": "Zellen verbinden",
      "unmerge_cells": "Zellen trennen"
    },
    "extension": {
      "reallydel": "M\u00f6chtest du diese Erweiterung wirklich deinstallieren",
      "display_viewoptions": "Einstellungen anzeigen:",
      "display_enabled": "aktiviert",
      "display_disabled": "deaktiviert",
      "display_updatable": "Update verf\u00fcgbar",
      "close": "Click to close",
      "filter": "Show updatable extensions only"
    },
    "logviewer": {
      "filter": "Protokolleintr\u00e4ge filtern"
    },
    "styling": {
      "loader": "Vorschau l\u00e4dt...<br \/>Falls diese Nachricht nicht verschwindet, k\u00f6nnten deine Werte fehlerhaft sein",
      "popup": "\u00d6ffne als Popup"
    }
  }
};
var toolbar = [{
  "type": "format",
  "title": "Fetter Text",
  "icon": "bold.png",
  "key": "b",
  "open": "**",
  "close": "**",
  "block": false
}, {
  "type": "format",
  "title": "Kursiver Text",
  "icon": "italic.png",
  "key": "i",
  "open": "\/\/",
  "close": "\/\/",
  "block": false
}, {
  "type": "format",
  "title": "Unterstrichener Text",
  "icon": "underline.png",
  "key": "u",
  "open": "__",
  "close": "__",
  "block": false
}, {
  "type": "format",
  "title": "Code Text",
  "icon": "mono.png",
  "key": "m",
  "open": "''",
  "close": "''",
  "block": false
}, {
  "type": "format",
  "title": "Durchgestrichener Text",
  "icon": "strike.png",
  "key": "d",
  "open": "<del>",
  "close": "<\/del>",
  "block": false
}, {
  "type": "autohead",
  "title": "\u00dcberschrift auf selber Ebene",
  "icon": "hequal.png",
  "key": "8",
  "text": "\u00dcberschrift",
  "mod": 0,
  "block": true
}, {
  "type": "autohead",
  "title": "\u00dcberschrift eine Ebene runter",
  "icon": "hminus.png",
  "key": "9",
  "text": "\u00dcberschrift",
  "mod": 1,
  "block": true
}, {
  "type": "autohead",
  "title": "\u00dcberschrift eine Ebene h\u00f6her",
  "icon": "hplus.png",
  "key": "0",
  "text": "\u00dcberschrift",
  "mod": -1,
  "block": true
}, {
  "type": "picker",
  "title": "W\u00e4hle eine \u00dcberschrift",
  "icon": "h.png",
  "class": "pk_hl",
  "list": [{
    "type": "format",
    "title": "Level 1 \u00dcberschrift",
    "icon": "h1.png",
    "key": "1",
    "open": "====== ",
    "close": " ======\\n"
  }, {
    "type": "format",
    "title": "Level 2 \u00dcberschrift",
    "icon": "h2.png",
    "key": "2",
    "open": "===== ",
    "close": " =====\\n"
  }, {
    "type": "format",
    "title": "Level 3 \u00dcberschrift",
    "icon": "h3.png",
    "key": "3",
    "open": "==== ",
    "close": " ====\\n"
  }, {
    "type": "format",
    "title": "Level 4 \u00dcberschrift",
    "icon": "h4.png",
    "key": "4",
    "open": "=== ",
    "close": " ===\\n"
  }, {
    "type": "format",
    "title": "Level 5 \u00dcberschrift",
    "icon": "h5.png",
    "key": "5",
    "open": "== ",
    "close": " ==\\n"
  }],
  "block": true
}, {
  "type": "linkwiz",
  "title": "Interner Link",
  "icon": "link.png",
  "key": "l",
  "open": "[[",
  "close": "]]",
  "block": false
}, {
  "type": "format",
  "title": "Externer Link",
  "icon": "linkextern.png",
  "open": "[[",
  "close": "]]",
  "sample": "http:\/\/example.com|Externer Link",
  "block": false
}, {
  "type": "formatln",
  "title": "Nummerierter Listenpunkt",
  "icon": "ol.png",
  "open": "  - ",
  "close": "",
  "key": "-",
  "block": true
}, {
  "type": "formatln",
  "title": "Listenpunkt",
  "icon": "ul.png",
  "open": "  * ",
  "close": "",
  "key": ".",
  "block": true
}, {
  "type": "insert",
  "title": "Horizontale Linie",
  "icon": "hr.png",
  "insert": "\\n----\\n",
  "block": true
}, {
  "type": "mediapopup",
  "title": "Bilder und andere Dateien hinzuf\u00fcgen",
  "icon": "image.png",
  "url": "lib\/exe\/mediamanager.php?ns=",
  "name": "mediaselect",
  "options": "width=750,height=500,left=20,top=20,scrollbars=yes,resizable=yes",
  "block": false
}, {
  "type": "picker",
  "title": "Smileys",
  "icon": "smiley.png",
  "list": {
    "8-)": "cool.svg",
    "8-O": "eek.svg",
    "8-o": "eek.svg",
    ":-(": "sad.svg",
    ":-)": "smile.svg",
    "=)": "smile2.svg",
    ":-\/": "doubt.svg",
    ":-\\": "doubt2.svg",
    ":-?": "confused.svg",
    ":-D": "biggrin.svg",
    ":-P": "razz.svg",
    ":-o": "surprised.svg",
    ":-O": "surprised.svg",
    ":-x": "silenced.svg",
    ":-X": "silenced.svg",
    ":-|": "neutral.svg",
    ";-)": "wink.svg",
    "m(": "facepalm.svg",
    "^_^": "fun.svg",
    ":?:": "question.svg",
    ":!:": "exclaim.svg",
    "LOL": "lol.svg",
    "FIXME": "fixme.svg",
    "DELETEME": "deleteme.svg"
  },
  "icobase": "smileys",
  "block": false
}, {
  "type": "picker",
  "title": "Sonderzeichen",
  "icon": "chars.png",
  "list": ["\u00c0", "\u00e0", "\u00c1", "\u00e1", "\u00c2", "\u00e2", "\u00c3", "\u00e3", "\u00c4", "\u00e4", "\u01cd", "\u01ce", "\u0102", "\u0103", "\u00c5", "\u00e5", "\u0100", "\u0101", "\u0104", "\u0105", "\u00c6", "\u00e6", "\u0106", "\u0107", "\u00c7", "\u00e7", "\u010c", "\u010d", "\u0108", "\u0109", "\u010a", "\u010b", "\u00d0", "\u0111", "\u00f0", "\u010e", "\u010f", "\u00c8", "\u00e8", "\u00c9", "\u00e9", "\u00ca", "\u00ea", "\u00cb", "\u00eb", "\u011a", "\u011b", "\u0112", "\u0113", "\u0116", "\u0117", "\u0118", "\u0119", "\u0122", "\u0123", "\u011c", "\u011d", "\u011e", "\u011f", "\u0120", "\u0121", "\u0124", "\u0125", "\u00cc", "\u00ec", "\u00cd", "\u00ed", "\u00ce", "\u00ee", "\u00cf", "\u00ef", "\u01cf", "\u01d0", "\u012a", "\u012b", "\u0130", "\u0131", "\u012e", "\u012f", "\u0134", "\u0135", "\u0136", "\u0137", "\u0139", "\u013a", "\u013b", "\u013c", "\u013d", "\u013e", "\u0141", "\u0142", "\u013f", "\u0140", "\u0143", "\u0144", "\u00d1", "\u00f1", "\u0145", "\u0146", "\u0147", "\u0148", "\u00d2", "\u00f2", "\u00d3", "\u00f3", "\u00d4", "\u00f4", "\u00d5", "\u00f5", "\u00d6", "\u00f6", "\u01d1", "\u01d2", "\u014c", "\u014d", "\u0150", "\u0151", "\u0152", "\u0153", "\u00d8", "\u00f8", "\u0154", "\u0155", "\u0156", "\u0157", "\u0158", "\u0159", "\u015a", "\u015b", "\u015e", "\u015f", "\u0160", "\u0161", "\u015c", "\u015d", "\u0162", "\u0163", "\u0164", "\u0165", "\u00d9", "\u00f9", "\u00da", "\u00fa", "\u00db", "\u00fb", "\u00dc", "\u00fc", "\u01d3", "\u01d4", "\u016c", "\u016d", "\u016a", "\u016b", "\u016e", "\u016f", "\u01d6", "\u01d8", "\u01da", "\u01dc", "\u0172", "\u0173", "\u0170", "\u0171", "\u0174", "\u0175", "\u00dd", "\u00fd", "\u0178", "\u00ff", "\u0176", "\u0177", "\u0179", "\u017a", "\u017d", "\u017e", "\u017b", "\u017c", "\u00de", "\u00fe", "\u00df", "\u0126", "\u0127", "\u00bf", "\u00a1", "\u00a2", "\u00a3", "\u00a4", "\u00a5", "\u20ac", "\u00a6", "\u00a7", "\u00aa", "\u00ac", "\u00af", "\u00b0", "\u00b1", "\u00f7", "\u2030", "\u00bc", "\u00bd", "\u00be", "\u00b9", "\u00b2", "\u00b3", "\u00b5", "\u00b6", "\u2020", "\u2021", "\u00b7", "\u2022", "\u00ba", "\u2200", "\u2202", "\u2203", "\u018f", "\u0259", "\u2205", "\u2207", "\u2208", "\u2209", "\u220b", "\u220f", "\u2211", "\u203e", "\u2212", "\u2217", "\u00d7", "\u2044", "\u221a", "\u221d", "\u221e", "\u2220", "\u2227", "\u2228", "\u2229", "\u222a", "\u222b", "\u2234", "\u223c", "\u2245", "\u2248", "\u2260", "\u2261", "\u2264", "\u2265", "\u2282", "\u2283", "\u2284", "\u2286", "\u2287", "\u2295", "\u2297", "\u22a5", "\u22c5", "\u25ca", "\u2118", "\u2111", "\u211c", "\u2135", "\u2660", "\u2663", "\u2665", "\u2666", "\u03b1", "\u03b2", "\u0393", "\u03b3", "\u0394", "\u03b4", "\u03b5", "\u03b6", "\u03b7", "\u0398", "\u03b8", "\u03b9", "\u03ba", "\u039b", "\u03bb", "\u03bc", "\u039e", "\u03be", "\u03a0", "\u03c0", "\u03c1", "\u03a3", "\u03c3", "\u03a4", "\u03c4", "\u03c5", "\u03a6", "\u03c6", "\u03c7", "\u03a8", "\u03c8", "\u03a9", "\u03c9", "\u2605", "\u2606", "\u260e", "\u261a", "\u261b", "\u261c", "\u261d", "\u261e", "\u261f", "\u2639", "\u263a", "\u2714", "\u2718", "\u201e", "\u201c", "\u201d", "\u201a", "\u2018", "\u2019", "\u00ab", "\u00bb", "\u2039", "\u203a", "\u2014", "\u2013", "\u2026", "\u2190", "\u2191", "\u2192", "\u2193", "\u2194", "\u21d0", "\u21d1", "\u21d2", "\u21d3", "\u21d4", "\u00a9", "\u2122", "\u00ae", "\u2032", "\u2033", "[", "]", "{", "}", "~", "(", ")", "%", "\u00a7", "$", "#", "|", "@"],
  "block": false
}, {
  "type": "signature",
  "title": "Unterschrift einf\u00fcgen",
  "icon": "sig.png",
  "key": "y",
  "block": false
}, {
  "title": "Neue Tabelle einf\u00fcgen",
  "type": "NewTable",
  "icon": "..\/..\/plugins\/edittable\/images\/add_table.png",
  "block": true
}, {
  "type": "picker",
  "title": "Wrap-Plugin",
  "icon": "..\/..\/plugins\/wrap\/images\/toolbar\/picker.png",
  "list": [{
    "type": "format",
    "title": "Spalten",
    "icon": "..\/..\/plugins\/wrap\/images\/toolbar\/column.png",
    "open": "<WRAP group>\\n<WRAP half column>\\n",
    "close": "\\n<\/WRAP>\\n\\n<WRAP half column>\\n\\n<\/WRAP>\\n<\/WRAP>\\n"
  }, {
    "type": "format",
    "title": "einfache zentrierte Box",
    "icon": "..\/..\/plugins\/wrap\/images\/toolbar\/box.png",
    "open": "<WRAP center round box 60%>\\n",
    "close": "\\n<\/WRAP>\\n"
  }, {
    "type": "format",
    "title": "Info-Box",
    "icon": "..\/..\/plugins\/wrap\/images\/note\/16\/info.png",
    "open": "<WRAP center round info 60%>\\n",
    "close": "\\n<\/WRAP>\\n"
  }, {
    "type": "format",
    "title": "Tip-Box",
    "icon": "..\/..\/plugins\/wrap\/images\/note\/16\/tip.png",
    "open": "<WRAP center round tip 60%>\\n",
    "close": "\\n<\/WRAP>\\n"
  }, {
    "type": "format",
    "title": "Wichtig-Box",
    "icon": "..\/..\/plugins\/wrap\/images\/note\/16\/important.png",
    "open": "<WRAP center round important 60%>\\n",
    "close": "\\n<\/WRAP>\\n"
  }, {
    "type": "format",
    "title": "Warn-Box",
    "icon": "..\/..\/plugins\/wrap\/images\/note\/16\/alert.png",
    "open": "<WRAP center round alert 60%>\\n",
    "close": "\\n<\/WRAP>\\n"
  }, {
    "type": "format",
    "title": "Hilfe-Box",
    "icon": "..\/..\/plugins\/wrap\/images\/note\/16\/help.png",
    "open": "<WRAP center round help 60%>\\n",
    "close": "\\n<\/WRAP>\\n"
  }, {
    "type": "format",
    "title": "Download-Box",
    "icon": "..\/..\/plugins\/wrap\/images\/note\/16\/download.png",
    "open": "<WRAP center round download 60%>\\n",
    "close": "\\n<\/WRAP>\\n"
  }, {
    "type": "format",
    "title": "Zu-Erledigen-Box",
    "icon": "..\/..\/plugins\/wrap\/images\/note\/16\/todo.png",
    "open": "<WRAP center round todo 60%>\\n",
    "close": "\\n<\/WRAP>\\n"
  }, {
    "type": "insert",
    "title": "Floats beseitigen",
    "icon": "..\/..\/plugins\/wrap\/images\/toolbar\/clear.png",
    "insert": "<WRAP clear\/>\\n"
  }, {
    "type": "format",
    "title": "wichtig",
    "icon": "..\/..\/plugins\/wrap\/images\/toolbar\/em.png",
    "open": "<wrap em>",
    "close": "<\/wrap>"
  }, {
    "type": "format",
    "title": "markieren",
    "icon": "..\/..\/plugins\/wrap\/images\/toolbar\/hi.png",
    "open": "<wrap hi>",
    "close": "<\/wrap>"
  }, {
    "type": "format",
    "title": "weniger wichtig",
    "icon": "..\/..\/plugins\/wrap\/images\/toolbar\/lo.png",
    "open": "<wrap lo>",
    "close": "<\/wrap>"
  }]
}];
(function (factory) {
  if (typeof define === 'function' && define.amd) {
    define(['jquery'], factory);
  } else if (typeof exports === 'object') {
    factory(require('jquery'));
  } else {
    factory(jQuery);
  }
}(function ($) {
  var pluses = /\+/g;

  function encode(s) {
    return config.raw ? s : encodeURIComponent(s);
  }

  function decode(s) {
    return config.raw ? s : decodeURIComponent(s);
  }

  function stringifyCookieValue(value) {
    return encode(config.json ? JSON.stringify(value) : String(value));
  }

  function parseCookieValue(s) {
    if (s.indexOf('"') === 0) {
      s = s.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\');
    }
    try {
      s = decodeURIComponent(s.replace(pluses, ' '));
      return config.json ? JSON.parse(s) : s;
    } catch (e) { }
  }

  function read(s, converter) {
    var value = config.raw ? s : parseCookieValue(s);
    return $.isFunction(converter) ? converter(value) : value;
  }
  var config = $.cookie = function (key, value, options) {
    if (value !== undefined && !$.isFunction(value)) {
      options = $.extend({}, config.defaults, options);
      if (typeof options.expires === 'number') {
        var days = options.expires,
          t = options.expires = new Date();
        t.setTime(+t + days * 864e+5);
      }
      return (document.cookie = [encode(key), '=', stringifyCookieValue(value), options.expires ? '; expires=' + options.expires.toUTCString() : '', options.path ? '; path=' + options.path : '', options.domain ? '; domain=' + options.domain : '', options.secure ? '; secure' : ''].join(''));
    }
    var result = key ? undefined : {};
    var cookies = document.cookie ? document.cookie.split('; ') : [];
    for (var i = 0, l = cookies.length; i < l; i++) {
      var parts = cookies[i].split('=');
      var name = decode(parts.shift());
      var cookie = parts.join('=');
      if (key && key === name) {
        result = read(cookie, value);
        break;
      }
      if (!key && (cookie = read(cookie)) !== undefined) {
        result[name] = cookie;
      }
    }
    return result;
  };
  config.defaults = {};
  $.removeCookie = function (key, options) {
    if ($.cookie(key) === undefined) {
      return false;
    }
    $.cookie(key, '', $.extend({}, options, {
      expires: -1
    }));
    return !$.cookie(key);
  };
}));
(function (factory) {
  "use strict";
  if (typeof define === "function" && define.amd) {
    define(["../widgets/datepicker"], factory);
  } else {
    factory(jQuery.datepicker);
  }
})(function (datepicker) {
  "use strict";
  datepicker.regional.de = {
    closeText: "Schließen",
    prevText: "Zurück",
    nextText: "Vor",
    currentText: "Heute",
    monthNames: ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"],
    monthNamesShort: ["Jan", "Feb", "Mär", "Apr", "Mai", "Jun", "Jul", "Aug", "Sep", "Okt", "Nov", "Dez"],
    dayNames: ["Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"],
    dayNamesShort: ["So", "Mo", "Di", "Mi", "Do", "Fr", "Sa"],
    dayNamesMin: ["So", "Mo", "Di", "Mi", "Do", "Fr", "Sa"],
    weekHeader: "KW",
    dateFormat: "dd.mm.yy",
    firstDay: 1,
    isRTL: false,
    showMonthAfterYear: false,
    yearSuffix: ""
  };
  datepicker.setDefaults(datepicker.regional.de);
  return datepicker.regional.de;
});
var qq = qq || {};
qq.extend = function (first, second) {
  for (var prop in second) {
    first[prop] = second[prop];
  }
};
qq.indexOf = function (arr, elt, from) {
  if (arr.indexOf) return arr.indexOf(elt, from);
  from = from || 0;
  var len = arr.length;
  if (from < 0) from += len;
  for (; from < len; from++) {
    if (from in arr && arr[from] === elt) {
      return from;
    }
  }
  return -1;
};
qq.getUniqueId = (function () {
  var id = 0;
  return function () {
    return id++;
  };
})();
qq.attach = function (element, type, fn) {
  if (element.addEventListener) {
    element.addEventListener(type, fn, false);
  } else if (element.attachEvent) {
    element.attachEvent('on' + type, fn);
  }
};
qq.detach = function (element, type, fn) {
  if (element.removeEventListener) {
    element.removeEventListener(type, fn, false);
  } else if (element.attachEvent) {
    element.detachEvent('on' + type, fn);
  }
};
qq.preventDefault = function (e) {
  if (e.preventDefault) {
    e.preventDefault();
  } else {
    e.returnValue = false;
  }
};
qq.insertBefore = function (a, b) {
  b.parentNode.insertBefore(a, b);
};
qq.remove = function (element) {
  element.parentNode.removeChild(element);
};
qq.contains = function (parent, descendant) {
  if (parent == descendant) return true;
  if (parent.contains) {
    return parent.contains(descendant);
  } else {
    return !!(descendant.compareDocumentPosition(parent) & 8);
  }
};
qq.toElement = (function () {
  var div = document.createElement('div');
  return function (html) {
    div.innerHTML = html;
    var element = div.firstChild;
    div.removeChild(element);
    return element;
  };
})();
qq.css = function (element, styles) {
  if (styles.opacity != null) {
    if (typeof element.style.opacity != 'string' && typeof (element.filters) != 'undefined') {
      styles.filter = 'alpha(opacity=' + Math.round(100 * styles.opacity) + ')';
    }
  }
  qq.extend(element.style, styles);
};
qq.hasClass = function (element, name) {
  var re = new RegExp('(^| )' + name + '( |$)');
  return re.test(element.className);
};
qq.addClass = function (element, name) {
  if (!qq.hasClass(element, name)) {
    element.className += ' ' + name;
  }
};
qq.removeClass = function (element, name) {
  var re = new RegExp('(^| )' + name + '( |$)');
  element.className = element.className.replace(re, ' ').replace(/^\s+|\s+$/g, "");
};
qq.setText = function (element, text) {
  element.innerText = text;
  element.textContent = text;
};
qq.children = function (element) {
  var children = [],
    child = element.firstChild;
  while (child) {
    if (child.nodeType == 1) {
      children.push(child);
    }
    child = child.nextSibling;
  }
  return children;
};
qq.getByClass = function (element, className) {
  if (element.querySelectorAll) {
    return element.querySelectorAll('.' + className);
  }
  var result = [];
  var candidates = element.getElementsByTagName("*");
  var len = candidates.length;
  for (var i = 0; i < len; i++) {
    if (qq.hasClass(candidates[i], className)) {
      result.push(candidates[i]);
    }
  }
  return result;
};
qq.obj2url = function (obj, temp, prefixDone) {
  var uristrings = [],
    prefix = '&',
    add = function (nextObj, i) {
      var nextTemp = temp ? (/\[\]$/.test(temp)) ? temp : temp + '[' + i + ']' : i;
      if ((nextTemp != 'undefined') && (i != 'undefined')) {
        uristrings.push((typeof nextObj === 'object') ? qq.obj2url(nextObj, nextTemp, true) : (Object.prototype.toString.call(nextObj) === '[object Function]') ? encodeURIComponent(nextTemp) + '=' + encodeURIComponent(nextObj()) : encodeURIComponent(nextTemp) + '=' + encodeURIComponent(nextObj));
      }
    };
  if (!prefixDone && temp) {
    prefix = (/\?/.test(temp)) ? (/\?$/.test(temp)) ? '' : '&' : '?';
    uristrings.push(temp);
    uristrings.push(qq.obj2url(obj));
  } else if ((Object.prototype.toString.call(obj) === '[object Array]') && (typeof obj != 'undefined')) {
    for (var i = 0, len = obj.length; i < len; ++i) {
      add(obj[i], i);
    }
  } else if ((typeof obj != 'undefined') && (obj !== null) && (typeof obj === "object")) {
    for (var i in obj) {
      if (obj.hasOwnProperty(i) && typeof obj[i] != 'function') {
        add(obj[i], i);
      }
    }
  } else {
    uristrings.push(encodeURIComponent(temp) + '=' + encodeURIComponent(obj));
  }
  return uristrings.join(prefix).replace(/^&/, '').replace(/%20/g, '+');
};
var qq = qq || {};
qq.FileUploaderBasic = function (o) {
  this._options = {
    debug: false,
    action: '/server/upload',
    params: {},
    button: null,
    multiple: true,
    maxConnections: 3,
    allowedExtensions: [],
    sizeLimit: 0,
    minSizeLimit: 0,
    onSubmit: function (id, fileName) { },
    onProgress: function (id, fileName, loaded, total) { },
    onComplete: function (id, fileName, responseJSON) { },
    onCancel: function (id, fileName) { },
    messages: {
      typeError: "{file} has invalid extension. Only {extensions} are allowed.",
      sizeError: "{file} is too large, maximum file size is {sizeLimit}.",
      minSizeError: "{file} is too small, minimum file size is {minSizeLimit}.",
      emptyError: "{file} is empty, please select files again without it.",
      onLeave: "The files are being uploaded, if you leave now the upload will be cancelled."
    },
    showMessage: function (message) {
      alert(message);
    }
  };
  qq.extend(this._options, o);
  this._filesInProgress = 0;
  this._handler = this._createUploadHandler();
  if (this._options.button) {
    this._button = this._createUploadButton(this._options.button);
  }
  this._preventLeaveInProgress();
};
qq.FileUploaderBasic.prototype = {
  setParams: function (params) {
    this._options.params = params;
  },
  getInProgress: function () {
    return this._filesInProgress;
  },
  _createUploadButton: function (element) {
    var self = this;
    return new qq.UploadButton({
      element: element,
      multiple: this._options.multiple && qq.UploadHandlerXhr.isSupported(),
      onChange: function (input) {
        self._onInputChange(input);
      }
    });
  },
  _createUploadHandler: function () {
    var self = this,
      handlerClass;
    if (qq.UploadHandlerXhr.isSupported()) {
      handlerClass = 'UploadHandlerXhr';
    } else {
      handlerClass = 'UploadHandlerForm';
    }
    var handler = new qq[handlerClass]({
      debug: this._options.debug,
      action: this._options.action,
      maxConnections: this._options.maxConnections,
      onProgress: function (id, fileName, loaded, total) {
        self._onProgress(id, fileName, loaded, total);
        self._options.onProgress(id, fileName, loaded, total);
      },
      onComplete: function (id, fileName, result) {
        self._onComplete(id, fileName, result);
        self._options.onComplete(id, fileName, result);
      },
      onCancel: function (id, fileName) {
        self._onCancel(id, fileName);
        self._options.onCancel(id, fileName);
      }
    });
    return handler;
  },
  _preventLeaveInProgress: function () {
    var self = this;
    qq.attach(window, 'beforeunload', function (e) {
      if (!self._filesInProgress) {
        return;
      }
      var e = e || window.event;
      e.returnValue = self._options.messages.onLeave;
      return self._options.messages.onLeave;
    });
  },
  _onSubmit: function (id, fileName) {
    this._filesInProgress++;
  },
  _onProgress: function (id, fileName, loaded, total) { },
  _onComplete: function (id, fileName, result) {
    this._filesInProgress--;
    if (result.error) {
      this._options.showMessage(result.error);
    }
  },
  _onCancel: function (id, fileName) {
    this._filesInProgress--;
  },
  _onInputChange: function (input) {
    if (this._handler instanceof qq.UploadHandlerXhr) {
      this._uploadFileList(input.files);
    } else {
      if (this._validateFile(input)) {
        this._uploadFile(input);
      }
    }
    this._button.reset();
  },
  _uploadFileList: function (files) {
    for (var i = 0; i < files.length; i++) {
      if (!this._validateFile(files[i])) {
        return;
      }
    }
    for (var i = 0; i < files.length; i++) {
      this._uploadFile(files[i]);
    }
  },
  _uploadFile: function (fileContainer) {
    var id = this._handler.add(fileContainer);
    var fileName = this._handler.getName(id);
    if (this._options.onSubmit(id, fileName) !== false) {
      this._onSubmit(id, fileName);
      this._handler.upload(id, this._options.params);
    }
  },
  _validateFile: function (file) {
    var name, size;
    if (file.value) {
      name = file.value.replace(/.*(\/|\\)/, "");
    } else {
      name = file.fileName != null ? file.fileName : file.name;
      size = file.fileSize != null ? file.fileSize : file.size;
    }
    if (!this._isAllowedExtension(name)) {
      this._error('typeError', name);
      return false;
    } else if (size === 0) {
      this._error('emptyError', name);
      return false;
    } else if (size && this._options.sizeLimit && size > this._options.sizeLimit) {
      this._error('sizeError', name);
      return false;
    } else if (size && size < this._options.minSizeLimit) {
      this._error('minSizeError', name);
      return false;
    }
    return true;
  },
  _error: function (code, fileName) {
    var message = this._options.messages[code];

    function r(name, replacement) {
      message = message.replace(name, replacement);
    }
    r('{file}', this._formatFileName(fileName));
    r('{extensions}', this._options.allowedExtensions.join(', '));
    r('{sizeLimit}', this._formatSize(this._options.sizeLimit));
    r('{minSizeLimit}', this._formatSize(this._options.minSizeLimit));
    this._options.showMessage(message);
  },
  _formatFileName: function (name) {
    if (name.length > 33) {
      name = name.slice(0, 19) + '...' + name.slice(-13);
    }
    return name;
  },
  _isAllowedExtension: function (fileName) {
    var ext = (-1 !== fileName.indexOf('.')) ? fileName.replace(/.*[.]/, '').toLowerCase() : '';
    var allowed = this._options.allowedExtensions;
    if (!allowed.length) {
      return true;
    }
    for (var i = 0; i < allowed.length; i++) {
      if (allowed[i].toLowerCase() == ext) {
        return true;
      }
    }
    return false;
  },
  _formatSize: function (bytes) {
    var i = -1;
    do {
      bytes = bytes / 1024;
      i++;
    } while (bytes > 99);
    return Math.max(bytes, 0.1).toFixed(1) + ['kB', 'MB', 'GB', 'TB', 'PB', 'EB'][i];
  }
};
qq.FileUploader = function (o) {
  qq.FileUploaderBasic.apply(this, arguments);
  qq.extend(this._options, {
    element: null,
    listElement: null,
    template: '<div class="qq-uploader">' + '<div class="qq-upload-drop-area"><span>Drop files here to upload</span></div>' + '<div class="qq-upload-button">Upload a file</div>' + '<ul class="qq-upload-list"></ul>' + '</div>',
    fileTemplate: '<li>' + '<span class="qq-upload-file"></span>' + '<span class="qq-upload-spinner"></span>' + '<span class="qq-upload-size"></span>' + '<a class="qq-upload-cancel" href="#">Cancel</a>' + '<span class="qq-upload-failed-text">Failed</span>' + '</li>',
    classes: {
      button: 'qq-upload-button',
      drop: 'qq-upload-drop-area',
      dropActive: 'qq-upload-drop-area-active',
      list: 'qq-upload-list',
      file: 'qq-upload-file',
      spinner: 'qq-upload-spinner',
      size: 'qq-upload-size',
      cancel: 'qq-upload-cancel',
      success: 'qq-upload-success',
      fail: 'qq-upload-fail'
    }
  });
  qq.extend(this._options, o);
  this._element = this._options.element;
  this._element.innerHTML = this._options.template;
  this._listElement = this._options.listElement || this._find(this._element, 'list');
  this._classes = this._options.classes;
  this._button = this._createUploadButton(this._find(this._element, 'button'));
  this._bindCancelEvent();
  this._setupDragDrop();
};
qq.extend(qq.FileUploader.prototype, qq.FileUploaderBasic.prototype);
qq.extend(qq.FileUploader.prototype, {
  _find: function (parent, type) {
    var element = qq.getByClass(parent, this._options.classes[type])[0];
    if (!element) {
      throw new Error('element not found ' + type);
    }
    return element;
  },
  _setupDragDrop: function () {
    var self = this,
      dropArea = this._find(this._element, 'drop');
    var dz = new qq.UploadDropZone({
      element: dropArea,
      onEnter: function (e) {
        qq.addClass(dropArea, self._classes.dropActive);
        e.stopPropagation();
      },
      onLeave: function (e) {
        e.stopPropagation();
      },
      onLeaveNotDescendants: function (e) {
        qq.removeClass(dropArea, self._classes.dropActive);
      },
      onDrop: function (e) {
        dropArea.style.display = 'none';
        qq.removeClass(dropArea, self._classes.dropActive);
        self._uploadFileList(e.dataTransfer.files);
      }
    });
    dropArea.style.display = 'none';
    qq.attach(document, 'dragenter', function (e) {
      if (!dz._isValidFileDrag(e)) return;
      dropArea.style.display = 'block';
    });
    qq.attach(document, 'dragleave', function (e) {
      if (!dz._isValidFileDrag(e)) return;
      var relatedTarget = document.elementFromPoint(e.clientX, e.clientY);
      if (!relatedTarget || relatedTarget.nodeName == "HTML") {
        dropArea.style.display = 'none';
      }
    });
  },
  _onSubmit: function (id, fileName) {
    qq.FileUploaderBasic.prototype._onSubmit.apply(this, arguments);
    this._addToList(id, fileName);
  },
  _onProgress: function (id, fileName, loaded, total) {
    qq.FileUploaderBasic.prototype._onProgress.apply(this, arguments);
    var item = this._getItemByFileId(id);
    var size = this._find(item, 'size');
    size.style.display = 'inline';
    var text;
    if (loaded != total) {
      text = Math.round(loaded / total * 100) + '% from ' + this._formatSize(total);
    } else {
      text = this._formatSize(total);
    }
    qq.setText(size, text);
  },
  _onComplete: function (id, fileName, result) {
    qq.FileUploaderBasic.prototype._onComplete.apply(this, arguments);
    var item = this._getItemByFileId(id);
    qq.remove(this._find(item, 'cancel'));
    qq.remove(this._find(item, 'spinner'));
    if (result.success) {
      qq.addClass(item, this._classes.success);
    } else {
      qq.addClass(item, this._classes.fail);
    }
  },
  _addToList: function (id, fileName) {
    var item = qq.toElement(this._options.fileTemplate);
    item.qqFileId = id;
    var fileElement = this._find(item, 'file');
    qq.setText(fileElement, this._formatFileName(fileName));
    this._find(item, 'size').style.display = 'none';
    this._listElement.appendChild(item);
  },
  _getItemByFileId: function (id) {
    var item = this._listElement.firstChild;
    while (item) {
      if (item.qqFileId == id) return item;
      item = item.nextSibling;
    }
  },
  _bindCancelEvent: function () {
    var self = this,
      list = this._listElement;
    qq.attach(list, 'click', function (e) {
      e = e || window.event;
      var target = e.target || e.srcElement;
      if (qq.hasClass(target, self._classes.cancel)) {
        qq.preventDefault(e);
        var item = target.parentNode;
        self._handler.cancel(item.qqFileId);
        qq.remove(item);
      }
    });
  }
});
qq.UploadDropZone = function (o) {
  this._options = {
    element: null,
    onEnter: function (e) { },
    onLeave: function (e) { },
    onLeaveNotDescendants: function (e) { },
    onDrop: function (e) { }
  };
  qq.extend(this._options, o);
  this._element = this._options.element;
  this._disableDropOutside();
  this._attachEvents();
};
qq.UploadDropZone.prototype = {
  _disableDropOutside: function (e) {
    if (!qq.UploadDropZone.dropOutsideDisabled) {
      qq.attach(document, 'dragover', function (e) {
        if (e.dataTransfer) {
          e.dataTransfer.dropEffect = 'none';
          e.preventDefault();
        }
      });
      qq.UploadDropZone.dropOutsideDisabled = true;
    }
  },
  _attachEvents: function () {
    var self = this;
    qq.attach(self._element, 'dragover', function (e) {
      if (!self._isValidFileDrag(e)) return;
      var effect = e.dataTransfer.effectAllowed;
      if (effect == 'move' || effect == 'linkMove') {
        e.dataTransfer.dropEffect = 'move';
      } else {
        e.dataTransfer.dropEffect = 'copy';
      }
      e.stopPropagation();
      e.preventDefault();
    });
    qq.attach(self._element, 'dragenter', function (e) {
      if (!self._isValidFileDrag(e)) return;
      self._options.onEnter(e);
    });
    qq.attach(self._element, 'dragleave', function (e) {
      if (!self._isValidFileDrag(e)) return;
      self._options.onLeave(e);
      var relatedTarget = document.elementFromPoint(e.clientX, e.clientY);
      if (qq.contains(this, relatedTarget)) return;
      self._options.onLeaveNotDescendants(e);
    });
    qq.attach(self._element, 'drop', function (e) {
      if (!self._isValidFileDrag(e)) return;
      e.preventDefault();
      self._options.onDrop(e);
    });
  },
  _isValidFileDrag: function (e) {
    var dt = e.dataTransfer,
      isWebkit = navigator.userAgent.indexOf("AppleWebKit") > -1;
    return dt && dt.effectAllowed != 'none' && (dt.files || (!isWebkit && dt.types.contains && dt.types.contains('Files')));
  }
};
qq.UploadButton = function (o) {
  this._options = {
    element: null,
    multiple: false,
    name: 'file',
    onChange: function (input) { },
    hoverClass: 'qq-upload-button-hover',
    focusClass: 'qq-upload-button-focus'
  };
  qq.extend(this._options, o);
  this._element = this._options.element;
  qq.css(this._element, {
    position: 'relative',
    overflow: 'hidden',
    direction: 'ltr'
  });
  this._input = this._createInput();
};
qq.UploadButton.prototype = {
  getInput: function () {
    return this._input;
  },
  reset: function () {
    if (this._input.parentNode) {
      qq.remove(this._input);
    }
    qq.removeClass(this._element, this._options.focusClass);
    this._input = this._createInput();
  },
  _createInput: function () {
    var input = document.createElement("input");
    if (this._options.multiple) {
      input.setAttribute("multiple", "multiple");
    }
    input.setAttribute("type", "file");
    input.setAttribute("name", this._options.name);
    qq.css(input, {
      position: 'absolute',
      right: 0,
      top: 0,
      fontFamily: 'Arial',
      fontSize: '118px',
      margin: 0,
      padding: 0,
      cursor: 'pointer',
      opacity: 0
    });
    this._element.appendChild(input);
    var self = this;
    qq.attach(input, 'change', function () {
      self._options.onChange(input);
    });
    qq.attach(input, 'mouseover', function () {
      qq.addClass(self._element, self._options.hoverClass);
    });
    qq.attach(input, 'mouseout', function () {
      qq.removeClass(self._element, self._options.hoverClass);
    });
    qq.attach(input, 'focus', function () {
      qq.addClass(self._element, self._options.focusClass);
    });
    qq.attach(input, 'blur', function () {
      qq.removeClass(self._element, self._options.focusClass);
    });
    if (window.attachEvent) {
      input.setAttribute('tabIndex', "-1");
    }
    return input;
  }
};
qq.UploadHandlerAbstract = function (o) {
  this._options = {
    debug: false,
    action: '/upload.php',
    maxConnections: 999,
    onProgress: function (id, fileName, loaded, total) { },
    onComplete: function (id, fileName, response) { },
    onCancel: function (id, fileName) { }
  };
  qq.extend(this._options, o);
  this._queue = [];
  this._params = [];
};
qq.UploadHandlerAbstract.prototype = {
  log: function (str) {
    if (this._options.debug && window.console) console.log('[uploader] ' + str);
  },
  add: function (file) { },
  upload: function (id, params) {
    var len = this._queue.push(id);
    var copy = {};
    qq.extend(copy, params);
    this._params[id] = copy;
    if (len <= this._options.maxConnections) {
      this._upload(id, this._params[id]);
    }
  },
  cancel: function (id) {
    this._cancel(id);
    this._dequeue(id);
  },
  cancelAll: function () {
    for (var i = 0; i < this._queue.length; i++) {
      this._cancel(this._queue[i]);
    }
    this._queue = [];
  },
  getName: function (id) { },
  getSize: function (id) { },
  getQueue: function () {
    return this._queue;
  },
  _upload: function (id) { },
  _cancel: function (id) { },
  _dequeue: function (id) {
    var i = qq.indexOf(this._queue, id);
    this._queue.splice(i, 1);
    var max = this._options.maxConnections;
    if (this._queue.length >= max && i < max) {
      var nextId = this._queue[max - 1];
      this._upload(nextId, this._params[nextId]);
    }
  }
};
qq.UploadHandlerForm = function (o) {
  qq.UploadHandlerAbstract.apply(this, arguments);
  this._inputs = {};
};
qq.extend(qq.UploadHandlerForm.prototype, qq.UploadHandlerAbstract.prototype);
qq.extend(qq.UploadHandlerForm.prototype, {
  add: function (fileInput) {
    fileInput.setAttribute('name', 'qqfile');
    var id = 'qq-upload-handler-iframe' + qq.getUniqueId();
    this._inputs[id] = fileInput;
    if (fileInput.parentNode) {
      qq.remove(fileInput);
    }
    return id;
  },
  getName: function (id) {
    return this._inputs[id].value.replace(/.*(\/|\\)/, "");
  },
  _cancel: function (id) {
    this._options.onCancel(id, this.getName(id));
    delete this._inputs[id];
    var iframe = document.getElementById(id);
    if (iframe) {
      iframe.setAttribute('src', 'javascript:false;');
      qq.remove(iframe);
    }
  },
  _upload: function (id, params) {
    var input = this._inputs[id];
    if (!input) {
      throw new Error('file with passed id was not added, or already uploaded or cancelled');
    }
    var fileName = this.getName(id);
    var iframe = this._createIframe(id);
    var form = this._createForm(iframe, params);
    form.appendChild(input);
    var self = this;
    this._attachLoadEvent(iframe, function () {
      self.log('iframe loaded');
      var response = self._getIframeContentJSON(iframe);
      self._options.onComplete(id, fileName, response);
      self._dequeue(id);
      delete self._inputs[id];
      setTimeout(function () {
        qq.remove(iframe);
      }, 1);
    });
    form.submit();
    qq.remove(form);
    return id;
  },
  _attachLoadEvent: function (iframe, callback) {
    qq.attach(iframe, 'load', function () {
      if (!iframe.parentNode) {
        return;
      }
      if (iframe.contentDocument && iframe.contentDocument.body && iframe.contentDocument.body.innerHTML == "false") {
        return;
      }
      callback();
    });
  },
  _getIframeContentJSON: function (iframe) {
    var doc = iframe.contentDocument ? iframe.contentDocument : iframe.contentWindow.document,
      response;
    this.log("converting iframe's innerHTML to JSON");
    this.log("innerHTML = " + doc.body.innerHTML);
    try {
      response = eval("(" + doc.body.innerHTML + ")");
    } catch (err) {
      response = {};
    }
    return response;
  },
  _createIframe: function (id) {
    var iframe = qq.toElement('<iframe src="javascript:false;" name="' + id + '" />');
    iframe.setAttribute('id', id);
    iframe.style.display = 'none';
    document.body.appendChild(iframe);
    return iframe;
  },
  _createForm: function (iframe, params) {
    var form = qq.toElement('<form method="post" enctype="multipart/form-data"></form>');
    var queryString = qq.obj2url(params, this._options.action);
    form.setAttribute('action', queryString);
    form.setAttribute('target', iframe.name);
    form.style.display = 'none';
    document.body.appendChild(form);
    return form;
  }
});
qq.UploadHandlerXhr = function (o) {
  qq.UploadHandlerAbstract.apply(this, arguments);
  this._files = [];
  this._xhrs = [];
  this._loaded = [];
};
qq.UploadHandlerXhr.isSupported = function () {
  var input = document.createElement('input');
  input.type = 'file';
  return ('multiple' in input && typeof File != "undefined" && typeof (new XMLHttpRequest()).upload != "undefined");
};
qq.extend(qq.UploadHandlerXhr.prototype, qq.UploadHandlerAbstract.prototype);
qq.extend(qq.UploadHandlerXhr.prototype, {
  add: function (file) {
    if (!(file instanceof File)) {
      throw new Error('Passed obj in not a File (in qq.UploadHandlerXhr)');
    }
    return this._files.push(file) - 1;
  },
  getName: function (id) {
    var file = this._files[id];
    return file.fileName != null ? file.fileName : file.name;
  },
  getSize: function (id) {
    var file = this._files[id];
    return file.fileSize != null ? file.fileSize : file.size;
  },
  getLoaded: function (id) {
    return this._loaded[id] || 0;
  },
  _upload: function (id, params) {
    var file = this._files[id],
      name = this.getName(id),
      size = this.getSize(id);
    this._loaded[id] = 0;
    var xhr = this._xhrs[id] = new XMLHttpRequest();
    var self = this;
    xhr.upload.onprogress = function (e) {
      if (e.lengthComputable) {
        self._loaded[id] = e.loaded;
        self._options.onProgress(id, name, e.loaded, e.total);
      }
    };
    xhr.onreadystatechange = function () {
      if (xhr.readyState == 4) {
        self._onComplete(id, xhr);
      }
    };
    params = params || {};
    params['qqfile'] = name;
    var queryString = qq.obj2url(params, this._options.action);
    xhr.open("POST", queryString, true);
    xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
    xhr.setRequestHeader("X-File-Name", encodeURIComponent(name));
    xhr.setRequestHeader("Content-Type", "application/octet-stream");
    xhr.send(file);
  },
  _onComplete: function (id, xhr) {
    if (!this._files[id]) return;
    var name = this.getName(id);
    var size = this.getSize(id);
    this._options.onProgress(id, name, size, size);
    if (xhr.status == 200) {
      this.log("xhr - server response received");
      this.log("responseText = " + xhr.responseText);
      var response;
      try {
        response = eval("(" + xhr.responseText + ")");
      } catch (err) {
        response = {};
      }
      this._options.onComplete(id, name, response);
    } else {
      this._options.onComplete(id, name, {});
    }
    this._files[id] = null;
    this._xhrs[id] = null;
    this._dequeue(id);
  },
  _cancel: function (id) {
    this._options.onCancel(id, this.getName(id));
    this._files[id] = null;
    if (this._xhrs[id]) {
      this._xhrs[id].abort();
      this._xhrs[id] = null;
    }
  }
});
qq.extend(qq.FileUploader.prototype, {
  _createUploadHandler: function () {
    var self = this,
      handlerClass;
    if (qq.UploadHandlerXhr.isSupported()) {
      handlerClass = 'UploadHandlerXhr';
    } else {
      handlerClass = 'UploadHandlerForm';
    }
    var handler = new qq[handlerClass]({
      debug: this._options.debug,
      action: this._options.action,
      maxConnections: this._options.maxConnections,
      onProgress: function (id, fileName, loaded, total) {
        self._onProgress(id, fileName, loaded, total);
        self._options.onProgress(id, fileName, loaded, total);
      },
      onComplete: function (id, fileName, result) {
        self._onComplete(id, fileName, result);
        self._options.onComplete(id, fileName, result);
      },
      onCancel: function (id, fileName) {
        self._onCancel(id, fileName);
        self._options.onCancel(id, fileName);
      },
      onUpload: function () {
        self._onUpload();
      }
    });
    return handler;
  },
  _onUpload: function () {
    this._handler.uploadAll(this._options.params);
  },
  _uploadFile: function (fileContainer) {
    var id = this._handler.add(fileContainer);
    var fileName = this._handler.getName(id);
    if (this._options.onSubmit(id, fileName) !== false) {
      this._onSubmit(id, fileName);
    }
  },
  _addToList: function (id, fileName) {
    var item = qq.toElement(this._options.fileTemplate);
    item.qqFileId = id;
    var fileElement = this._find(item, 'file');
    qq.setText(fileElement, fileName);
    this._find(item, 'size').style.display = 'none';
    var nameElement = this._find(item, 'nameInput');
    fileName = fileName.toLowerCase();
    fileName = fileName.replace(/([ !"#$%&\'()+,\/;<=>?@[\]^`{|}~:]+)/g, '_');
    fileName = fileName.replace(/^_+/, '');
    nameElement.value = fileName;
    nameElement.id = 'mediamanager__upload_item' + id;
    this._listElement.appendChild(item);
  }
});
qq.FileUploaderExtended = function (o) {
  qq.FileUploaderBasic.apply(this, arguments);
  qq.extend(this._options, {
    element: null,
    listElement: null,
    template: '<div class="qq-uploader">' + '<div class="qq-upload-drop-area"><span>' + LANG.media_drop + '</span></div>' + '<div class="qq-upload-button">' + LANG.media_select + '</div>' + '<ul class="qq-upload-list"></ul>' + '<div class="qq-action-container">' + '  <button class="qq-upload-action" type="submit" id="mediamanager__upload_button">' + LANG.media_upload_btn + '</button>' + '  <label class="qq-overwrite-check"><input type="checkbox" value="1" name="ow" class="dw__ow"> <span>' + LANG.media_overwrt + '</span></label>' + '</div>' + '</div>',
    fileTemplate: '<li>' + '<span class="qq-upload-file hidden"></span>' + '  <input class="qq-upload-name-input edit" type="text" value="" />' + '  <span class="qq-upload-spinner hidden"></span>' + '  <span class="qq-upload-size"></span>' + '  <a class="qq-upload-cancel" href="#">' + LANG.media_cancel + '</a>' + '  <span class="qq-upload-failed-text error">Failed</span>' + '</li>',
    classes: {
      button: 'qq-upload-button',
      drop: 'qq-upload-drop-area',
      dropActive: 'qq-upload-drop-area-active',
      list: 'qq-upload-list',
      nameInput: 'qq-upload-name-input',
      overwriteInput: 'qq-overwrite-check',
      uploadButton: 'qq-upload-action',
      file: 'qq-upload-file',
      spinner: 'qq-upload-spinner',
      size: 'qq-upload-size',
      cancel: 'qq-upload-cancel',
      success: 'qq-upload-success',
      fail: 'qq-upload-fail',
      failedText: 'qq-upload-failed-text'
    }
  });
  qq.extend(this._options, o);
  this._element = this._options.element;
  this._element.innerHTML = this._options.template;
  this._listElement = this._options.listElement || this._find(this._element, 'list');
  this._classes = this._options.classes;
  this._button = this._createUploadButton(this._find(this._element, 'button'));
  this._bindCancelEvent();
  this._bindUploadEvent();
  this._setupDragDrop();
};
qq.extend(qq.FileUploaderExtended.prototype, qq.FileUploader.prototype);
qq.extend(qq.FileUploaderExtended.prototype, {
  _bindUploadEvent: function () {
    var self = this,
      list = this._listElement;
    qq.attach(document.getElementById('mediamanager__upload_button'), 'click', function (e) {
      e = e || window.event;
      var target = e.target || e.srcElement;
      qq.preventDefault(e);
      self._handler._options.onUpload();
      jQuery(".qq-upload-name-input").each(function (i) {
        jQuery(this).prop('disabled', true);
      });
    });
  },
  _onComplete: function (id, fileName, result) {
    this._filesInProgress--;
    var item = this._getItemByFileId(id);
    qq.remove(this._find(item, 'cancel'));
    qq.remove(this._find(item, 'spinner'));
    var nameInput = this._find(item, 'nameInput');
    var fileElement = this._find(item, 'file');
    qq.setText(fileElement, nameInput.value);
    qq.removeClass(fileElement, 'hidden');
    qq.remove(nameInput);
    jQuery('.qq-upload-button, #mediamanager__upload_button').remove();
    jQuery('.dw__ow').parent().hide();
    jQuery('.qq-upload-drop-area').remove();
    if (result.success) {
      qq.addClass(item, this._classes.success);
      $link = '<a href="' + result.link + '" id="h_:' + result.id + '" class="select">' + nameInput.value + '</a>';
      jQuery(fileElement).html($link);
    } else {
      qq.addClass(item, this._classes.fail);
      var fail = this._find(item, 'failedText');
      if (result.error) qq.setText(fail, result.error);
    }
    if (document.getElementById('media__content') && !document.getElementById('mediamanager__done_form')) {
      var action = document.location.href;
      var i = action.indexOf('?');
      if (i) action = action.substr(0, i);
      var button = '<form method="post" action="' + action + '" id="mediamanager__done_form"><div>';
      button += '<input type="hidden" value="' + result.ns + '" name="ns">';
      button += '<input type="hidden" value="1" name="recent">';
      button += '<button type="submit">' + LANG.media_done_btn + '</button></div></form>';
      jQuery('#mediamanager__uploader').append(button);
    }
  }
});
qq.extend(qq.UploadHandlerForm.prototype, {
  uploadAll: function (params) {
    this._uploadAll(params);
  },
  getName: function (id) {
    var file = this._inputs[id];
    var name = document.getElementById('mediamanager__upload_item' + id);
    if (name != null) {
      return name.value;
    } else {
      if (file != null) {
        return file.value.replace(/.*(\/|\\)/, "");
      } else {
        return null;
      }
    }
  },
  _uploadAll: function (params) {
    jQuery(".qq-upload-spinner").each(function (i) {
      jQuery(this).removeClass('hidden');
    });
    for (key in this._inputs) {
      this.upload(key, params);
    }
  },
  _upload: function (id, params) {
    var input = this._inputs[id];
    if (!input) {
      throw new Error('file with passed id was not added, or already uploaded or cancelled');
    }
    var fileName = this.getName(id);
    var iframe = this._createIframe(id);
    var form = this._createForm(iframe, params);
    form.appendChild(input);
    var nameInput = qq.toElement('<input name="mediaid" value="' + fileName + '" type="text">');
    form.appendChild(nameInput);
    var checked = jQuery('.dw__ow').is(':checked');
    var owCheckbox = jQuery('.dw__ow').clone();
    owCheckbox.attr('checked', checked);
    jQuery(form).append(owCheckbox);
    var self = this;
    this._attachLoadEvent(iframe, function () {
      self.log('iframe loaded');
      var response = self._getIframeContentJSON(iframe);
      self._options.onComplete(id, fileName, response);
      self._dequeue(id);
      delete self._inputs[id];
      setTimeout(function () {
        qq.remove(iframe);
      }, 1);
    });
    form.submit();
    qq.remove(form);
    return id;
  }
});
qq.extend(qq.UploadHandlerXhr.prototype, {
  uploadAll: function (params) {
    this._uploadAll(params);
  },
  getName: function (id) {
    var file = this._files[id];
    var name = document.getElementById('mediamanager__upload_item' + id);
    if (name != null) {
      return name.value;
    } else {
      if (file != null) {
        return file.fileName != null ? file.fileName : file.name;
      } else {
        return null;
      }
    }
  },
  getSize: function (id) {
    var file = this._files[id];
    if (file == null) return null;
    return file.fileSize != null ? file.fileSize : file.size;
  },
  _upload: function (id, params) {
    var file = this._files[id],
      name = this.getName(id),
      size = this.getSize(id);
    if (name == null || size == null) return;
    this._loaded[id] = 0;
    var xhr = this._xhrs[id] = new XMLHttpRequest();
    var self = this;
    xhr.upload.onprogress = function (e) {
      if (e.lengthComputable) {
        self._loaded[id] = e.loaded;
        self._options.onProgress(id, name, e.loaded, e.total);
      }
    };
    xhr.onreadystatechange = function () {
      if (xhr.readyState == 4) {
        self._onComplete(id, xhr);
      }
    };
    params = params || {};
    params['qqfile'] = name;
    params['ow'] = jQuery('.dw__ow').is(':checked');
    var queryString = qq.obj2url(params, this._options.action);
    xhr.open("POST", queryString, true);
    xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
    xhr.setRequestHeader("X-File-Name", encodeURIComponent(name));
    xhr.setRequestHeader("Content-Type", "application/octet-stream");
    xhr.send(file);
  },
  _uploadAll: function (params) {
    jQuery(".qq-upload-spinner").each(function (i) {
      jQuery(this).removeClass('hidden');
    });
    for (key in this._files) {
      this.upload(key, params);
    }
  }
});

function substr_replace(str, replace, start, length) {
  var a2, b1;
  a2 = (start < 0 ? str.length : 0) + start;
  if (typeof length === 'undefined') {
    length = str.length - a2;
  } else if (length < 0 && start < 0 && length <= start) {
    length = 0;
  }
  b1 = (length < 0 ? str.length : a2) + length;
  return str.substring(0, a2) + replace + str.substring(b1);
}

function bind(fnc) {
  var Aps = Array.prototype.slice,
    static_args = Aps.call(arguments, 1);
  return function () {
    return fnc.apply(this, static_args.concat(Aps.call(arguments, 0)));
  };
}

function logError(e, file) {
  if (window.console && console.error) {
    console.error('The error "%s: %s" occurred in file "%s". ' + 'If this is in a plugin try updating or disabling the plugin, ' + 'if this is in a template try updating the template or switching to the "dokuwiki" template.', e.name, e.message, file);
    if (e.stack) {
      console.error(e.stack);
    }
  }
}
var timer = {
  _cur_id: 0,
  _handlers: {},
  execDispatch: function (id) {
    timer._handlers[id]();
  },
  add: function (func, timeout) {
    var id = ++timer._cur_id;
    timer._handlers[id] = func;
    return window.setTimeout('timer.execDispatch(' + id + ')', timeout);
  }
};

function Delay(func, timeout) {
  this.func = func;
  if (timeout) {
    this.timeout = timeout;
  }
}
Delay.prototype = {
  func: null,
  timeout: 500,
  delTimer: function () {
    if (this.timer !== null) {
      window.clearTimeout(this.timer);
      this.timer = null;
    }
  },
  start: function () {
    DEPRECATED('don\'t use the Delay object, use window.timeout with a callback instead');
    this.delTimer();
    var _this = this;
    this.timer = timer.add(function () {
      _this.exec.call(_this);
    }, this.timeout);
    this._data = {
      _this: arguments[0],
      _params: Array.prototype.slice.call(arguments, 2)
    };
  },
  exec: function () {
    this.delTimer();
    this.func.call(this._data._this, this._data._params);
  }
};
var DokuCookie = {
  data: {},
  name: 'DOKU_PREFS',
  setValue: function (key, val) {
    var text = [],
      _this = this;
    this.init();
    if (val === false) {
      delete this.data[key];
    } else {
      val = val + "";
      this.data[key] = val;
    }
    jQuery.each(_this.data, function (key, val) {
      if (_this.data.hasOwnProperty(key)) {
        text.push(encodeURIComponent(key) + '#' + encodeURIComponent(val));
      }
    });
    jQuery.cookie(this.name, text.join('#'), {
      expires: 365,
      path: DOKU_COOKIE_PARAM.path,
      secure: DOKU_COOKIE_PARAM.secure
    });
  },
  getValue: function (key, def) {
    this.init();
    return this.data.hasOwnProperty(key) ? this.data[key] : def;
  },
  init: function () {
    var text, parts, i;
    if (!jQuery.isEmptyObject(this.data)) {
      return;
    }
    text = jQuery.cookie(this.name);
    if (text) {
      parts = text.split('#');
      for (i = 0; i < parts.length; i += 2) {
        this.data[decodeURIComponent(parts[i])] = decodeURIComponent(parts[i + 1]);
      }
    }
  }
};
if ('function' === typeof jQuery && 'function' === typeof jQuery.noConflict) {
  jQuery.noConflict();
}
var clientPC = navigator.userAgent.toLowerCase();
var is_macos = navigator.appVersion.indexOf('Mac') != -1;
var is_gecko = ((clientPC.indexOf('gecko') != -1) && (clientPC.indexOf('spoofer') == -1) && (clientPC.indexOf('khtml') == -1) && (clientPC.indexOf('netscape/7.0') == -1));
var is_safari = ((clientPC.indexOf('applewebkit') != -1) && (clientPC.indexOf('spoofer') == -1));
var is_khtml = (navigator.vendor == 'KDE' || (document.childNodes && !document.all && !navigator.taintEnabled));
if (clientPC.indexOf('opera') != -1) {
  var is_opera = true;
  var is_opera_preseven = (window.opera && !document.childNodes);
  var is_opera_seven = (window.opera && document.childNodes);
}

function closePopups() {
  jQuery('div.JSpopup').hide();
}
jQuery(function () {
  jQuery(document).on('click', closePopups);
});
jQuery.fn.dw_qsearch = function (overrides) {
  var dw_qsearch = {
    output: '#qsearch__out',
    $inObj: this,
    $outObj: null,
    timer: null,
    curRequest: null,
    init: function () {
      var do_qsearch;
      dw_qsearch.$outObj = jQuery(dw_qsearch.output);
      if (dw_qsearch.$inObj.length === 0 || dw_qsearch.$outObj.length === 0) {
        return;
      }
      do_qsearch = function () {
        if (dw_qsearch.curRequest != null) {
          dw_qsearch.curRequest.abort();
        }
        var value = dw_qsearch.getSearchterm();
        if (value === '') {
          dw_qsearch.clear_results();
          return;
        }
        dw_qsearch.$inObj.parents('form').addClass('searching');
        dw_qsearch.curRequest = jQuery.post(DOKU_BASE + 'lib/exe/ajax.php', {
          call: 'qsearch',
          q: encodeURI(value)
        }, dw_qsearch.onCompletion, 'html');
      };
      dw_qsearch.$inObj.on('keyup', function () {
        if (dw_qsearch.timer) {
          window.clearTimeout(dw_qsearch.timer);
          dw_qsearch.timer = null;
        }
        dw_qsearch.timer = window.setTimeout(do_qsearch, 500);
      });
      dw_qsearch.$outObj.on('click', dw_qsearch.clear_results);
    },
    getSearchterm: function () {
      return dw_qsearch.$inObj.val();
    },
    clear_results: function () {
      dw_qsearch.$inObj.parents('form').removeClass('searching');
      dw_qsearch.$outObj.hide();
      dw_qsearch.$outObj.text('');
    },
    onCompletion: function (data) {
      var max, $links, too_big;
      dw_qsearch.$inObj.parents('form').removeClass('searching');
      dw_qsearch.curRequest = null;
      if (data === '') {
        dw_qsearch.clear_results();
        return;
      }
      dw_qsearch.$outObj.html(data).show().css('white-space', 'nowrap');
      dw_qsearch.$outObj.find('li').css('overflow', 'visible');
      $links = dw_qsearch.$outObj.find('a');
      max = dw_qsearch.$outObj[0].clientWidth;
      if (document.documentElement.dir === 'rtl') {
        max -= parseInt(dw_qsearch.$outObj.css('padding-left'));
        too_big = function (l) {
          return l.offsetLeft < 0;
        };
      } else {
        max -= parseInt(dw_qsearch.$outObj.css('padding-right'));
        too_big = function (l) {
          return l.offsetWidth + l.offsetLeft > max;
        };
      }
      $links.each(function () {
        var start, length, replace, nsL, nsR, eli, runaway;
        if (!too_big(this)) {
          return;
        }
        nsL = this.textContent.indexOf('(');
        nsR = this.textContent.indexOf(')');
        eli = 0;
        runaway = 0;
        while ((nsR - nsL > 3) && too_big(this) && runaway++ < 500) {
          if (eli !== 0) {
            if ((eli - nsL) > (nsR - eli)) {
              start = eli - 2;
              length = 2;
            } else {
              start = eli + 1;
              length = 1;
            }
            replace = '';
          } else {
            start = Math.floor(nsL + ((nsR - nsL) / 2));
            length = 1;
            replace = '…';
          }
          this.textContent = substr_replace(this.textContent, replace, start, length);
          eli = this.textContent.indexOf('…');
          nsL = this.textContent.indexOf('(');
          nsR = this.textContent.indexOf(')');
        }
      });
      dw_qsearch.$outObj.find('li').css('overflow', 'hidden').css('text-overflow', 'ellipsis');
    }
  };
  jQuery.extend(dw_qsearch, overrides);
  if (!overrides.deferInit) {
    dw_qsearch.init();
  }
  return dw_qsearch;
};
jQuery(function () {
  jQuery('#qsearch__in').dw_qsearch({
    output: '#qsearch__out'
  });
});
jQuery(function () {
  'use strict';
  var $searchForm = jQuery('.search-results-form');
  if (!$searchForm.length) {
    return;
  }
  var $toggleAssistanceButton = jQuery('<button>').addClass('toggleAssistant').attr('type', 'button').attr('aria-expanded', 'false').text(LANG.search_toggle_tools).prependTo($searchForm.find('fieldset'));
  $toggleAssistanceButton.on('click', function () {
    jQuery('.advancedOptions').toggle(0, function () {
      var $me = jQuery(this);
      if ($me.attr('aria-hidden')) {
        $me.removeAttr('aria-hidden');
        $toggleAssistanceButton.attr('aria-expanded', 'true');
        DokuCookie.setValue('sa', 'on');
      } else {
        $me.attr('aria-hidden', 'true');
        $toggleAssistanceButton.attr('aria-expanded', 'false');
        DokuCookie.setValue('sa', 'off');
      }
    });
  });
  if (DokuCookie.getValue('sa') === 'on') {
    $toggleAssistanceButton.trigger('click');
  }
  $searchForm.find('.advancedOptions .toggle div.current').on('click', function () {
    var $me = jQuery(this);
    $me.parent().siblings().removeClass('open');
    $me.parent().siblings().find('ul:first').attr('aria-expanded', 'false');
    $me.parent().toggleClass('open');
    if ($me.parent().hasClass('open')) {
      $me.parent().find('ul:first').attr('aria-expanded', 'true');
    } else {
      $me.parent().find('ul:first').attr('aria-expanded', 'false');
    }
  });
});
jQuery.fn.dw_tree = function (overrides) {
  var dw_tree = {
    throbber_delay: 500,
    $obj: this,
    toggle_selector: 'a.idx_dir',
    init: function () {
      this.$obj.on('click', this.toggle_selector, this, this.toggle);
      jQuery('ul:first', this.$obj).attr('role', 'tree');
      jQuery('ul', this.$obj).not(':first').attr('role', 'group');
      jQuery('li', this.$obj).attr('role', 'treeitem');
      jQuery('li.open > ul', this.$obj).attr('aria-expanded', 'true');
      jQuery('li.closed > ul', this.$obj).attr('aria-expanded', 'false');
      jQuery('li.closed', this.$obj).attr('aria-live', 'assertive');
    },
    toggle: function (e) {
      var $listitem, $sublist, timeout, $clicky, show_sublist, dw_tree, opening;
      e.preventDefault();
      dw_tree = e.data;
      $clicky = jQuery(this);
      $listitem = $clicky.closest('li');
      $sublist = $listitem.find('ul').first();
      opening = $listitem.hasClass('closed');
      dw_tree.toggle_display($clicky, opening);
      if ($sublist.is(':visible')) {
        $listitem.removeClass('open').addClass('closed');
        $sublist.attr('aria-expanded', 'false');
      } else {
        $listitem.removeClass('closed').addClass('open');
        $sublist.attr('aria-expanded', 'true');
      }
      if (!opening) {
        $sublist.dw_hide();
        return;
      }
      show_sublist = function (data) {
        $sublist.hide();
        if (typeof data !== 'undefined') {
          $sublist.html(data);
          $sublist.parent().attr('aria-busy', 'false').removeAttr('aria-live');
          jQuery('li.closed', $sublist).attr('aria-live', 'assertive');
        }
        if ($listitem.hasClass('open')) {
          $sublist.dw_show();
        }
      };
      if ($sublist.length > 0) {
        show_sublist();
        return;
      }
      $sublist = jQuery('<ul class="idx" role="group"/>');
      $listitem.append($sublist);
      timeout = window.setTimeout(bind(show_sublist, '<li aria-busy="true"><img src="' + DOKU_BASE + 'lib/images/throbber.gif" alt="loading..." title="loading..." /></li>'), dw_tree.throbber_delay);
      dw_tree.load_data(function (data) {
        window.clearTimeout(timeout);
        show_sublist(data);
      }, $clicky);
    },
    toggle_display: function ($clicky, opening) { },
    load_data: function (show_data, $clicky) {
      show_data();
    }
  };
  jQuery.extend(dw_tree, overrides);
  if (!overrides.deferInit) {
    dw_tree.init();
  }
  return dw_tree;
};
var dw_index = jQuery('#index__tree').dw_tree({
  deferInit: true,
  load_data: function (show_sublist, $clicky) {
    jQuery.post(DOKU_BASE + 'lib/exe/ajax.php', $clicky[0].search.substr(1) + '&call=index', show_sublist, 'html');
  }
});
jQuery(function () {
  var $tree = jQuery('#index__tree');
  dw_index.$obj = $tree;
  dw_index.init();
});

function selection_class() {
  this.start = 0;
  this.end = 0;
  this.obj = null;
  this.scroll = 0;
  this.fix = 0;
  this.getLength = function () {
    return this.end - this.start;
  };
  this.getText = function () {
    return (!this.obj) ? '' : this.obj.value.substring(this.start, this.end);
  };
}

function DWgetSelection(textArea) {
  var sel = new selection_class();
  textArea.focus();
  sel.obj = textArea;
  sel.start = textArea.selectionStart;
  sel.end = textArea.selectionEnd;
  sel.scroll = textArea.scrollTop;
  return sel;
}

function DWsetSelection(selection) {
  selection.obj.setSelectionRange(selection.start, selection.end);
  if (selection.scroll) selection.obj.scrollTop = selection.scroll;
}

function pasteText(selection, text, opts) {
  if (!opts) opts = {};
  selection.obj.value = selection.obj.value.substring(0, selection.start) + text + selection.obj.value.substring(selection.end, selection.obj.value.length);
  if (is_opera) {
    selection.end = selection.start + text.replace(/\r?\n/g, '\r\n').length;
  } else {
    selection.end = selection.start + text.length;
  }
  if (opts.startofs) selection.start += opts.startofs;
  if (opts.endofs) selection.end -= opts.endofs;
  if (opts.nosel) selection.start = selection.end;
  DWsetSelection(selection);
}

function insertTags(textAreaID, tagOpen, tagClose, sampleText) {
  var txtarea = jQuery('#' + textAreaID)[0];
  var selection = DWgetSelection(txtarea);
  var text = selection.getText();
  var opts;
  if (text.charAt(text.length - 1) == ' ') {
    selection.end--;
    text = selection.getText();
  }
  if (!text) {
    text = sampleText;
    opts = {
      startofs: tagOpen.length,
      endofs: tagClose.length
    };
  } else {
    opts = {
      nosel: true
    };
  }
  text = tagOpen + text + tagClose;
  pasteText(selection, text, opts);
}

function insertAtCarret(textAreaID, text) {
  var txtarea = jQuery('#' + textAreaID)[0];
  var selection = DWgetSelection(txtarea);
  pasteText(selection, text, {
    nosel: true
  });
}
var pickercounter = 0;

function initToolbar(tbid, edid, tb, allowblock) {
  var $toolbar, $edit;
  if (typeof tbid == 'string') {
    $toolbar = jQuery('#' + tbid);
  } else {
    $toolbar = jQuery(tbid);
  }
  $edit = jQuery('#' + edid);
  if ($toolbar.length == 0 || $edit.length == 0 || $edit.attr('readOnly')) {
    return;
  }
  if (typeof allowblock === 'undefined') {
    allowblock = true;
  }
  $toolbar.html('');
  jQuery.each(tb, function (k, val) {
    if (!tb.hasOwnProperty(k) || (!allowblock && val.block === true)) {
      return;
    }
    var actionFunc, $btn;
    $btn = jQuery(createToolButton(val.icon, val.title, val.key, val.id, val['class']));
    actionFunc = 'tb_' + val.type;
    if (jQuery.isFunction(window[actionFunc])) {
      $btn.on('click', bind(window[actionFunc], $btn, val, edid));
      $toolbar.append($btn);
      return;
    }
    actionFunc = 'addBtnAction' + val.type.charAt(0).toUpperCase() + val.type.substring(1);
    if (jQuery.isFunction(window[actionFunc])) {
      var pickerid = window[actionFunc]($btn, val, edid);
      if (pickerid !== '') {
        $toolbar.append($btn);
        $btn.attr('aria-controls', pickerid);
        if (actionFunc === 'addBtnActionPicker') {
          $btn.attr('aria-haspopup', 'true');
        }
      }
      return;
    }
    alert('unknown toolbar type: ' + val.type + '  ' + actionFunc);
  });
}

function tb_format(btn, props, edid) {
  var sample = props.sample || props.title;
  insertTags(edid, fixtxt(props.open), fixtxt(props.close), fixtxt(sample));
  pickerClose();
  return false;
}

function tb_formatln(btn, props, edid) {
  var sample = props.sample || props.title,
    opts, selection = DWgetSelection(jQuery('#' + edid)[0]);
  sample = fixtxt(sample);
  props.open = fixtxt(props.open);
  props.close = fixtxt(props.close);
  if (selection.getLength()) {
    sample = selection.getText();
    opts = {
      nosel: true
    };
  } else {
    opts = {
      startofs: props.open.length,
      endofs: props.close.length
    };
  }
  sample = sample.split("\n").join(props.close + "\n" + props.open);
  sample = props.open + sample + props.close;
  pasteText(selection, sample, opts);
  pickerClose();
  return false;
}

function tb_insert(btn, props, edid) {
  insertAtCarret(edid, fixtxt(props.insert));
  pickerClose();
  return false;
}

function tb_mediapopup(btn, props, edid) {
  window.open(DOKU_BASE + props.url + encodeURIComponent(NS) + '&edid=' + encodeURIComponent(edid), props.name, props.options);
  return false;
}

function tb_autohead(btn, props, edid) {
  var lvl = currentHeadlineLevel(edid),
    tags;
  lvl += props.mod;
  if (lvl < 1) lvl = 1;
  if (lvl > 5) lvl = 5;
  tags = (new Array(8 - lvl)).join('=');
  insertTags(edid, tags + ' ', ' ' + tags + "\n", props.text);
  pickerClose();
  return false;
}

function addBtnActionPicker($btn, props, edid) {
  var pickerid = 'picker' + (pickercounter++);
  var picker = createPicker(pickerid, props, edid);
  jQuery(picker).attr('aria-hidden', 'true');
  $btn.click(function (e) {
    pickerToggle(pickerid, $btn);
    e.preventDefault();
    return '';
  });
  return pickerid;
}

function addBtnActionLinkwiz($btn, props, edid) {
  dw_linkwiz.init(jQuery('#' + edid));
  jQuery($btn).click(function (e) {
    dw_linkwiz.val = props;
    dw_linkwiz.toggle();
    e.preventDefault();
    return '';
  });
  return 'link__wiz';
}

function pickerToggle(pickerid, $btn) {
  var $picker = jQuery('#' + pickerid),
    pos = $btn.offset();
  if ($picker.hasClass('a11y')) {
    $picker.removeClass('a11y').attr('aria-hidden', 'false');
  } else {
    $picker.addClass('a11y').attr('aria-hidden', 'true');
  }
  var picker_left = pos.left + 3,
    picker_width = $picker.width(),
    window_width = jQuery(window).width();
  if (picker_width > 300) {
    $picker.css("max-width", "300");
    picker_width = 300;
  }
  if ((picker_left + picker_width + 40) > window_width) {
    picker_left = window_width - picker_width - 40;
  }
  if (picker_left < 0) {
    picker_left = 0;
  }
  $picker.offset({
    left: picker_left,
    top: pos.top + $btn[0].offsetHeight + 3
  });
}

function pickerClose() {
  jQuery('.picker').addClass('a11y');
}

function fixtxt(str) {
  return str.replace(/\\n/g, "\n");
}
jQuery(function () {
  initToolbar('tool__bar', 'wiki__text', toolbar);
  jQuery('#tool__bar').attr('role', 'toolbar');
});

function createToolButton(icon, label, key, id, classname) {
  var $btn = jQuery(document.createElement('button')),
    $ico = jQuery(document.createElement('img'));
  $btn.addClass('toolbutton');
  if (classname) {
    $btn.addClass(classname);
  }
  $btn.attr('title', label).attr('aria-controls', 'wiki__text');
  if (key) {
    $btn.attr('title', label + ' [' + key.toUpperCase() + ']').attr('accessKey', key);
  }
  if (id) {
    $btn.attr('id', id);
    $ico.attr('id', id + '_ico');
  }
  if (icon.substr(0, 1) !== '/') {
    icon = DOKU_BASE + 'lib/images/toolbar/' + icon;
  }
  $ico.attr('src', icon);
  $ico.attr('alt', '');
  $ico.attr('width', 16);
  $ico.attr('height', 16);
  $btn.append($ico);
  return $btn[0];
}

function createPicker(id, props, edid) {
  var $picker = jQuery(document.createElement('div'));
  $picker.addClass('picker a11y');
  if (props['class']) {
    $picker.addClass(props['class']);
  }
  $picker.attr('id', id).css('position', 'absolute');

  function $makebutton(title) {
    var $btn = jQuery(document.createElement('button')).addClass('pickerbutton').attr('title', title).attr('aria-controls', edid).on('click', bind(pickerInsert, title, edid)).appendTo($picker);
    return $btn;
  }
  jQuery.each(props.list, function (key, item) {
    if (!props.list.hasOwnProperty(key)) {
      return;
    }
    if (isNaN(key)) {
      if (item.substr(0, 1) !== '/') {
        item = DOKU_BASE + 'lib/images/' + props.icobase + '/' + item;
      }
      jQuery(document.createElement('img')).attr('src', item).attr('alt', '').css('height', '16').appendTo($makebutton(key));
    } else if (typeof item == 'string') {
      $makebutton(item).text(item);
    } else {
      initToolbar($picker, edid, props.list);
      return false;
    }
  });
  jQuery('body').append($picker);
  return $picker[0];
}

function pickerInsert(text, edid) {
  insertAtCarret(edid, text);
  pickerClose();
}

function addBtnActionSignature($btn, props, edid) {
  if (typeof SIG != 'undefined' && SIG != '') {
    $btn.on('click', function (e) {
      insertAtCarret(edid, SIG);
      e.preventDefault();
    });
    return edid;
  }
  return '';
}

function currentHeadlineLevel(textboxId) {
  var field = jQuery('#' + textboxId)[0],
    s = false,
    opts = [field.value.substr(0, DWgetSelection(field).start)];
  if (field.form && field.form.prefix) {
    opts.push(field.form.prefix.value);
  }
  jQuery.each(opts, function (_, opt) {
    var str = "\n" + opt,
      lasthl = str.lastIndexOf("\n==");
    if (lasthl !== -1) {
      s = str.substr(lasthl + 1, 6);
      return false;
    }
  });
  if (s === false) {
    return 0;
  }
  return 7 - s.match(/^={2,6}/)[0].length;
}
window.textChanged = false;
window.doku_edit_text_content = '';

function deleteDraft() {
  if (is_opera || window.keepDraft) {
    return;
  }
  var $dwform = jQuery('#dw__editform');
  if ($dwform.length === 0) {
    return;
  }
  jQuery.post(DOKU_BASE + 'lib/exe/ajax.php', {
    call: 'draftdel',
    id: $dwform.find('input[name=id]').val(),
    sectok: $dwform.find('input[name=sectok]').val()
  });
}
jQuery(function () {
  var $editform = jQuery('#dw__editform');
  if ($editform.length == 0) {
    return;
  }
  var $edit_text = jQuery('#wiki__text');
  if ($edit_text.length > 0) {
    if ($edit_text.attr('readOnly')) {
      return;
    }
    var sel = DWgetSelection($edit_text[0]);
    sel.start = 0;
    sel.end = 0;
    DWsetSelection(sel);
    $edit_text.trigger('focus');
    doku_edit_text_content = $edit_text.val();
  }
  var changeHandler = function () {
    doku_hasTextBeenModified();
    doku_summaryCheck();
  };
  $editform.change(changeHandler);
  $editform.keydown(changeHandler);
  window.onbeforeunload = function () {
    if (window.textChanged) {
      return LANG.notsavedyet;
    }
  };
  window.onunload = deleteDraft;
  jQuery('#edbtn__save').on('click', function () {
    window.onbeforeunload = '';
    textChanged = false;
  });
  jQuery('#edbtn__preview').on('click', function () {
    window.onbeforeunload = '';
    textChanged = false;
    window.keepDraft = true;
  });
  var $summary = jQuery('#edit__summary');
  $summary.on('change keyup', doku_summaryCheck);
  if (textChanged) doku_summaryCheck();
});

function doku_hasTextBeenModified() {
  if (!textChanged) {
    var $edit_text = jQuery('#wiki__text');
    if ($edit_text.length > 0) {
      textChanged = doku_edit_text_content != $edit_text.val();
    } else {
      textChanged = true;
    }
  }
}

function doku_summaryCheck() {
  var $sum = jQuery('#edit__summary'),
    missing = $sum.val() === '';
  $sum.toggleClass('missing', missing).toggleClass('edit', !missing);
}
var dw_editor = {
  init: function () {
    var $editor = jQuery('#wiki__text');
    if ($editor.length === 0) {
      return;
    }
    dw_editor.initSizeCtl('#size__ctl', $editor);
    if ($editor.attr('readOnly')) {
      return;
    }
    $editor.keydown(dw_editor.keyHandler);
  },
  initSizeCtl: function (ctlarea, editor) {
    var $ctl = jQuery(ctlarea),
      $textarea = jQuery(editor);
    if ($ctl.length === 0 || $textarea.length === 0) {
      return;
    }
    $textarea.css('height', DokuCookie.getValue('sizeCtl') || '300px');
    var wrp = DokuCookie.getValue('wrapCtl');
    if (wrp) {
      dw_editor.setWrap($textarea[0], wrp);
    }
    jQuery.each([
      ['larger', function () {
        dw_editor.sizeCtl(editor, 100);
      }],
      ['smaller', function () {
        dw_editor.sizeCtl(editor, -100);
      }],
      ['wrap', function () {
        dw_editor.toggleWrap(editor);
      }]
    ], function (_, img) {
      jQuery(document.createElement('img')).attr('src', DOKU_BASE + 'lib/images/' + img[0] + '.gif').attr('alt', '').on('click', img[1]).appendTo($ctl);
    });
  },
  sizeCtl: function (editor, val) {
    var $textarea = jQuery(editor),
      height = parseInt($textarea.css('height')) + val;
    $textarea.css('height', height + 'px');
    DokuCookie.setValue('sizeCtl', $textarea.css('height'));
  },
  toggleWrap: function (editor) {
    var $textarea = jQuery(editor),
      wrap = $textarea.attr('wrap');
    dw_editor.setWrap($textarea[0], (wrap && wrap.toLowerCase() == 'off') ? 'soft' : 'off');
    DokuCookie.setValue('wrapCtl', $textarea.attr('wrap'));
  },
  setWrap: function (textarea, wrapAttrValue) {
    textarea.setAttribute('wrap', wrapAttrValue);
    var parNod = textarea.parentNode;
    var nxtSib = textarea.nextSibling;
    parNod.removeChild(textarea);
    parNod.insertBefore(textarea, nxtSib);
  },
  keyHandler: function (e) {
    if (jQuery.inArray(e.keyCode, [8, 10, 13, 32]) === -1) {
      return;
    }
    var selection = DWgetSelection(this);
    if (selection.getLength() > 0) {
      return;
    }
    var search = "\n" + this.value.substr(0, selection.start);
    var linestart = Math.max(search.lastIndexOf("\n"), search.lastIndexOf("\r"));
    search = search.substr(linestart);
    if ((e.keyCode == 13 || e.keyCode == 10) && e.ctrlKey) {
      jQuery('#edbtn__save').trigger('click');
      e.preventDefault();
      return false;
    } else if (e.keyCode == 13) {
      var match = search.match(/(\n  +([\*-] ?)?)/);
      if (match) {
        var scroll = this.scrollHeight;
        var match2 = search.match(/^\n  +[\*-]\s*$/);
        if (match2 && this.value.substr(selection.start).match(/^($|\r?\n)/)) {
          this.value = this.value.substr(0, linestart) + "\n" + this.value.substr(selection.start);
          selection.start = linestart + 1;
          selection.end = linestart + 1;
          DWsetSelection(selection);
        } else {
          insertAtCarret(this.id, match[1]);
        }
        this.scrollTop += (this.scrollHeight - scroll);
        e.preventDefault();
        return false;
      }
    } else if (e.keyCode == 8) {
      var match = search.match(/(\n  +)([*-] ?)$/);
      if (match) {
        var spaces = match[1].length - 1;
        if (spaces > 3) {
          this.value = this.value.substr(0, linestart) + this.value.substr(linestart + 2);
          selection.start = selection.start - 2;
          selection.end = selection.start;
        } else {
          this.value = this.value.substr(0, linestart) + this.value.substr(selection.start);
          selection.start = linestart;
          selection.end = linestart;
        }
        DWsetSelection(selection);
        e.preventDefault();
        return false;
      }
    } else if (e.keyCode == 32) {
      var match = search.match(/(\n  +)([*-] )$/);
      if (match) {
        this.value = this.value.substr(0, linestart) + '  ' + this.value.substr(linestart);
        selection.start = selection.start + 2;
        selection.end = selection.start;
        DWsetSelection(selection);
        e.preventDefault();
        return false;
      }
    }
  }
};
jQuery(dw_editor.init);
var dw_locktimer = {
  timeout: 0,
  draft: false,
  timerID: null,
  lasttime: null,
  msg: LANG.willexpire,
  pageid: '',
  fieldsToSaveAsDraft: ['input[name=prefix]', 'textarea[name=wikitext]', 'input[name=suffix]', 'input[name=date]',],
  callbacks: [],
  init: function (timeout, draft, edid) {
    var $edit;
    edid = edid || 'wiki__text';
    $edit = jQuery('#' + edid);
    if ($edit.length === 0 || $edit.attr('readonly')) {
      return;
    }
    dw_locktimer.timeout = timeout * 1000;
    dw_locktimer.draft = draft;
    dw_locktimer.lasttime = new Date();
    dw_locktimer.pageid = jQuery('#dw__editform').find('input[name=id]').val();
    if (!dw_locktimer.pageid) {
      return;
    }
    $edit.keypress(dw_locktimer.refresh);
    dw_locktimer.reset();
  },
  addField: function (selector) {
    dw_locktimer.fieldsToSaveAsDraft.push(selector);
  },
  addRefreshCallback: function (callback) {
    dw_locktimer.callbacks.push(callback);
  },
  reset: function () {
    dw_locktimer.clear();
    dw_locktimer.timerID = window.setTimeout(dw_locktimer.warning, dw_locktimer.timeout);
  },
  warning: function () {
    dw_locktimer.clear();
    alert(fixtxt(dw_locktimer.msg));
  },
  clear: function () {
    if (dw_locktimer.timerID !== null) {
      window.clearTimeout(dw_locktimer.timerID);
      dw_locktimer.timerID = null;
    }
  },
  refresh: function () {
    var now = new Date(),
      params = 'call=lock&id=' + dw_locktimer.pageid + '&';
    if (now.getTime() - dw_locktimer.lasttime.getTime() <= 30 * 1000) {
      return;
    }
    if (dw_locktimer.draft && jQuery('#dw__editform').find('textarea[name=wikitext]').length > 0) {
      params += jQuery('#dw__editform').find(dw_locktimer.fieldsToSaveAsDraft.join(', ')).serialize();
    }
    jQuery.post(DOKU_BASE + 'lib/exe/ajax.php', params, null, 'json').done(function dwLocktimerRefreshDoneHandler(data) {
      dw_locktimer.callbacks.forEach(function (callback) {
        callback(data);
      });
    });
    dw_locktimer.lasttime = now;
  },
  refreshed: function (data) {
    if (data.errors.length) {
      data.errors.forEach(function (error) {
        jQuery('#draft__status').after(jQuery('<div class="error"></div>').text(error));
      })
    }
    jQuery('#draft__status').html(data.draft);
    if (data.lock !== '1') {
      return;
    }
    dw_locktimer.reset();
  }
};
dw_locktimer.callbacks.push(dw_locktimer.refreshed);
class LinkWizard {
  $wiz = null;
  $entry = null;
  result = null;
  timer = null;
  textArea = null;
  selected = -1;
  selection = null;
  val = {
    open: '[[',
    close: ']]'
  };
  init($editor) {
    const pos = $editor.position();
    if (this.$wiz) return;
    this.$wiz = jQuery(document.createElement('div')).dialog({
      autoOpen: false,
      draggable: true,
      title: LANG.linkwiz,
      resizable: false
    }).html('<div>' + LANG.linkto + ' <input type="text" class="edit" id="link__wiz_entry" autocomplete="off" /></div>' + '<div id="link__wiz_result"></div>').parent().attr('id', 'link__wiz').css({
      'position': 'absolute',
      'top': (pos.top + 20) + 'px',
      'left': (pos.left + 80) + 'px'
    }).hide().appendTo('.dokuwiki:first');
    this.textArea = $editor[0];
    this.result = jQuery('#link__wiz_result')[0];
    jQuery(this.result).css('position', 'relative');
    this.$entry = jQuery('#link__wiz_entry');
    if (JSINFO.namespace) {
      this.$entry.val(JSINFO.namespace + ':');
    }
    jQuery('#link__wiz .ui-dialog-titlebar-close').on('click', () => this.hide());
    this.$entry.keyup((e) => this.onEntry(e));
    jQuery(this.result).on('click', 'a', (e) => this.onResultClick(e));
  }
  onEntry(e) {
    if (e.key === 'ArrowLeft' || e.key === 'ArrowRight') {
      return true;
    }
    if (e.key === 'Escape') {
      this.hide();
      e.preventDefault();
      e.stopPropagation();
      return false;
    }
    if (e.key === 'ArrowUp') {
      this.select(this.selected - 1);
      e.preventDefault();
      e.stopPropagation();
      return false;
    }
    if (e.key === 'ArrowDown') {
      this.select(this.selected + 1);
      e.preventDefault();
      e.stopPropagation();
      return false;
    }
    if (e.key === 'Enter') {
      if (this.selected > -1) {
        const $obj = this.$getResult(this.selected);
        if ($obj.length > 0) {
          this.resultClick($obj.find('a')[0]);
        }
      } else if (this.$entry.val()) {
        this.insertLink(this.$entry.val());
      }
      e.preventDefault();
      e.stopPropagation();
      return false;
    }
    this.autocomplete();
  }
  $getResult(num) {
    return jQuery(this.result).find('div').eq(num);
  }
  select(num) {
    if (num < 0) {
      this.deselect();
      return;
    }
    const $obj = this.$getResult(num);
    if ($obj.length === 0) {
      return;
    }
    this.deselect();
    $obj.addClass('selected');
    const childPos = $obj.position().top;
    const yDiff = childPos + $obj.outerHeight() - jQuery(this.result).innerHeight();
    if (childPos < 0) {
      jQuery(this.result)[0].scrollTop += childPos;
    } else if (yDiff > 0) {
      jQuery(this.result)[0].scrollTop += yDiff;
    }
    this.selected = num;
  }
  deselect() {
    if (this.selected > -1) {
      this.$getResult(this.selected).removeClass('selected');
    }
    this.selected = -1;
  }
  onResultClick(e) {
    if (!jQuery(e.target).is('a')) {
      return;
    }
    e.stopPropagation();
    e.preventDefault();
    this.resultClick(e.target);
    return false;
  }
  resultClick(a) {
    this.$entry.val(a.title);
    if (a.title === '' || a.title.charAt(a.title.length - 1) === ':') {
      this.autocomplete_exec();
    } else {
      if (jQuery(a.nextSibling).is('span')) {
        this.insertLink(a.nextSibling.innerText);
      } else {
        this.insertLink('');
      }
    }
  }
  insertLink(title) {
    let link = this.$entry.val();
    let selection;
    let linkTitle;
    if (!link) {
      return;
    }
    selection = DWgetSelection(this.textArea);
    if (selection.start === 0 && selection.end === 0) {
      selection = this.selection;
    }
    linkTitle = selection.getText();
    if (linkTitle.charAt(linkTitle.length - 1) === ' ') {
      selection.end--;
      linkTitle = selection.getText();
    }
    if (!linkTitle && !DOKU_UHC) {
      linkTitle = title;
    }
    const syntax = this.createLinkSyntax(link, linkTitle);
    pasteText(selection, syntax.link, syntax);
    this.hide();
    const externallinkpattern = new RegExp('^((f|ht)tps?:)?//', 'i');
    let entry_value;
    if (externallinkpattern.test(this.$entry.val())) {
      if (JSINFO.namespace) {
        entry_value = JSINFO.namespace + ':';
      } else {
        entry_value = '';
      }
    } else {
      entry_value = this.$entry.val().replace(/[^:]*$/, '')
    }
    this.$entry.val(entry_value);
  }
  createLinkSyntax(id, title) {
    let link = id;
    if (!id.match(/^(f|ht)tps?:\/\//i)) {
      const refId = this.textArea.form.id.value;
      link = LinkWizard.createRelativeID(refId, id);
    }
    let startofs = link.length;
    let endofs = 0;
    if (this.val.open) {
      startofs += this.val.open.length;
      link = this.val.open + link;
    }
    link += '|';
    startofs += 1;
    if (title) {
      link += title;
    }
    if (this.val.close) {
      link += this.val.close;
      endofs = this.val.close.length;
    }
    return {
      link,
      startofs,
      endofs
    };
  }
  autocomplete() {
    if (this.timer !== null) {
      window.clearTimeout(this.timer);
      this.timer = null;
    }
    this.timer = window.setTimeout(() => this.autocomplete_exec(), 350);
  }
  autocomplete_exec() {
    const $res = jQuery(this.result);
    this.deselect();
    $res.html('<img src="' + DOKU_BASE + 'lib/images/throbber.gif" alt="" width="16" height="16" />').load(DOKU_BASE + 'lib/exe/ajax.php', {
      call: 'linkwiz',
      q: this.$entry.val()
    });
  }
  show() {
    this.selection = DWgetSelection(this.textArea);
    this.$wiz.show();
    this.$entry.focus();
    this.autocomplete();
    const temp = this.$entry.val();
    this.$entry.val('');
    this.$entry.val(temp);
  }
  hide() {
    this.$wiz.hide();
    this.textArea.focus();
  }
  toggle() {
    if (this.$wiz.css('display') === 'none') {
      this.show();
    } else {
      this.hide();
    }
  }
  static createRelativeID(ref, id) {
    const sourceNs = ref.split(':');
    [] = sourceNs.pop();
    const targetNs = id.split(':');
    const targetPage = targetNs.pop();
    const relativeID = [];
    let commonPrefixLength = 0;
    while (commonPrefixLength < sourceNs.length && commonPrefixLength < targetNs.length && sourceNs[commonPrefixLength] === targetNs[commonPrefixLength]) {
      commonPrefixLength++;
    }
    if (sourceNs.length) {
      if (commonPrefixLength) {
        if (commonPrefixLength === sourceNs.length && commonPrefixLength === targetNs.length) { } else if (commonPrefixLength < sourceNs.length) {
          relativeID.push(...Array(sourceNs.length - commonPrefixLength).fill('..'));
        } else {
          relativeID.push('.');
        }
      } else if (targetNs.length === 0) {
        relativeID.push('');
      }
      relativeID.push(...targetNs.slice(commonPrefixLength));
    } else {
      relativeID.push(...targetNs);
    }
    relativeID.push(targetPage);
    return relativeID.join(':');
  }
}
window.dw_linkwiz = new LinkWizard();
var dw_mediamanager = {
  keepopen: false,
  hide: false,
  popup: false,
  display: false,
  ext: false,
  $popup: null,
  align: false,
  link: false,
  size: false,
  forbidden_opts: {},
  view_opts: {
    list: false,
    sort: false
  },
  layout_width: 0,
  minHeights: {
    thumbs: 200,
    rows: 100
  },
  init: function () {
    var $content, $tree;
    $content = jQuery('#media__content');
    $tree = jQuery('#media__tree');
    if (!$tree.length) return;
    dw_mediamanager.prepare_content($content);
    dw_mediamanager.attachoptions();
    dw_mediamanager.initpopup();
    $content.on('change', '#upload__file', dw_mediamanager.suggest).on('click', 'a.select', dw_mediamanager.select).on('click', '#media__content a.btn_media_delete', dw_mediamanager.confirmattach).on('submit', '#mediamanager__done_form', dw_mediamanager.list);
    $tree.dw_tree({
      toggle_selector: 'img',
      load_data: function (show_sublist, $clicky) {
        var $link = $clicky.parent().find('div.li a.idx_dir');
        jQuery.post(DOKU_BASE + 'lib/exe/ajax.php', $link[0].search.substr(1) + '&call=medians', show_sublist, 'html');
      },
      toggle_display: function ($clicky, opening) {
        $clicky.attr('src', DOKU_BASE + 'lib/images/' + (opening ? 'minus' : 'plus') + '.gif');
      }
    });
    $tree.on('click', 'a', dw_mediamanager.list);
    dw_mediamanager.set_fileview_list();
    dw_mediamanager.init_options();
    dw_mediamanager.image_diff();
    dw_mediamanager.init_ajax_uploader();
    var $page = jQuery('#mediamanager__page');
    $page.find('div.filelist').on('click', 'ul.tabs a', dw_mediamanager.list).on('click', 'div.panelContent a', dw_mediamanager.details).on('submit', '#dw__mediasearch', dw_mediamanager.list).on('change', '#upload__file', dw_mediamanager.suggest).on('click', '.qq-upload-file a', dw_mediamanager.details);
    $page.find('div.file').on('click', 'ul.tabs a', dw_mediamanager.details).on('submit', '#mediamanager__btn_update', dw_mediamanager.list).on('submit', '#page__revisions', dw_mediamanager.details).on('click', '#page__revisions a', dw_mediamanager.details).on('submit', '#mediamanager__save_meta', dw_mediamanager.details).on('submit', '#mediamanager__btn_delete', dw_mediamanager.details).on('submit', '#mediamanager__btn_restore', dw_mediamanager.details).on('submit', '.btn_newer, .btn_older', dw_mediamanager.details);
    dw_mediamanager.resize();
    dw_mediamanager.update_resizable();
    dw_mediamanager.layout_width = $page.width();
    jQuery(window).on('resize', dw_mediamanager.window_resize);
  },
  init_options: function () {
    var $options = jQuery('div.filelist div.panelHeader form.options'),
      $listType, $sortBy, $both;
    if ($options.length === 0) {
      return;
    }
    $listType = $options.find('li.listType');
    $sortBy = $options.find('li.sortBy');
    $both = $listType.add($sortBy);
    $options.find('button[type=submit]').parent().hide();
    $both.find('label').each(function () {
      var $this = jQuery(this);
      $this.children('input').appendTo($this.parent());
    });
    $both.find("input[type='radio']").checkboxradio({
      icon: false
    });
    $both.controlgroup();
    $listType.children('input').change(function () {
      dw_mediamanager.set_fileview_list();
    });
    $sortBy.children('input').change(function (event) {
      dw_mediamanager.set_fileview_sort();
      dw_mediamanager.list.call(jQuery('#dw__mediasearch')[0] || this, event);
    });
  },
  initpopup: function () {
    var opts, $insp, $insbtn;
    dw_mediamanager.$popup = jQuery(document.createElement('div')).attr('id', 'media__popup_content').dialog({
      autoOpen: false,
      width: 280,
      modal: true,
      draggable: true,
      title: LANG.mediatitle,
      resizable: false
    });
    opts = [{
      id: 'link',
      label: LANG.mediatarget,
      btns: ['lnk', 'direct', 'nolnk', 'displaylnk']
    }, {
      id: 'align',
      label: LANG.mediaalign,
      btns: ['noalign', 'left', 'center', 'right']
    }, {
      id: 'size',
      label: LANG.mediasize,
      btns: ['small', 'medium', 'large', 'original']
    }];
    jQuery.each(opts, function (_, opt) {
      var $p, $l;
      $p = jQuery(document.createElement('p')).attr('id', 'media__' + opt.id);
      if (dw_mediamanager.display === "2") {
        $p.hide();
      }
      $l = jQuery(document.createElement('label')).text(opt.label);
      $p.append($l);
      jQuery.each(opt.btns, function (i, text) {
        var $btn, $img;
        $btn = jQuery(document.createElement('button')).addClass('button').attr('id', "media__" + opt.id + "btn" + (i + 1)).attr('title', LANG['media' + text]).on('click', bind(dw_mediamanager.setOpt, opt.id));
        $img = jQuery(document.createElement('img')).attr('src', DOKU_BASE + 'lib/images/media_' + opt.id + '_' + text + '.png');
        $btn.append($img);
        $p.append($btn);
      });
      dw_mediamanager.$popup.append($p);
    });
    $insp = jQuery(document.createElement('p'));
    dw_mediamanager.$popup.append($insp);
    $insbtn = jQuery(document.createElement('input')).attr('id', 'media__sendbtn').attr('type', 'button').addClass('button').val(LANG.mediainsert);
    $insp.append($insbtn);
  },
  insert: function (id) {
    var opts, cb, edid, s;
    dw_mediamanager.$popup.dialog('close');
    opts = '';
    if ({
      img: 1,
      swf: 1
    }[dw_mediamanager.ext] === 1) {
      if (dw_mediamanager.link === '4') {
        opts = '?linkonly';
      } else {
        if (dw_mediamanager.link === "3" && dw_mediamanager.ext === 'img') {
          opts = '?nolink';
        } else if (dw_mediamanager.link === "2" && dw_mediamanager.ext === 'img') {
          opts = '?direct';
        }
        s = parseInt(dw_mediamanager.size, 10);
        var size = s * 200;
        if (s && s >= 1 && s < 4) {
          opts += (opts.length) ? '&' : '?';
          opts += size;
          if (dw_mediamanager.ext === 'swf') {
            switch (s) {
              case 1:
                opts += 'x62';
                break;
              case 2:
                opts += 'x123';
                break;
              case 3:
                opts += 'x185';
                break;
            }
          }
        }
      }
    }
    edid = String.prototype.match.call(document.location, /&edid=([^&]+)/);
    edid = edid ? edid[1] : 'wiki__text';
    cb = String.prototype.match.call(document.location, /&onselect=([^&]+)/);
    cb = cb ? cb[1].replace(/[^\w]+/, '') : 'dw_mediamanager_item_select';
    opener[cb](edid, id, opts, dw_mediamanager.align, dw_mediamanager.keepopen);
    if (!dw_mediamanager.keepopen) {
      window.close();
    }
    opener.focus();
    return false;
  },
  suggest: function () {
    var $file, $name, text;
    $file = jQuery(this);
    $name = jQuery('#upload__name');
    if ($name.val() != '') return;
    if (!$file.length || !$name.length) {
      return;
    }
    text = $file.val();
    text = text.substr(text.lastIndexOf('/') + 1);
    text = text.substr(text.lastIndexOf('\\') + 1);
    $name.val(text);
  },
  list: function (event) {
    var $link, $content, params;
    if (event) {
      event.preventDefault();
    }
    jQuery('div.success, div.info, div.error, div.notify').remove();
    $link = jQuery(this);
    $content = jQuery('#media__content');
    if ($content.length === 0) {
      $content = jQuery('div.filelist');
      if ($link.hasClass('idx_dir')) {
        jQuery('div.file').empty();
        jQuery('div.namespaces .selected').removeClass('selected');
        $link.addClass('selected');
      }
    }
    params = 'call=medialist&';
    if ($link[0].search) {
      params += $link[0].search.substr(1);
    } else if ($link.is('form')) {
      params += dw_mediamanager.form_params($link);
    } else if ($link.closest('form').length > 0) {
      params += dw_mediamanager.form_params($link.closest('form'));
    }
    dw_mediamanager.update_content($content, params);
  },
  form_params: function ($form) {
    if (!$form.length) return;
    var action = '';
    var i = $form[0].action.indexOf('?');
    if (i >= 0) {
      action = $form[0].action.substr(i + 1);
    }
    return action + '&' + $form.serialize();
  },
  set_fileview_list: function (new_type) {
    dw_mediamanager.set_fileview_opt(['list', 'listType', function (new_type) {
      jQuery('div.filelist div.panelContent ul').toggleClass('rows', new_type === 'rows').toggleClass('thumbs', new_type === 'thumbs');
    }], new_type);
  },
  set_fileview_sort: function (new_sort) {
    dw_mediamanager.set_fileview_opt(['sort', 'sortBy', function (new_sort) { }], new_sort);
  },
  set_fileview_opt: function (opt, new_val) {
    if (typeof new_val === 'undefined') {
      new_val = jQuery('form.options li.' + opt[1] + ' input').filter(':checked').val();
      if (typeof new_val === 'undefined') {
        new_val = 'thumbs';
      }
    }
    if (new_val !== dw_mediamanager.view_opts[opt[0]]) {
      opt[2](new_val);
      DokuCookie.setValue(opt[0], new_val);
      dw_mediamanager.view_opts[opt[0]] = new_val;
    }
  },
  details: function (event) {
    var $link, $content, params, update_list;
    $link = jQuery(this);
    event.preventDefault();
    jQuery('div.success, div.info, div.error, div.notify').remove();
    if ($link[0].id == 'mediamanager__btn_delete' && !confirm(LANG.del_confirm)) {
      return false;
    }
    if ($link[0].id == 'mediamanager__btn_restore' && !confirm(LANG.restore_confirm)) {
      return false;
    }
    $content = jQuery('div.file');
    params = 'call=mediadetails&';
    if ($link[0].search) {
      params += $link[0].search.substr(1);
    } else if ($link.is('form')) {
      params += dw_mediamanager.form_params($link);
    } else if ($link.closest('form').length > 0) {
      params += dw_mediamanager.form_params($link.closest('form'));
    }
    update_list = ($link[0].id == 'mediamanager__btn_delete' || $link[0].id == 'mediamanager__btn_restore');
    dw_mediamanager.update_content($content, params, update_list);
  },
  update_content: function ($content, params, update_list) {
    var $container;
    jQuery.post(DOKU_BASE + 'lib/exe/ajax.php', params, function (data) {
      dw_mediamanager.$resizables().resizable('destroy');
      if (update_list) {
        dw_mediamanager.list.call(jQuery('#mediamanager__page').find('form.options button[type="submit"]')[0]);
      }
      $content.html(data);
      dw_mediamanager.prepare_content($content);
      dw_mediamanager.updatehide();
      dw_mediamanager.update_resizable();
      dw_behaviour.revisionBoxHandler();
      dw_mediamanager.set_fileview_list(dw_mediamanager.view_opts.list);
      dw_mediamanager.image_diff();
      dw_mediamanager.init_ajax_uploader();
      dw_mediamanager.init_options();
    }, 'html');
    $container = $content.find('div.panelContent');
    if ($container.length === 0) {
      $container = $content;
    }
    $container.html('<img src="' + DOKU_BASE + 'lib/images/throbber.gif" alt="..." class="load" />');
  },
  window_resize: function () {
    dw_mediamanager.opacity_slider();
    dw_mediamanager.portions_slider();
  },
  $resizables: function () {
    return jQuery('#mediamanager__page').find('div.namespaces, div.filelist');
  },
  update_resizable: function () {
    var $resizables = dw_mediamanager.$resizables();
    $resizables.resizable({
      handles: (jQuery('html[dir=rtl]').length ? 'w' : 'e'),
      resize: function (event, ui) {
        var $page = jQuery('#mediamanager__page');
        var widthFull = $page.width();
        var widthResizables = 0;
        $resizables.each(function () {
          widthResizables += jQuery(this).width();
        });
        var $filePanel = $page.find('div.panel.file');
        var widthOtherResizable = widthResizables - jQuery(this).width();
        var minWidthNonResizable = parseFloat($filePanel.css("min-width"));
        var maxWidth = widthFull - (widthOtherResizable + minWidthNonResizable) - 1;
        $resizables.resizable("option", "maxWidth", maxWidth);
        var relWidthNonResizable = 99.9 - (100 * widthResizables / widthFull);
        $filePanel.width(relWidthNonResizable + '%');
        dw_mediamanager.opacity_slider();
        dw_mediamanager.portions_slider();
      }
    });
  },
  resize: function () {
    jQuery('#mediamanager__page').find('div.panelContent').css('height', '60vh');
  },
  image_diff: function () {
    if (jQuery('#mediamanager__difftype').length) return;
    var $form = jQuery('#mediamanager__form_diffview');
    if (!$form.length) return;
    var $label = jQuery(document.createElement('label'));
    $label.append('<span>' + LANG.media_diff + '</span> ');
    var $select = jQuery(document.createElement('select')).attr('id', 'mediamanager__difftype').attr('name', 'difftype').change(dw_mediamanager.change_diff_type);
    $select.append(new Option(LANG.media_diff_both, "both"));
    $select.append(new Option(LANG.media_diff_opacity, "opacity"));
    $select.append(new Option(LANG.media_diff_portions, "portions"));
    $label.append($select);
    $form.append($label);
    var select = document.getElementById('mediamanager__difftype');
    select.options[0].text = LANG.media_diff_both;
    select.options[1].text = LANG.media_diff_opacity;
    select.options[2].text = LANG.media_diff_portions;
  },
  change_diff_type: function () {
    var $select = jQuery('#mediamanager__difftype');
    var $content = jQuery('#mediamanager__diff');
    var params = dw_mediamanager.form_params($select.closest('form')) + '&call=mediadiff';
    jQuery.post(DOKU_BASE + 'lib/exe/ajax.php', params, function (data) {
      $content.html(data);
      dw_mediamanager.portions_slider();
      dw_mediamanager.opacity_slider();
    }, 'html');
  },
  opacity_slider: function () {
    var $diff = jQuery("#mediamanager__diff");
    var $slider = $diff.find("div.slider");
    if (!$slider.length) return;
    var $image = $diff.find('div.imageDiff.opacity div.image1 img');
    if (!$image.length) return;
    $slider.width($image.width() - 20);
    $slider.slider();
    $slider.slider("option", "min", 0);
    $slider.slider("option", "max", 0.999);
    $slider.slider("option", "step", 0.001);
    $slider.slider("option", "value", 0.5);
    $slider.on("slide", function (event, ui) {
      jQuery('#mediamanager__diff').find('div.imageDiff.opacity div.image2 img').css({
        opacity: $slider.slider("option", "value")
      });
    });
  },
  portions_slider: function () {
    var $diff = jQuery("#mediamanager__diff");
    if (!$diff.length) return;
    var $image1 = $diff.find('div.imageDiff.portions div.image1 img');
    var $image2 = $diff.find('div.imageDiff.portions div.image2 img');
    if (!$image1.length || !$image2.length) return;
    $diff.width('100%');
    $image2.parent().width('97%');
    $image1.width('100%');
    $image2.width('100%');
    if ($image1.width() < $diff.width()) {
      $diff.width($image1.width());
    }
    $image2.parent().width('50%');
    $image2.width($image1.width());
    $image1.width($image1.width());
    var $slider = $diff.find("div.slider");
    if (!$slider.length) return;
    $slider.width($image1.width() - 20);
    $slider.slider();
    $slider.slider("option", "min", 0);
    $slider.slider("option", "max", 97);
    $slider.slider("option", "step", 1);
    $slider.slider("option", "value", 50);
    $slider.on("slide", function (event, ui) {
      jQuery('#mediamanager__diff').find('div.imageDiff.portions div.image2').css({
        width: $slider.slider("option", "value") + '%'
      });
    });
  },
  params_toarray: function (str) {
    var vars = [],
      hash;
    var hashes = str.split('&');
    for (var i = 0; i < hashes.length; i++) {
      hash = hashes[i].split('=');
      vars[decodeURIComponent(hash[0])] = decodeURIComponent(hash[1]);
    }
    return vars;
  },
  init_ajax_uploader: function () {
    if (!jQuery('#mediamanager__uploader').length) return;
    if (jQuery('.qq-upload-list').length) return;
    var params = dw_mediamanager.form_params(jQuery('#dw__upload')) + '&call=mediaupload';
    params = dw_mediamanager.params_toarray(params);
    var uploader = new qq.FileUploaderExtended({
      element: document.getElementById('mediamanager__uploader'),
      action: DOKU_BASE + 'lib/exe/ajax.php',
      params: params
    });
  },
  prepare_content: function ($content) {
    $content.find('div.example:visible').hide();
    $content.find('a.allowedmime').on('click', function (event) {
      event.preventDefault();
      $toggle = jQuery(this);
      $list = $toggle.next('span');
      $list.toggle();
    }).next('span').hide();
  },
  select: function (event) {
    var $link, id, dot, ext;
    event.preventDefault();
    $link = jQuery(this);
    id = $link.attr('id').substr(2);
    if (!opener) {
      jQuery(document.getElementById('ex_' + id.replace(/:/g, '_').replace(/^_/, ''))).dw_toggle();
      return;
    }
    dw_mediamanager.ext = false;
    dot = id.lastIndexOf(".");
    if (-1 === dot) {
      dw_mediamanager.insert(id);
      return;
    }
    ext = id.substr(dot);
    if ({
      '.jpg': 1,
      '.jpeg': 1,
      '.png': 1,
      '.gif': 1,
      '.swf': 1
    }[ext] !== 1) {
      dw_mediamanager.insert(id);
      return;
    }
    var $sendbtn = jQuery('#media__sendbtn');
    $sendbtn.off().on('click', bind(dw_mediamanager.insert, id));
    dw_mediamanager.unforbid('ext');
    if (ext === '.swf') {
      dw_mediamanager.ext = 'swf';
      dw_mediamanager.forbid('ext', {
        link: ['1', '2'],
        size: ['4']
      });
    } else {
      dw_mediamanager.ext = 'img';
    }
    dw_mediamanager.setOpt('link');
    dw_mediamanager.setOpt('align');
    dw_mediamanager.setOpt('size');
    jQuery('#media__linkbtn1, #media__linkbtn2, #media__sizebtn4').toggle(dw_mediamanager.ext === 'img');
    dw_mediamanager.$popup.dialog('open');
    $sendbtn.focus();
  },
  confirmattach: function (e) {
    if (!confirm(LANG.del_confirm + "\n" + jQuery(this).attr('title'))) {
      e.preventDefault();
    }
  },
  attachoptions: function () {
    var $obj, opts;
    $obj = jQuery('#media__opts');
    if ($obj.length === 0) {
      return;
    }
    opts = [];
    if (opener) {
      opts.push(['keepopen', 'keepopen']);
    }
    opts.push(['hide', 'hidedetails']);
    jQuery.each(opts, function (_, opt) {
      var $box, $lbl;
      $box = jQuery(document.createElement('input')).attr('type', 'checkbox').attr('id', 'media__' + opt[0]).on('click', bind(dw_mediamanager.toggleOption, opt[0]));
      if (DokuCookie.getValue(opt[0])) {
        $box.prop('checked', true);
        dw_mediamanager[opt[0]] = true;
      }
      $lbl = jQuery(document.createElement('label')).attr('for', 'media__' + opt[0]).text(LANG[opt[1]]);
      $obj.append($box, $lbl, document.createElement('br'));
    });
    dw_mediamanager.updatehide();
  },
  toggleOption: function (variable) {
    if (jQuery(this).prop('checked')) {
      DokuCookie.setValue(variable, 1);
      dw_mediamanager[variable] = true;
    } else {
      DokuCookie.setValue(variable, '');
      dw_mediamanager[variable] = false;
    }
    if (variable === 'hide') {
      dw_mediamanager.updatehide();
    }
  },
  updatehide: function () {
    jQuery('#media__content').find('div.detail').dw_toggle(!dw_mediamanager.hide);
  },
  setOpt: function (opt, e) {
    var val, i;
    if (typeof e !== 'undefined') {
      val = this.id.substring(this.id.length - 1);
    } else {
      val = dw_mediamanager.getOpt(opt);
    }
    if (val === false) {
      DokuCookie.setValue(opt, '');
      dw_mediamanager[opt] = false;
      return;
    }
    if (opt === 'link') {
      if (val !== '4' && dw_mediamanager.link === '4') {
        dw_mediamanager.unforbid('linkonly');
        dw_mediamanager.setOpt('align');
        dw_mediamanager.setOpt('size');
      } else if (val === '4') {
        dw_mediamanager.forbid('linkonly', {
          align: false,
          size: false
        });
      }
      jQuery("#media__size, #media__align").dw_toggle(val !== '4');
    }
    DokuCookie.setValue(opt, val);
    dw_mediamanager[opt] = val;
    for (i = 1; i <= 4; i++) {
      jQuery("#media__" + opt + "btn" + i).removeClass('selected');
    }
    jQuery('#media__' + opt + 'btn' + val).addClass('selected');
  },
  unforbid: function (group) {
    delete dw_mediamanager.forbidden_opts[group];
  },
  forbid: function (group, forbids) {
    dw_mediamanager.forbidden_opts[group] = forbids;
  },
  allowedOpt: function (opt, val) {
    var ret = true;
    jQuery.each(dw_mediamanager.forbidden_opts, function (_, forbids) {
      ret = forbids[opt] !== false && jQuery.inArray(val, forbids[opt]) === -1;
      return ret;
    });
    return ret;
  },
  getOpt: function (opt) {
    var allowed = bind(dw_mediamanager.allowedOpt, opt);
    if (dw_mediamanager[opt] !== false && allowed(dw_mediamanager[opt])) {
      return dw_mediamanager[opt];
    }
    if (DokuCookie.getValue(opt) && allowed(DokuCookie.getValue(opt))) {
      return DokuCookie.getValue(opt);
    }
    if (opt === 'size' && allowed('2')) {
      return '2';
    }
    return jQuery.grep(['1', '2', '3', '4'], allowed)[0] || false;
  }
};

function dw_mediamanager_item_select(edid, mediaid, opts, align, keepopen) {
  var alignleft = '';
  var alignright = '';
  var cursorInImageTag = false;
  var textArea = jQuery('#' + edid)[0];
  var selection = DWgetSelection(textArea);
  selection.end = selection.end + 2;
  var charsAfterCursor = selection.getText();
  if (charsAfterCursor === '}}') {
    cursorInImageTag = true;
  }
  if (align !== '1') {
    alignleft = align === '2' ? '' : ' ';
    alignright = align === '4' ? '' : ' ';
  }
  if (keepopen && cursorInImageTag) {
    selection.start = selection.start + 2;
    DWsetSelection(selection);
  }
  insertTags(edid, '{{' + alignleft + mediaid + opts + alignright + '|', '}}', '');
}
jQuery(dw_mediamanager.init);

function DEPRECATED(msg) {
  if (!window.console) return;
  if (!msg) msg = '';
  var func;
  if (arguments.callee) func = arguments.callee.caller.name;
  if (func) func = ' ' + func + '()';
  var line = 'DEPRECATED function call' + func + '. ' + msg;
  if (console.warn) {
    console.warn(line);
  } else {
    console.log(line);
  }
  if (console.trace) console.trace();
}

function DEPRECATED_WRAP(func, context) {
  return function () {
    DEPRECATED();
    return func.apply(context || this, arguments);
  };
}
jQuery.fn.dw_hide = function (fn, noaria) {
  if (!noaria) this.attr('aria-expanded', 'false');
  return this.slideUp('fast', fn);
};
jQuery.fn.dw_show = function (fn, noaria) {
  if (!noaria) this.attr('aria-expanded', 'true');
  return this.slideDown('fast', fn);
};
jQuery.fn.dw_toggle = function (state, fn, noaria) {
  return this.each(function () {
    var $this = jQuery(this);
    if (typeof state === 'undefined') {
      state = $this.is(':hidden');
    }
    $this[state ? "dw_show" : "dw_hide"](fn, noaria);
  });
};
var dw_behaviour = {
  init: function () {
    dw_behaviour.focusMarker();
    dw_behaviour.scrollToMarker();
    dw_behaviour.removeHighlightOnClick();
    dw_behaviour.quickSelect();
    dw_behaviour.checkWindowsShares();
    dw_behaviour.subscription();
    dw_behaviour.pageRestoreConfirm();
    dw_behaviour.securityCheck();
    dw_behaviour.revisionBoxHandler();
    jQuery(document).on('click', '#page__revisions input[type=checkbox]', dw_behaviour.revisionBoxHandler);
    jQuery('.bounce').effect('bounce', {
      times: 10
    }, 2000);
  },
  scrollToMarker: function () {
    var $obj = jQuery('#scroll__here');
    if ($obj.length) {
      if ($obj.offset().top != 0) {
        jQuery('html, body').animate({
          scrollTop: $obj.offset().top - 100
        }, 500);
      } else {
        $obj[0].scrollIntoView();
      }
    }
  },
  pageRestoreConfirm: function () {
    jQuery('#dokuwiki__pagetools li.revert a').on('click', function () {
      return confirm(LANG.restore_confirm);
    });
  },
  focusMarker: function () {
    jQuery('#focus__this').trigger('focus');
  },
  removeHighlightOnClick: function () {
    jQuery('span.search_hit').on('click', function (e) {
      jQuery(e.target).removeClass('search_hit', 1000);
    });
  },
  quickSelect: function () {
    jQuery('.quickselect').change(function (e) {
      HTMLFormElement.prototype.submit.call(e.target.form);
    }).closest('form').find(':button').not('.show').hide();
  },
  checkWindowsShares: function () {
    if (!LANG.nosmblinks || navigator.userAgent.match(/(Trident|MSIE|Edge)/)) {
      return;
    }
    jQuery('a.windows').on('click', function () {
      alert(LANG.nosmblinks.replace(/\\n/, "\n"));
    });
  },
  subscription: function () {
    var $form, $list, $digest;
    $form = jQuery('#subscribe__form');
    if (0 === $form.length) return;
    $list = $form.find("input[name='sub_style'][value='list']");
    $digest = $form.find("input[name='sub_style'][value='digest']");
    $form.find("input[name='sub_target']").on('click', function () {
      var $this = jQuery(this),
        show_list;
      if (!$this.prop('checked')) {
        return;
      }
      show_list = $this.val().match(/:$/);
      $list.parent().dw_toggle(show_list);
      if (!show_list && $list.prop('checked')) {
        $digest.prop('checked', 'checked');
      }
    }).filter(':checked').trigger('click');
  },
  revisionBoxHandler: function () {
    var $revisions = jQuery('#page__revisions');
    var $all = jQuery('input[type="checkbox"][name="rev2[]"]', $revisions);
    var $checked = $all.filter(':checked');
    var $button = jQuery('button', $revisions);
    if ($checked.length < 2) {
      $all.prop('disabled', false);
      $button.prop('disabled', true);
    } else {
      $all.prop('disabled', true);
      $button.prop('disabled', false);
      $checked.each(function (i) {
        jQuery(this).prop('disabled', false);
        if (i > 1) {
          jQuery(this).prop('checked', false);
        }
      });
    }
  },
  securityCheck: function () {
    var $checkDiv = jQuery('#security__check');
    if (!$checkDiv.length) return;
    if (sessionStorage.getItem('dw-security-check:' + DOKU_BASE)) {
      $checkDiv.remove();
      return;
    }
    var img = new Image();
    img.onerror = function () {
      $checkDiv.remove();
      sessionStorage.setItem('dw-security-check:' + DOKU_BASE, true);
    };
    img.onload = function () {
      $checkDiv.html(LANG.data_insecure);
      $checkDiv.addClass('error');
    };
    img.src = $checkDiv.data('src') + '?t=' + Date.now();
  }
};
jQuery(dw_behaviour.init);
dw_page = {
  init: function () {
    dw_page.sectionHighlight();
    dw_page.currentIDHighlight();
    jQuery('a.fn_top').on('mouseover', dw_page.footnoteDisplay);
    dw_page.makeToggle('#dw__toc h3', '#dw__toc > div');
  },
  sectionHighlight: function () {
    jQuery('form.btn_secedit').each(function () {
      let $tgt = jQuery(this).parent();
      const match = $tgt.attr('class').match(/(\s+|^)editbutton_(\d+)(\s+|$)/);
      if (!match) return;
      const nr = match[2];
      let $highlight = jQuery();
      const $highlightWrap = jQuery('<div class="section_highlight_wrapper"></div>');
      $highlight = $highlight.add($tgt);
      while ($tgt.length > 0 && !($tgt.hasClass('sectionedit' + nr) || $tgt.find('.sectionedit' + nr).length)) {
        $tgt = $tgt.prev();
        $highlight = $highlight.add($tgt);
      }
      $highlight.wrapAll($highlightWrap);
    }).on('mouseover', function () {
      jQuery(this).parents('.section_highlight_wrapper').addClass('section_highlight');
    }).on('mouseout', function () {
      jQuery(this).parents('.section_highlight_wrapper').removeClass('section_highlight');
    });
  },
  currentIDHighlight: function () {
    jQuery('a.wikilink1, a.wikilink2').filter('[data-wiki-id="' + JSINFO.id + '"]').wrap('<span class="curid"></span>');
  },
  insituPopup: function (target, popup_id) {
    var $fndiv = jQuery('#' + popup_id);
    if ($fndiv.length === 0) {
      $fndiv = jQuery(document.createElement('div')).attr('id', popup_id).addClass('insitu-footnote JSpopup').attr('aria-hidden', 'true').on('mouseleave', function () {
        jQuery(this).hide().attr('aria-hidden', 'true');
      }).attr('role', 'tooltip');
      jQuery('.dokuwiki:first').append($fndiv);
    }
    $fndiv.show().position({
      my: 'left top',
      at: 'left center',
      of: target
    }).hide();
    return $fndiv;
  },
  footnoteDisplay: function () {
    var $content = jQuery(jQuery(this).attr('href')).parent().siblings('.content').clone();
    if (!$content.length) {
      return;
    }
    jQuery('[id]', $content).each(function () {
      var id = jQuery(this).attr('id');
      jQuery(this).attr('id', 'insitu__' + id);
    });
    var content = $content.html().trim();
    dw_page.insituPopup(this, 'insitu__fn').html(content).show().attr('aria-hidden', 'false');
  },
  makeToggle: function (handle, content, state) {
    var $handle, $content, $clicky, $child, setClicky;
    $handle = jQuery(handle);
    if (!$handle.length) return;
    $content = jQuery(content);
    if (!$content.length) return;
    $child = $content.children();
    setClicky = function (hiding) {
      if (hiding) {
        $clicky.html('<span>+</span>');
        $handle.addClass('closed');
        $handle.removeClass('open');
      } else {
        $clicky.html('<span>−</span>');
        $handle.addClass('open');
        $handle.removeClass('closed');
      }
    };
    $handle[0].setState = function (state) {
      var hidden;
      if (!state) state = 1;
      $content.css('min-height', $content.height()).show();
      $child.stop(true, true);
      if (state === -1) {
        hidden = false;
      } else if (state === 1) {
        hidden = true;
      } else {
        hidden = $child.is(':hidden');
      }
      setClicky(!hidden);
      $child.dw_toggle(hidden, function () {
        $content.toggle(hidden);
        $content.attr('aria-expanded', hidden);
        $content.css('min-height', '');
      }, true);
    };
    $clicky = jQuery(document.createElement('strong'));
    $handle.css('cursor', 'pointer').on('click', $handle[0].setState).prepend($clicky);
    $handle[0].setState(state);
  }
};
jQuery(dw_page.init);
jQuery(function () {
  var $panel = jQuery('div.qc-output').hide();
  jQuery('.page-attributes .plugin_qc a').load(DOKU_BASE + 'lib/exe/ajax.php', {
    call: 'plugin_qc_short',
    id: JSINFO['id']
  }, function () {
    jQuery(this).find('span span').addClass('num');
  }).click(function (e) {
    e.preventDefault();
    if ($panel.html() == '') {
      $panel.load(DOKU_BASE + 'lib/exe/ajax.php', {
        call: 'plugin_qc_long',
        id: JSINFO['id']
      }, function () {
        $panel.dw_show();
      });
    } else {
      $panel.dw_toggle();
    }
  });
});
(function ($) {
  var debugBookCreatorOnDetailTemplate = function () {
    var $detail = $('#dokuwiki__detail');
    if (!$detail.length) return;
    if (JSINFO.bookcreator === undefined) {
      JSINFO.bookcreator = {};
      JSINFO.bookcreator.areToolsVisible = false;
    }
  };
  $(function () {
    debugBookCreatorOnDetailTemplate();
  });
})(jQuery);
(function ($) {
  var debugFoldedOnDetailTemplate = function () {
    var $detail = $('#dokuwiki__detail');
    if (!$detail.length) return;
    if (JSINFO.plugin_folded === undefined) {
      JSINFO.plugin_folded = {};
      JSINFO.plugin_folded.reveal = '';
      JSINFO.plugin_folded.hide = '';
    }
  };
  $(function () {
    debugFoldedOnDetailTemplate();
  });
})(jQuery);
(function ($) {
  var registerClickForTabsInMetaBox = function ($metaBox) {
    $metaBox.on('click', '.meta-tabs a', function (e) {
      e.preventDefault();
      var $tab = $(this),
        isopen = $tab.attr('aria-expanded') === 'true';
      disableExistingTabs($metaBox);
      if (isopen) return;
      $tab.attr('aria-expanded', 'true').closest('li').addClass('active');
      $metaBox.find($tab.attr('href')).addClass('active').attr('aria-hidden', 'false');
    }).find('.meta-content').on('click', 'a[href*="#"]', function (e) {
      disableExistingTabs($metaBox);
    }).find('#tagging__edit').on('hide', function (e) {
      disableExistingTabs($metaBox);
    });
    if ($('body').hasClass('do-admin')) {
      var $tocLink = $metaBox.find('a[href="#spr__tab-toc"]');
      if ($tocLink.length === 1) {
        $tocLink.trigger('click');
      }
    }
  },
    disableExistingTabs = function ($metaBox) {
      $metaBox.find('.meta-tabs li').removeClass('active').find('a').attr('aria-expanded', 'false');
      $metaBox.find('.meta-content .tab-pane').removeClass('active').attr('aria-hidden', 'false');
    };
  var stickyBox = function ($metaBox, topOffset, leftOffset) {
    if (window.pageYOffset >= topOffset) {
      $metaBox.addClass("sticky").attr("style", "left: " + leftOffset + "px");
    } else {
      $metaBox.removeClass("sticky").removeAttr("style");
    }
  };
  $(function () {
    var $metaBox = $('#spr__meta-box');
    if (!$metaBox.length) return;
    registerClickForTabsInMetaBox($metaBox);
    var topOffset = $metaBox.offset().top;
    window.onscroll = function () {
      var leftOffset = $metaBox.offset().left;
      stickyBox($metaBox, topOffset, leftOffset)
    };
  });
})(jQuery);
jQuery(function () {
  var $nav = jQuery('#dokuwiki__aside');
  if (!$nav.length) return;
  var sidebarId = '';
  var divId = jQuery('#sidebarId');
  if (typeof divId !== 'undefined') {
    sidebarId = divId.attr('class').split(' ')[0];
  }
  var setWideContent = function () {
    $nav.find('div.nav-panel').hide();
    jQuery('body').addClass('wide-content');
    removeToggleStorage();
    window.sessionStorage.setItem('wide-content', true);
  },
    removeToggleStorage = function () {
      for (var index = 0; index <= window.sessionStorage.length; index += 1) {
        var item = window.sessionStorage.getItem('sidebar-section-' + sidebarId + '-' + index + '-open');
        if (!item) {
          continue;
        }
        window.sessionStorage.setItem('sidebar-section-' + sidebarId + '-' + index + '-open', 'false');
      }
    },
    setDefaultContent = function () {
      jQuery('body').removeClass('wide-content');
      window.sessionStorage.setItem('wide-content', false);
    },
    focusFirstSubLink = function ($elem) {
      $elem.find('a').first().focus();
    },
    removeOpenStates = function () {
      $nav.find('.is-open').removeClass('is-open');
    },
    toggleNav = function ($toggler) {
      var $panel = $toggler.parent().next('div.nav-panel');
      var isOpen = $panel.is(':visible');
      setDefaultContent();
      $panel.dw_toggle(!isOpen, function () {
        if (!isOpen) {
          focusFirstSubLink($panel);
          $toggler.addClass('is-open');
        } else {
          $toggler.removeClass('is-open');
        }
      });
      window.sessionStorage.setItem('sidebar-section-' + sidebarId + '-' + $toggler.data('index') + '-open', !isOpen);
    },
    initContentNav = function () {
      var $main = $nav.find('nav.nav-main');
      if (!$main.length) return;
      if (jQuery('body').hasClass('wide-content')) {
        removeToggleStorage();
      }
      var ELEMENT = JSINFO.template.sprintdoc.sidebar_toggle_elements;
      var $elements = $main.find(ELEMENT);
      $elements.each(function (index) {
        var $me = jQuery(this),
          data = $me.text().split('@', 2),
          text = data[0].trim();
        var $icon = jQuery('<span class="ico">').text(text.substr(0, 1).toUpperCase() + text.substr(1, 1).toLowerCase()).wrapInner('<strong>');
        if (data[1]) {
          var src = data[1].trim();
          $icon.load(DOKU_BASE + 'lib/tpl/sprintdoc/img/' + src);
        }
        var $toggler = jQuery('<a>').attr('href', '#').attr('role', 'heading').attr('aria-level', '2').text(text).wrapInner('<span class="lbl">').prepend($icon).data('index', index);
        $toggler = jQuery('<div class="nav">').prepend($toggler);
        var $wrap = jQuery('<div>').addClass('nav-panel');
        var $sibs = $me.nextAll();
        for (var i = 0; i < $sibs.length; i++) {
          var $sib = jQuery($sibs[i]);
          if ($sib.is(ELEMENT)) break;
          $sib.detach().appendTo($wrap);
          addContentMenuCurrentStates($sib, $toggler);
        }
        var $links = jQuery($wrap[0]).find('a');
        if ($links.length === 1 && $links.first().attr('href') !== '#') {
          $toggler.children().first().attr('href', jQuery($links[0]).attr('href'));
        } else {
          $wrap.insertAfter($me);
          if ($toggler.parent('li').length) {
            $toggler.parent('li').addClass('toggler');
          }
          if (window.sessionStorage.getItem('sidebar-section-' + sidebarId + '-' + index + '-open') === 'true') {
            $wrap.css('display', 'block');
            setTogglerClass($toggler, 'is-open');
          }
        }
        $me.replaceWith($toggler);
      });
      $main.css({
        opacity: 0,
        visibility: "visible"
      }).animate({
        opacity: 1
      }, 200);
    },
    initMenuHandling = function () {
      $nav.on('click', 'div.nav a', function (e) {
        if (jQuery(this).attr('href').startsWith('#')) {
          toggleNav(jQuery(this));
          e.preventDefault();
        }
      });
    },
    setTogglerClass = function ($toggler, classVal) {
      if ($toggler.is('a')) {
        $toggler.addClass(classVal);
      } else {
        $toggler.find('a').addClass(classVal);
      }
    },
    addContentMenuCurrentStates = function ($menuObj, $toggler) {
      if ($menuObj[0] && String($menuObj[0].innerHTML).indexOf('curid') > 0) {
        setTogglerClass($toggler, 'is-active');
      }
    },
    initContentMinHeight = function () {
      var $sidebar = jQuery('.page-wrapper').find('> .tools').find('.col-xs-12');
      if ($sidebar.length == 1) {
        var num = parseFloat($sidebar.height());
        if (!isNaN(num)) {
          jQuery('#dokuwiki__content').css('minHeight', num + 100);
        }
      }
    },
    initSidebarToggling = function () {
      var $toggler = jQuery('.togglelink.page_main-content').find('a');
      $toggler.click(function (e) {
        e.preventDefault();
        if (jQuery('body').hasClass('wide-content')) {
          setDefaultContent();
        } else {
          setWideContent();
          removeOpenStates();
        }
      });
      if (window.sessionStorage.getItem('wide-content') === 'true') {
        setWideContent();
      }
    },
    initSearchToggling = function () {
      jQuery('.toggleSearch').find('a').click(function (e) {
        setDefaultContent();
        e.preventDefault();
        jQuery('#qsearch__in').focus();
      });
    },
    initMobileToggling = function () {
      jQuery('.menu-togglelink').find('a').click(function (e) {
        e.preventDefault();
        var $body = jQuery('body');
        $body.toggleClass('show-mobile-sidebar');
      });
    },
    setActive = function (selectorArray, $nav) {
      for (var i = 0; i < selectorArray.length; i++) {
        var mode = selectorArray[i];
        if (jQuery('body').is('.do-' + mode)) {
          setTogglerClass($nav.find('.nav'), 'is-active');
          $nav.find('a[href*="do=' + mode + '"]').wrapAll('<span class="curid"></span>');
        }
      }
    },
    initTemplateMenues = function () {
      var $body = jQuery('body'),
        $siteTools = $nav.find('> .nav-sitetools'),
        $userTools = $nav.find('> .nav-usermenu'),
        $templateMenus = $nav.find('> nav:not(.nav-main)'),
        stModes = ['recent', 'media', 'index'],
        utModes = ['profile', 'admin'],
        isWideContent = false;
      setActive(stModes, $siteTools);
      setActive(utModes, $userTools);
      if ($body.is('.do-show') && $body.is('.wide-content')) {
        window.sessionStorage.setItem('wide-content', true);
        isWideContent = true;
      }
      $templateMenus.each(function (index) {
        var $t = jQuery(this).find('.nav'),
          y = $nav.find('.nav-main').find('.nav').length,
          $toggler = ($t.is('a')) ? $t : $t.find('a:last'),
          tIndex = y + index;
        $toggler.data('index', tIndex);
        var item = window.sessionStorage.getItem('sidebar-section-' + sidebarId + '-' + tIndex + '-open');
        if (item) {
          if (isWideContent) {
            window.sessionStorage.setItem('sidebar-section-' + sidebarId + '-' + tIndex + '-open', 'false');
          } else {
            if (item === 'true') {
              jQuery(this).find('.nav-panel').css('display', 'block');
              setTogglerClass($toggler, 'is-open');
            }
          }
        }
      });
    };
  initContentNav();
  initSidebarToggling();
  initTemplateMenues();
  initMenuHandling();
  initContentMinHeight();
  initSearchToggling();
  initMobileToggling();
});
(function ($) {
  var $body, scrollingForDirectNav = function ($directMenu) {
    $body = $('body');
    checkAnchorsOnLoad($directMenu);
    registerClickForDirectLinks($directMenu);
  },
    registerClickForDirectLinks = function ($menu) {
      $menu.find('a').on('click', function (e) {
        e.stopPropagation();
        var target = $(this).attr('href');
        tasksBeforeScrolling(target);
        scrollToTarget(target);
      });
    },
    checkAnchorsOnLoad = function ($menu) {
      var hash = window.location.hash;
      if (hash) {
        $menu.find('a').each(function () {
          var target = $(this).attr('href');
          if (hash === target) {
            tasksBeforeScrolling(target);
            scrollToTarget(target);
            setFocusOnLoad(target);
          }
        });
      }
    },
    tasksBeforeScrolling = function (target) {
      switch (target) {
        case '#qsearch__in':
          showSearchField(target);
          break;
        case '#dokuwiki__usertools':
          $(target).find('li:first-child').find('a').focus();
          break;
      }
    },
    setFocusOnLoad = function (target) {
      var $target = $(target);
      switch (target) {
        case '#qsearch__in':
        case '#spr__toggle-content':
          $target.focus();
          break;
        case '#dokuwiki__usertools':
          break;
        default:
          $target.attr('tabindex', 0);
          $target.focus();
      }
    },
    showSearchField = function (target) {
      if ($body.hasClass('wide-content')) {
        $('#spr__toggle-content').trigger('click');
      }
    },
    scrollToTarget = function (target) {
      $('html, body').animate({
        scrollTop: (target.offset().top - 60)
      }, 400);
    };
  $(function () {
    var $directMenu = $('#spr__direct');
    if (!$directMenu.length) return;
    scrollingForDirectNav($directMenu);
  });
})(jQuery);
jQuery(function () {
  jQuery('#dokuwiki__content.main-content').find('h1,h2,h3,h4,h5').append(function () {
    if (this.id) {
      return '<a href="#' + this.id + '" class="anchor">' + '<svg viewBox="0 0 20 20">' + '<path d="m 15.416601,0 c -1.58446,-4.6014118e-8 -2.991809,0.81019022 -3.813281,2.0403646 l -1.89e-4,2.645e-4 -1.6649087,2.4970052 a 0.83333545,0.83333545 0 0 0 0.2313147,1.1557943 0.83333545,0.83333545 0 0 0 1.155534,-0.2310548 l 1.664323,-2.4965493 2.52e-4,-5.166e-4 c 0.523149,-0.7831205 1.408706,-1.298698 2.426953,-1.2986979 1.6207,0 2.916798,1.2960971 2.916798,2.9167968 0,0.6021756 -0.179631,1.154007 -0.489128,1.6171224 l -2.52e-4,2.645e-4 -3.333658,5.0005203 c -0.523149,0.783122 -1.408706,1.298698 -2.426953,1.298698 -1.6207,0 -2.916797,-1.295901 -2.916797,-2.9166011 0,-0.11021 0.0062,-0.2187797 0.017969,-0.3252604 A 0.83333545,0.83333545 0 0 0 8.447859,8.3383588 0.83333545,0.83333545 0 0 0 7.5280673,9.0750775 c -0.018477,0.1671322 -0.02806,0.3368675 -0.02806,0.5083334 0,2.5214361 2.0619628,4.5832031 4.5833987,4.5832031 1.584459,0 2.991809,-0.809929 3.813282,-2.040104 l 2.52e-4,-5.17e-4 3.333203,-4.9994788 C 19.716167,6.3991244 20,5.5202455 20,4.5833984 20,2.0619631 17.938037,9.202824e-8 15.416601,0 Z M 7.9166015,5.8333983 C 6.3321419,5.8333982 4.9247921,6.643328 4.1033203,7.8735025 l -1.89e-4,5.165e-4 -3.33366517,5.000265 C 0.28367569,13.601502 0,14.480069 0,15.416601 0,17.938037 2.0619629,20 4.5833984,20 c 1.58446,0 2.9918085,-0.810191 3.8132812,-2.040364 l 1.889e-4,-2.52e-4 1.6649085,-2.497006 A 0.83333545,0.83333545 0 0 0 9.8304623,14.306584 0.83333545,0.83333545 0 0 0 8.6749285,14.537639 L 7.0103452,17.03471 c -0.5231502,0.783122 -1.4087056,1.298697 -2.4269531,1.298697 -1.6206999,0 -2.9167969,-1.296097 -2.9167969,-2.916797 0,-0.602177 0.1796968,-1.154007 0.4891927,-1.617122 l 2.016e-4,-2.52e-4 3.3334635,-4.9999997 2.646e-4,-5.166e-4 c 0.5231491,-0.7831206 1.4086408,-1.298698 2.426888,-1.2986979 1.6206997,0 2.9168624,1.2959017 2.9168624,2.9166012 0,0.110213 -0.0062,0.21879 -0.01797,0.325261 a 0.83333545,0.83333545 0 0 0 0.736719,0.919791 0.83333545,0.83333545 0 0 0 0.919726,-0.736718 C 12.490419,10.757796 12.5,10.588061 12.5,10.416601 12.5,7.895166 10.438037,5.8333983 7.9166015,5.8333983 Z" />' + '</svg>' + '</a>';
    } else {
      return '';
    }
  })
});
var dw_acl = {
  init: function () {
    var $tree;
    if (jQuery('#acl_manager').length === 0) {
      return;
    }
    jQuery('#acl__user select').on('change', dw_acl.userselhandler);
    jQuery('#acl__user button').on('click', dw_acl.loadinfo);
    $tree = jQuery('#acl__tree');
    $tree.dw_tree({
      toggle_selector: 'img',
      load_data: function (show_sublist, $clicky) {
        var $frm = jQuery('#acl__detail form');
        jQuery.post(DOKU_BASE + 'lib/exe/ajax.php', jQuery.extend(dw_acl.parseatt($clicky.parent().find('a')[0].search), {
          call: 'plugin_acl',
          ajax: 'tree',
          current_ns: $frm.find('input[name=ns]').val(),
          current_id: $frm.find('input[name=id]').val()
        }), show_sublist, 'html');
      },
      toggle_display: function ($clicky, opening) {
        $clicky.attr('src', DOKU_BASE + 'lib/images/' + (opening ? 'minus' : 'plus') + '.gif');
      }
    });
    $tree.delegate('a', 'click', dw_acl.treehandler);
  },
  userselhandler: function () {
    jQuery('#acl__user input').toggle(this.value === '__g__' || this.value === '__u__');
    dw_acl.loadinfo();
  },
  loadinfo: function () {
    jQuery('#acl__info').attr('role', 'alert').html('<img src="' + DOKU_BASE + 'lib/images/throbber.gif" alt="..." />').load(DOKU_BASE + 'lib/exe/ajax.php', jQuery('#acl__detail form').serialize() + '&call=plugin_acl&ajax=info');
    return false;
  },
  parseatt: function (str) {
    if (str[0] === '?') {
      str = str.substr(1);
    }
    var attributes = {};
    var all = str.split('&');
    for (var i = 0; i < all.length; i++) {
      var att = all[i].split('=');
      attributes[att[0]] = decodeURIComponent(att[1]);
    }
    return attributes;
  },
  treehandler: function () {
    var $link, $frm;
    $link = jQuery(this);
    jQuery('#acl__tree a.cur').removeClass('cur');
    $link.addClass('cur');
    $frm = jQuery('#acl__detail form');
    if ($link.hasClass('wikilink1')) {
      $frm.find('input[name=ns]').val('');
      $frm.find('input[name=id]').val(dw_acl.parseatt($link[0].search).id);
    } else if ($link.hasClass('idx_dir')) {
      $frm.find('input[name=ns]').val(dw_acl.parseatt($link[0].search).ns);
      $frm.find('input[name=id]').val('');
    }
    dw_acl.loadinfo();
    return false;
  }
};
jQuery(dw_acl.init);
jQuery(function () {
  jQuery('form.bureaucracy__plugin').each(function () {
    function updateFieldset(input) {
      jQuery.each(jQuery(input).data('dparray'), function (i, dp) {
        var showOrHide = input.parentNode.parentNode.style.display !== 'none' && ((input.checked === dp.tval) || (input.type !== 'checkbox' && (dp.tval === true && input.value !== '')) || input.value === dp.tval);
        dp.fset.toggle(showOrHide);
        dp.fset.find('input,select').each(function () {
          var $inputelem = jQuery(this);
          if ($inputelem.hasClass('required')) {
            if (showOrHide) {
              $inputelem.attr('required', 'required');
            } else {
              $inputelem.removeAttr('required')
            }
          }
          if ($inputelem.data('dparray')) {
            $inputelem.change();
          }
        });
      });
    }
    jQuery('p.bureaucracy_depends', this).each(function () {
      var fname = jQuery(this).find('span.bureaucracy_depends_fname').html(),
        fvalue = jQuery(this).find('span.bureaucracy_depends_fvalue');
      fvalue = (fvalue.length ? fvalue.html() : true);
      var fieldsetinfo = {
        fset: jQuery(this).parent(),
        tval: fvalue
      };
      jQuery("label").has(":first-child:contains('" + fname + "')").first().find("select,input:last").each(function () {
        if (!jQuery(this).data('dparray')) {
          jQuery(this).data('dparray', [fieldsetinfo]);
        } else {
          jQuery(this).data('dparray').push(fieldsetinfo);
        }
      }).bind('change keyup', function () {
        updateFieldset(this);
      }).change();
    }).hide();
  });
});
jQuery(function () {
  function ajaxsource(request, response, getterm) {
    jQuery.getJSON(DOKU_BASE + 'lib/exe/ajax.php', {
      call: 'bureaucracy_user_field',
      search: getterm(request)
    }, function (data) {
      response(jQuery.map(data, function (name, user) {
        return {
          label: name + ' (' + user + ')',
          value: user
        }
      }))
    });
  }

  function split(val) {
    return val.split(/,\s*/);
  }

  function extractLast(term) {
    return split(term).pop();
  }
  jQuery(".userpicker").autocomplete({
    source: function (request, response) {
      ajaxsource(request, response, function (req) {
        return req.term
      })
    }
  });
  jQuery(".userspicker").bind("keydown", function (event) {
    if (event.keyCode === jQuery.ui.keyCode.TAB && jQuery(this).data("ui-autocomplete").menu.active) {
      event.preventDefault();
    }
  }).autocomplete({
    minLength: 0,
    source: function (request, response) {
      ajaxsource(request, response, function (req) {
        return extractLast(req.term)
      })
    },
    search: function () {
      var term = extractLast(this.value);
      return term.length >= 2;
    },
    focus: function () {
      return false;
    },
    select: function (event, ui) {
      var terms = split(this.value);
      terms.pop();
      terms.push(ui.item.value);
      terms.push("");
      this.value = terms.join(", ");
      return false;
    }
  });
});
jQuery(function () {
  jQuery('.bureaucracy__plugin .datepicker').datepicker({
    dateFormat: "yy-mm-dd",
    changeMonth: true,
    changeYear: true
  });
});
jQuery(function () {
  var $wrap = jQuery('#plugin__captcha_wrapper');
  if (!$wrap.length) return;
  var $code = jQuery('#plugin__captcha_code');
  if ($code.length) {
    var $box = $wrap.find('input[type=text]');
    $box.first().val($code.text().replace(/([^A-Z])+/g, ''));
    $wrap.hide();
  }
  var $audiolink = $wrap.find('a.audiolink');
  if ($audiolink.length) {
    var audio = document.createElement('audio');
    if (audio) {
      audio.src = $audiolink.attr('href');
      $wrap.append(audio);
      $audiolink.click(function (e) {
        audio.play();
        e.preventDefault();
        e.stopPropagation();
      });
    }
  }
});

function catlist_button_add_page(element, ns) {
  var addPageForm = element.parentNode;
  addPageForm.innerHTML = "";
  var addPageLabel = document.createElement('label');
  addPageLabel.innerHTML = ns;
  var addPageInput = document.createElement('input');
  addPageInput.type = 'text';
  addPageInput.id = 'catlist_addpage_id';
  addPageInput.onkeyup = function (evt) {
    var key = evt.keyCode || evt.which;
    if (key == 13) jQuery('#catlist_addpage_btn').click();
  };
  addPageLabel.htmlFor = 'catlist_addpage_id';
  var addPageValidButton = document.createElement('button');
  addPageValidButton.className = 'button';
  addPageValidButton.innerHTML = "Ok";
  addPageValidButton.id = 'catlist_addpage_btn';
  jQuery(addPageForm).append(addPageLabel).append(addPageInput).append(addPageValidButton);
  addPageInput.focus();
  jQuery(addPageValidButton).click(function () {
    if (addPageInput.value.length == 0) {
      addPageInput.focus();
      return;
    }
    var pagename = addPageInput.value;
    if (catlist_pagename_sanitize) {
      if (catlist_deaccent == 0) {
        pagename = encodeURI(pagename).replace(/[^a-zA-Z0-9._:%-]+/g, catlist_sepchar).replace(/%(?![A-Fa-f0-9]{2})/, catlist_sepchar);
      } else {
        if (typeof String.prototype.normalize === "function") pagename = pagename.normalize('NFD').replace(/[\u0300-\u036f]/g, "");
        pagename = pagename.replace(/[^a-zA-Z0-9._:-]+/g, catlist_sepchar);
      }
      pagename = pagename.replace(/^[._-]+/, "").replace(/[._-]+$/, "").replace(new RegExp(catlist_sepchar + '{2,}', 'g'), catlist_sepchar).toLowerCase();
    }
    var newPageID = ns + pagename;
    if (catlist_useslash && catlist_userewrite != 0) {
      newPageID = newPageID.replace(/:/g, '/');
    }
    switch (catlist_userewrite) {
      case 0:
        newPageURL = catlist_baseurl + catlist_basescript + '?id=' + newPageID + '&do=edit';
        break;
      case 1:
        newPageURL = catlist_baseurl + newPageID + '?do=edit';
        break;
      case 2:
        newPageURL = catlist_baseurl + catlist_basescript + '/' + newPageID + '?do=edit';
        break;
    }
    window.location.href = newPageURL;
  });
}
jQuery(function () {
  jQuery('.data_type_dt input').datepicker({
    dateFormat: "yy-mm-dd",
    changeMonth: true,
    changeYear: true
  });
});
jQuery(function () {
  function getAliastype($input) {
    var classes = $input.parent().attr('class').split(' '),
      multi = false,
      aliastype = 'data_type_page';
    jQuery.each(classes, function (i, cls) {
      if (cls == 'data_type_page' || cls == 'data_type_pages') {
        multi = cls.substr(cls.length - 1, 1) == 's';
        return true;
      }
      if (cls.substr(0, 10) == 'data_type_') {
        aliastype = cls;
      }
    });
    return (multi ? aliastype.substr(0, aliastype.length - 1) : aliastype);
  }

  function ajaxsource(request, response, getTerm, aliastype) {
    jQuery.getJSON(DOKU_BASE + 'lib/exe/ajax.php', {
      call: 'data_page',
      aliastype: aliastype,
      search: getTerm(request)
    }, function (data) {
      response(jQuery.map(data, function (name, id) {
        return {
          label: name + ' (' + id + ')',
          value: id
        }
      }))
    });
  }

  function split(val) {
    return val.split(/,\s*/);
  }

  function extractLast(term) {
    return split(term).pop();
  }
  jQuery(".data_type_page input").autocomplete({
    source: function (request, response) {
      ajaxsource(request, response, function (req) {
        return req.term;
      }, getAliastype(this.element));
    }
  });
  jQuery(".data_type_pages input").bind("keydown", function (event) {
    if (event.keyCode === jQuery.ui.keyCode.TAB && jQuery(this).data("ui-autocomplete").menu.active) {
      event.preventDefault();
    }
  }).autocomplete({
    minLength: 0,
    source: function (request, response) {
      ajaxsource(request, response, function (req) {
        return extractLast(req.term);
      }, getAliastype(this.element));
    },
    search: function () {
      var term = extractLast(this.value);
      if (term.length < 2) {
        return false;
      }
      return true;
    },
    focus: function () {
      return false;
    },
    select: function (event, ui) {
      var terms = split(this.value);
      terms.pop();
      terms.push(ui.item.value);
      terms.push("");
      this.value = terms.join(", ");
      return false;
    }
  });
});
(function webpackUniversalModuleDefinition(root, factory) {
  if (typeof exports === 'object' && typeof module === 'object') module.exports = factory();
  else if (typeof define === 'function' && define.amd) define("Handsontable", [], factory);
  else if (typeof exports === 'object') exports["Handsontable"] = factory();
  else root["Handsontable"] = factory();
})(this, function () {
  return (function (modules) {
    var installedModules = {};

    function __webpack_require__(moduleId) {
      if (installedModules[moduleId]) {
        return installedModules[moduleId].exports;
      }
      var module = installedModules[moduleId] = {
        i: moduleId,
        l: false,
        exports: {}
      };
      modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
      module.l = true;
      return module.exports;
    }
    __webpack_require__.m = modules;
    __webpack_require__.c = installedModules;
    __webpack_require__.i = function (value) {
      return value;
    };
    __webpack_require__.d = function (exports, name, getter) {
      if (!__webpack_require__.o(exports, name)) {
        Object.defineProperty(exports, name, {
          configurable: false,
          enumerable: true,
          get: getter
        });
      }
    };
    __webpack_require__.n = function (module) {
      var getter = module && module.__esModule ? function getDefault() {
        return module['default'];
      } : function getModuleExports() {
        return module;
      };
      __webpack_require__.d(getter, 'a', getter);
      return getter;
    };
    __webpack_require__.o = function (object, property) {
      return Object.prototype.hasOwnProperty.call(object, property);
    };
    __webpack_require__.p = "";
    return __webpack_require__(__webpack_require__.s = 332);
  })([(function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.HTML_CHARACTERS = undefined;
    exports.getParent = getParent;
    exports.closest = closest;
    exports.closestDown = closestDown;
    exports.isChildOf = isChildOf;
    exports.isChildOfWebComponentTable = isChildOfWebComponentTable;
    exports.polymerWrap = polymerWrap;
    exports.polymerUnwrap = polymerUnwrap;
    exports.index = index;
    exports.overlayContainsElement = overlayContainsElement;
    exports.hasClass = hasClass;
    exports.addClass = addClass;
    exports.removeClass = removeClass;
    exports.removeTextNodes = removeTextNodes;
    exports.empty = empty;
    exports.fastInnerHTML = fastInnerHTML;
    exports.fastInnerText = fastInnerText;
    exports.isVisible = isVisible;
    exports.offset = offset;
    exports.getWindowScrollTop = getWindowScrollTop;
    exports.getWindowScrollLeft = getWindowScrollLeft;
    exports.getScrollTop = getScrollTop;
    exports.getScrollLeft = getScrollLeft;
    exports.getScrollableElement = getScrollableElement;
    exports.getTrimmingContainer = getTrimmingContainer;
    exports.getStyle = getStyle;
    exports.getComputedStyle = getComputedStyle;
    exports.outerWidth = outerWidth;
    exports.outerHeight = outerHeight;
    exports.innerHeight = innerHeight;
    exports.innerWidth = innerWidth;
    exports.addEvent = addEvent;
    exports.removeEvent = removeEvent;
    exports.getCaretPosition = getCaretPosition;
    exports.getSelectionEndPosition = getSelectionEndPosition;
    exports.getSelectionText = getSelectionText;
    exports.setCaretPosition = setCaretPosition;
    exports.getScrollbarWidth = getScrollbarWidth;
    exports.hasVerticalScrollbar = hasVerticalScrollbar;
    exports.hasHorizontalScrollbar = hasHorizontalScrollbar;
    exports.setOverlayPosition = setOverlayPosition;
    exports.getCssTransform = getCssTransform;
    exports.resetCssTransform = resetCssTransform;
    exports.isInput = isInput;
    exports.isOutsideInput = isOutsideInput;
    var _browser = __webpack_require__(22);
    var _feature = __webpack_require__(34);

    function getParent(element) {
      var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
      var iteration = -1;
      var parent = null;
      while (element != null) {
        if (iteration === level) {
          parent = element;
          break;
        }
        if (element.host && element.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
          element = element.host;
        } else {
          iteration++;
          element = element.parentNode;
        }
      }
      return parent;
    }

    function closest(element, nodes, until) {
      while (element != null && element !== until) {
        if (element.nodeType === Node.ELEMENT_NODE && (nodes.indexOf(element.nodeName) > -1 || nodes.indexOf(element) > -1)) {
          return element;
        }
        if (element.host && element.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
          element = element.host;
        } else {
          element = element.parentNode;
        }
      }
      return null;
    }

    function closestDown(element, nodes, until) {
      var matched = [];
      while (element) {
        element = closest(element, nodes, until);
        if (!element || until && !until.contains(element)) {
          break;
        }
        matched.push(element);
        if (element.host && element.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
          element = element.host;
        } else {
          element = element.parentNode;
        }
      }
      var length = matched.length;
      return length ? matched[length - 1] : null;
    }

    function isChildOf(child, parent) {
      var node = child.parentNode;
      var queriedParents = [];
      if (typeof parent === 'string') {
        queriedParents = Array.prototype.slice.call(document.querySelectorAll(parent), 0);
      } else {
        queriedParents.push(parent);
      }
      while (node != null) {
        if (queriedParents.indexOf(node) > -1) {
          return true;
        }
        node = node.parentNode;
      }
      return false;
    }

    function isChildOfWebComponentTable(element) {
      var hotTableName = 'hot-table',
        result = false,
        parentNode;
      parentNode = polymerWrap(element);

      function isHotTable(element) {
        return element.nodeType === Node.ELEMENT_NODE && element.nodeName === hotTableName.toUpperCase();
      }
      while (parentNode != null) {
        if (isHotTable(parentNode)) {
          result = true;
          break;
        } else if (parentNode.host && parentNode.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
          result = isHotTable(parentNode.host);
          if (result) {
            break;
          }
          parentNode = parentNode.host;
        }
        parentNode = parentNode.parentNode;
      }
      return result;
    }

    function polymerWrap(element) {
      return typeof Polymer !== 'undefined' && typeof wrap === 'function' ? wrap(element) : element;
    }

    function polymerUnwrap(element) {
      return typeof Polymer !== 'undefined' && typeof unwrap === 'function' ? unwrap(element) : element;
    }

    function index(element) {
      var i = 0;
      if (element.previousSibling) {
        while (element = element.previousSibling) {
          ++i;
        }
      }
      return i;
    }

    function overlayContainsElement(overlayType, element) {
      var overlayElement = document.querySelector('.ht_clone_' + overlayType);
      return overlayElement ? overlayElement.contains(element) : null;
    }
    var classListSupport = !!document.documentElement.classList;
    var _hasClass, _addClass, _removeClass;

    function filterEmptyClassNames(classNames) {
      var len = 0,
        result = [];
      if (!classNames || !classNames.length) {
        return result;
      }
      while (classNames[len]) {
        result.push(classNames[len]);
        len++;
      }
      return result;
    }
    if (classListSupport) {
      var isSupportMultipleClassesArg = function () {
        var element = document.createElement('div');
        element.classList.add('test', 'test2');
        return element.classList.contains('test2');
      }();
      _hasClass = function _hasClass(element, className) {
        if (element.classList === void 0 || className === '') {
          return false;
        }
        return element.classList.contains(className);
      };
      _addClass = function _addClass(element, className) {
        var len = 0;
        if (typeof className === 'string') {
          className = className.split(' ');
        }
        className = filterEmptyClassNames(className);
        if (isSupportMultipleClassesArg) {
          element.classList.add.apply(element.classList, className);
        } else {
          while (className && className[len]) {
            element.classList.add(className[len]);
            len++;
          }
        }
      };
      _removeClass = function _removeClass(element, className) {
        var len = 0;
        if (typeof className === 'string') {
          className = className.split(' ');
        }
        className = filterEmptyClassNames(className);
        if (isSupportMultipleClassesArg) {
          element.classList.remove.apply(element.classList, className);
        } else {
          while (className && className[len]) {
            element.classList.remove(className[len]);
            len++;
          }
        }
      };
    } else {
      var createClassNameRegExp = function createClassNameRegExp(className) {
        return new RegExp('(\\s|^)' + className + '(\\s|$)');
      };
      _hasClass = function _hasClass(element, className) {
        return element.className !== void 0 && element.className.test(createClassNameRegExp(className));
      };
      _addClass = function _addClass(element, className) {
        var len = 0,
          _className = element.className;
        if (typeof className === 'string') {
          className = className.split(' ');
        }
        if (_className === '') {
          _className = className.join(' ');
        } else {
          while (className && className[len]) {
            if (!createClassNameRegExp(className[len]).test(_className)) {
              _className += ' ' + className[len];
            }
            len++;
          }
        }
        element.className = _className;
      };
      _removeClass = function _removeClass(element, className) {
        var len = 0,
          _className = element.className;
        if (typeof className === 'string') {
          className = className.split(' ');
        }
        while (className && className[len]) {
          _className = _className.replace(createClassNameRegExp(className[len]), ' ').trim();
          len++;
        }
        if (element.className !== _className) {
          element.className = _className;
        }
      };
    }

    function hasClass(element, className) {
      return _hasClass(element, className);
    }

    function addClass(element, className) {
      return _addClass(element, className);
    }

    function removeClass(element, className) {
      return _removeClass(element, className);
    }

    function removeTextNodes(element, parent) {
      if (element.nodeType === 3) {
        parent.removeChild(element);
      } else if (['TABLE', 'THEAD', 'TBODY', 'TFOOT', 'TR'].indexOf(element.nodeName) > -1) {
        var childs = element.childNodes;
        for (var i = childs.length - 1; i >= 0; i--) {
          removeTextNodes(childs[i], element);
        }
      }
    }

    function empty(element) {
      var child;
      while (child = element.lastChild) {
        element.removeChild(child);
      }
    }
    var HTML_CHARACTERS = exports.HTML_CHARACTERS = /(<(.*)>|&(.*);)/;

    function fastInnerHTML(element, content) {
      if (HTML_CHARACTERS.test(content)) {
        element.innerHTML = content;
      } else {
        fastInnerText(element, content);
      }
    }
    var textContextSupport = !!document.createTextNode('test').textContent;

    function fastInnerText(element, content) {
      var child = element.firstChild;
      if (child && child.nodeType === 3 && child.nextSibling === null) {
        if (textContextSupport) {
          child.textContent = content;
        } else {
          child.data = content;
        }
      } else {
        empty(element);
        element.appendChild(document.createTextNode(content));
      }
    }

    function isVisible(elem) {
      var next = elem;
      while (polymerUnwrap(next) !== document.documentElement) {
        if (next === null) {
          return false;
        } else if (next.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
          if (next.host) {
            if (next.host.impl) {
              return isVisible(next.host.impl);
            } else if (next.host) {
              return isVisible(next.host);
            }
            throw new Error('Lost in Web Components world');
          } else {
            return false;
          }
        } else if (next.style.display === 'none') {
          return false;
        }
        next = next.parentNode;
      }
      return true;
    }

    function offset(elem) {
      var offsetLeft, offsetTop, lastElem, docElem, box;
      docElem = document.documentElement;
      if ((0, _feature.hasCaptionProblem)() && elem.firstChild && elem.firstChild.nodeName === 'CAPTION') {
        box = elem.getBoundingClientRect();
        return {
          top: box.top + (window.pageYOffset || docElem.scrollTop) - (docElem.clientTop || 0),
          left: box.left + (window.pageXOffset || docElem.scrollLeft) - (docElem.clientLeft || 0)
        };
      }
      offsetLeft = elem.offsetLeft;
      offsetTop = elem.offsetTop;
      lastElem = elem;
      while (elem = elem.offsetParent) {
        if (elem === document.body) {
          break;
        }
        offsetLeft += elem.offsetLeft;
        offsetTop += elem.offsetTop;
        lastElem = elem;
      }
      if (lastElem && lastElem.style.position === 'fixed') {
        offsetLeft += window.pageXOffset || docElem.scrollLeft;
        offsetTop += window.pageYOffset || docElem.scrollTop;
      }
      return {
        left: offsetLeft,
        top: offsetTop
      };
    }

    function getWindowScrollTop() {
      var res = window.scrollY;
      if (res === void 0) {
        res = document.documentElement.scrollTop;
      }
      return res;
    }

    function getWindowScrollLeft() {
      var res = window.scrollX;
      if (res === void 0) {
        res = document.documentElement.scrollLeft;
      }
      return res;
    }

    function getScrollTop(element) {
      if (element === window) {
        return getWindowScrollTop();
      }
      return element.scrollTop;
    }

    function getScrollLeft(element) {
      if (element === window) {
        return getWindowScrollLeft();
      }
      return element.scrollLeft;
    }

    function getScrollableElement(element) {
      var el = element.parentNode,
        props = ['auto', 'scroll'],
        overflow, overflowX, overflowY, computedStyle = '',
        computedOverflow = '',
        computedOverflowY = '',
        computedOverflowX = '';
      while (el && el.style && document.body !== el) {
        overflow = el.style.overflow;
        overflowX = el.style.overflowX;
        overflowY = el.style.overflowY;
        if (overflow == 'scroll' || overflowX == 'scroll' || overflowY == 'scroll') {
          return el;
        } else if (window.getComputedStyle) {
          computedStyle = window.getComputedStyle(el);
          computedOverflow = computedStyle.getPropertyValue('overflow');
          computedOverflowY = computedStyle.getPropertyValue('overflow-y');
          computedOverflowX = computedStyle.getPropertyValue('overflow-x');
          if (computedOverflow === 'scroll' || computedOverflowX === 'scroll' || computedOverflowY === 'scroll') {
            return el;
          }
        }
        if (el.clientHeight <= el.scrollHeight && (props.indexOf(overflowY) !== -1 || props.indexOf(overflow) !== -1 || props.indexOf(computedOverflow) !== -1 || props.indexOf(computedOverflowY) !== -1)) {
          return el;
        }
        if (el.clientWidth <= el.scrollWidth && (props.indexOf(overflowX) !== -1 || props.indexOf(overflow) !== -1 || props.indexOf(computedOverflow) !== -1 || props.indexOf(computedOverflowX) !== -1)) {
          return el;
        }
        el = el.parentNode;
      }
      return window;
    }

    function getTrimmingContainer(base) {
      var el = base.parentNode;
      while (el && el.style && document.body !== el) {
        if (el.style.overflow !== 'visible' && el.style.overflow !== '') {
          return el;
        } else if (window.getComputedStyle) {
          var computedStyle = window.getComputedStyle(el);
          if (computedStyle.getPropertyValue('overflow') !== 'visible' && computedStyle.getPropertyValue('overflow') !== '') {
            return el;
          }
        }
        el = el.parentNode;
      }
      return window;
    }

    function getStyle(element, prop) {
      if (!element) {
        return;
      } else if (element === window) {
        if (prop === 'width') {
          return window.innerWidth + 'px';
        } else if (prop === 'height') {
          return window.innerHeight + 'px';
        }
        return;
      }
      var styleProp = element.style[prop],
        computedStyle;
      if (styleProp !== '' && styleProp !== void 0) {
        return styleProp;
      } else {
        computedStyle = getComputedStyle(element);
        if (computedStyle[prop] !== '' && computedStyle[prop] !== void 0) {
          return computedStyle[prop];
        }
      }
    }

    function getComputedStyle(element) {
      return element.currentStyle || document.defaultView.getComputedStyle(element);
    }

    function outerWidth(element) {
      return element.offsetWidth;
    }

    function outerHeight(elem) {
      if ((0, _feature.hasCaptionProblem)() && elem.firstChild && elem.firstChild.nodeName === 'CAPTION') {
        return elem.offsetHeight + elem.firstChild.offsetHeight;
      }
      return elem.offsetHeight;
    }

    function innerHeight(element) {
      return element.clientHeight || element.innerHeight;
    }

    function innerWidth(element) {
      return element.clientWidth || element.innerWidth;
    }

    function addEvent(element, event, callback) {
      if (window.addEventListener) {
        element.addEventListener(event, callback, false);
      } else {
        element.attachEvent('on' + event, callback);
      }
    }

    function removeEvent(element, event, callback) {
      if (window.removeEventListener) {
        element.removeEventListener(event, callback, false);
      } else {
        element.detachEvent('on' + event, callback);
      }
    }

    function getCaretPosition(el) {
      if (el.selectionStart) {
        return el.selectionStart;
      } else if (document.selection) {
        el.focus();
        var r = document.selection.createRange();
        if (r == null) {
          return 0;
        }
        var re = el.createTextRange();
        var rc = re.duplicate();
        re.moveToBookmark(r.getBookmark());
        rc.setEndPoint('EndToStart', re);
        return rc.text.length;
      }
      return 0;
    }

    function getSelectionEndPosition(el) {
      if (el.selectionEnd) {
        return el.selectionEnd;
      } else if (document.selection) {
        var r = document.selection.createRange();
        if (r == null) {
          return 0;
        }
        var re = el.createTextRange();
        return re.text.indexOf(r.text) + r.text.length;
      }
      return 0;
    }

    function getSelectionText() {
      var text = '';
      if (window.getSelection) {
        text = window.getSelection().toString();
      } else if (document.selection && document.selection.type !== 'Control') {
        text = document.selection.createRange().text;
      }
      return text;
    }

    function setCaretPosition(element, pos, endPos) {
      if (endPos === void 0) {
        endPos = pos;
      }
      if (element.setSelectionRange) {
        element.focus();
        try {
          element.setSelectionRange(pos, endPos);
        } catch (err) {
          var elementParent = element.parentNode;
          var parentDisplayValue = elementParent.style.display;
          elementParent.style.display = 'block';
          element.setSelectionRange(pos, endPos);
          elementParent.style.display = parentDisplayValue;
        }
      } else if (element.createTextRange) {
        var range = element.createTextRange();
        range.collapse(true);
        range.moveEnd('character', endPos);
        range.moveStart('character', pos);
        range.select();
      }
    }
    var cachedScrollbarWidth;

    function walkontableCalculateScrollbarWidth() {
      var inner = document.createElement('div');
      inner.style.height = '200px';
      inner.style.width = '100%';
      var outer = document.createElement('div');
      outer.style.boxSizing = 'content-box';
      outer.style.height = '150px';
      outer.style.left = '0px';
      outer.style.overflow = 'hidden';
      outer.style.position = 'absolute';
      outer.style.top = '0px';
      outer.style.width = '200px';
      outer.style.visibility = 'hidden';
      outer.appendChild(inner);
      (document.body || document.documentElement).appendChild(outer);
      var w1 = inner.offsetWidth;
      outer.style.overflow = 'scroll';
      var w2 = inner.offsetWidth;
      if (w1 == w2) {
        w2 = outer.clientWidth;
      } (document.body || document.documentElement).removeChild(outer);
      return w1 - w2;
    }

    function getScrollbarWidth() {
      if (cachedScrollbarWidth === void 0) {
        cachedScrollbarWidth = walkontableCalculateScrollbarWidth();
      }
      return cachedScrollbarWidth;
    }

    function hasVerticalScrollbar(element) {
      return element.offsetWidth !== element.clientWidth;
    }

    function hasHorizontalScrollbar(element) {
      return element.offsetHeight !== element.clientHeight;
    }

    function setOverlayPosition(overlayElem, left, top) {
      if ((0, _browser.isIE8)() || (0, _browser.isIE9)()) {
        overlayElem.style.top = top;
        overlayElem.style.left = left;
      } else if ((0, _browser.isSafari)()) {
        overlayElem.style['-webkit-transform'] = 'translate3d(' + left + ',' + top + ',0)';
      } else {
        overlayElem.style.transform = 'translate3d(' + left + ',' + top + ',0)';
      }
    }

    function getCssTransform(element) {
      var transform;
      if (element.style.transform && (transform = element.style.transform) !== '') {
        return ['transform', transform];
      } else if (element.style['-webkit-transform'] && (transform = element.style['-webkit-transform']) !== '') {
        return ['-webkit-transform', transform];
      }
      return -1;
    }

    function resetCssTransform(element) {
      if (element.style.transform && element.style.transform !== '') {
        element.style.transform = '';
      } else if (element.style['-webkit-transform'] && element.style['-webkit-transform'] !== '') {
        element.style['-webkit-transform'] = '';
      }
    }

    function isInput(element) {
      var inputs = ['INPUT', 'SELECT', 'TEXTAREA'];
      return element && (inputs.indexOf(element.nodeName) > -1 || element.contentEditable === 'true');
    }

    function isOutsideInput(element) {
      return isInput(element) && element.className.indexOf('handsontableInput') == -1 && element.className.indexOf('copyPaste') == -1;
    }
  }), (function (module, exports, __webpack_require__) {
    var global = __webpack_require__(10);
    var core = __webpack_require__(45);
    var hide = __webpack_require__(31);
    var redefine = __webpack_require__(32);
    var ctx = __webpack_require__(30);
    var PROTOTYPE = 'prototype';
    var $export = function (type, name, source) {
      var IS_FORCED = type & $export.F;
      var IS_GLOBAL = type & $export.G;
      var IS_STATIC = type & $export.S;
      var IS_PROTO = type & $export.P;
      var IS_BIND = type & $export.B;
      var target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE];
      var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});
      var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});
      var key, own, out, exp;
      if (IS_GLOBAL) source = name;
      for (key in source) {
        own = !IS_FORCED && target && target[key] !== undefined;
        out = (own ? target : source)[key];
        exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
        if (target) redefine(target, key, out, type & $export.U);
        if (exports[key] != out) hide(exports, key, exp);
        if (IS_PROTO && expProto[key] != out) expProto[key] = out;
      }
    };
    global.core = core;
    $export.F = 1;
    $export.G = 2;
    $export.S = 4;
    $export.P = 8;
    $export.B = 16;
    $export.W = 32;
    $export.U = 64;
    $export.R = 128;
    module.exports = $export;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.to2dArray = to2dArray;
    exports.extendArray = extendArray;
    exports.pivot = pivot;
    exports.arrayReduce = arrayReduce;
    exports.arrayFilter = arrayFilter;
    exports.arrayMap = arrayMap;
    exports.arrayEach = arrayEach;
    exports.arraySum = arraySum;
    exports.arrayMax = arrayMax;
    exports.arrayMin = arrayMin;
    exports.arrayAvg = arrayAvg;
    exports.arrayFlatten = arrayFlatten;
    exports.arrayUnique = arrayUnique;

    function to2dArray(arr) {
      var i = 0,
        ilen = arr.length;
      while (i < ilen) {
        arr[i] = [arr[i]];
        i++;
      }
    }

    function extendArray(arr, extension) {
      var i = 0,
        ilen = extension.length;
      while (i < ilen) {
        arr.push(extension[i]);
        i++;
      }
    }

    function pivot(arr) {
      var pivotedArr = [];
      if (!arr || arr.length === 0 || !arr[0] || arr[0].length === 0) {
        return pivotedArr;
      }
      var rowCount = arr.length;
      var colCount = arr[0].length;
      for (var i = 0; i < rowCount; i++) {
        for (var j = 0; j < colCount; j++) {
          if (!pivotedArr[j]) {
            pivotedArr[j] = [];
          }
          pivotedArr[j][i] = arr[i][j];
        }
      }
      return pivotedArr;
    }

    function arrayReduce(array, iteratee, accumulator, initFromArray) {
      var index = -1,
        length = array.length;
      if (initFromArray && length) {
        accumulator = array[++index];
      }
      while (++index < length) {
        accumulator = iteratee(accumulator, array[index], index, array);
      }
      return accumulator;
    }

    function arrayFilter(array, predicate) {
      var index = -1,
        length = array.length,
        resIndex = -1,
        result = [];
      while (++index < length) {
        var value = array[index];
        if (predicate(value, index, array)) {
          result[++resIndex] = value;
        }
      }
      return result;
    }

    function arrayMap(array, iteratee) {
      var index = -1,
        length = array.length,
        resIndex = -1,
        result = [];
      while (++index < length) {
        var value = array[index];
        result[++resIndex] = iteratee(value, index, array);
      }
      return result;
    }

    function arrayEach(array, iteratee) {
      var index = -1,
        length = array.length;
      while (++index < length) {
        if (iteratee(array[index], index, array) === false) {
          break;
        }
      }
      return array;
    }

    function arraySum(array) {
      return arrayReduce(array, function (a, b) {
        return a + b;
      }, 0);
    }

    function arrayMax(array) {
      return arrayReduce(array, function (a, b) {
        return a > b ? a : b;
      }, Array.isArray(array) ? array[0] : void 0);
    }

    function arrayMin(array) {
      return arrayReduce(array, function (a, b) {
        return a < b ? a : b;
      }, Array.isArray(array) ? array[0] : void 0);
    }

    function arrayAvg(array) {
      if (!array.length) {
        return 0;
      }
      return arraySum(array) / array.length;
    }

    function arrayFlatten(array) {
      return arrayReduce(array, function (initial, value) {
        return initial.concat(Array.isArray(value) ? arrayFlatten(value) : value);
      }, []);
    }

    function arrayUnique(array) {
      var unique = [];
      arrayEach(array, function (value) {
        if (unique.indexOf(value) === -1) {
          unique.push(value);
        }
      });
      return unique;
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
      return typeof obj;
    } : function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
    exports.duckSchema = duckSchema;
    exports.inherit = inherit;
    exports.extend = extend;
    exports.deepExtend = deepExtend;
    exports.deepClone = deepClone;
    exports.clone = clone;
    exports.mixin = mixin;
    exports.isObjectEquals = isObjectEquals;
    exports.isObject = isObject;
    exports.defineGetter = defineGetter;
    exports.objectEach = objectEach;
    exports.getProperty = getProperty;
    exports.deepObjectSize = deepObjectSize;
    exports.createObjectPropListener = createObjectPropListener;
    exports.hasOwnProperty = hasOwnProperty;
    var _array = __webpack_require__(2);

    function _defineProperty(obj, key, value) {
      if (key in obj) {
        Object.defineProperty(obj, key, {
          value: value,
          enumerable: true,
          configurable: true,
          writable: true
        });
      } else {
        obj[key] = value;
      }
      return obj;
    }

    function duckSchema(object) {
      var schema;
      if (Array.isArray(object)) {
        schema = [];
      } else {
        schema = {};
        objectEach(object, function (value, key) {
          if (key === '__children') {
            return;
          }
          if (value && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && !Array.isArray(value)) {
            schema[key] = duckSchema(value);
          } else if (Array.isArray(value)) {
            if (value.length && _typeof(value[0]) === 'object' && !Array.isArray(value[0])) {
              schema[key] = [duckSchema(value[0])];
            } else {
              schema[key] = [];
            }
          } else {
            schema[key] = null;
          }
        });
      }
      return schema;
    }

    function inherit(Child, Parent) {
      Parent.prototype.constructor = Parent;
      Child.prototype = new Parent();
      Child.prototype.constructor = Child;
      return Child;
    }

    function extend(target, extension) {
      objectEach(extension, function (value, key) {
        target[key] = value;
      });
      return target;
    }

    function deepExtend(target, extension) {
      objectEach(extension, function (value, key) {
        if (extension[key] && _typeof(extension[key]) === 'object') {
          if (!target[key]) {
            if (Array.isArray(extension[key])) {
              target[key] = [];
            } else if (Object.prototype.toString.call(extension[key]) === '[object Date]') {
              target[key] = extension[key];
            } else {
              target[key] = {};
            }
          }
          deepExtend(target[key], extension[key]);
        } else {
          target[key] = extension[key];
        }
      });
    }

    function deepClone(obj) {
      if ((typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object') {
        return JSON.parse(JSON.stringify(obj));
      }
      return obj;
    }

    function clone(object) {
      var result = {};
      objectEach(object, function (value, key) {
        result[key] = value;
      });
      return result;
    }

    function mixin(Base) {
      if (!Base.MIXINS) {
        Base.MIXINS = [];
      }
      for (var _len = arguments.length, mixins = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        mixins[_key - 1] = arguments[_key];
      } (0, _array.arrayEach)(mixins, function (mixin) {
        Base.MIXINS.push(mixin.MIXIN_NAME);
        objectEach(mixin, function (value, key) {
          if (Base.prototype[key] !== void 0) {
            throw new Error('Mixin conflict. Property \'' + key + '\' already exist and cannot be overwritten.');
          }
          if (typeof value === 'function') {
            Base.prototype[key] = value;
          } else {
            var getter = function _getter(propertyName, initialValue) {
              propertyName = '_' + propertyName;
              var initValue = function initValue(value) {
                if (Array.isArray(value) || isObject(value)) {
                  value = deepClone(value);
                }
                return value;
              };
              return function () {
                if (this[propertyName] === void 0) {
                  this[propertyName] = initValue(initialValue);
                }
                return this[propertyName];
              };
            };
            var setter = function _setter(propertyName) {
              propertyName = '_' + propertyName;
              return function (value) {
                this[propertyName] = value;
              };
            };
            Object.defineProperty(Base.prototype, key, {
              get: getter(key, value),
              set: setter(key),
              configurable: true
            });
          }
        });
      });
      return Base;
    }

    function isObjectEquals(object1, object2) {
      return JSON.stringify(object1) === JSON.stringify(object2);
    }

    function isObject(obj) {
      return Object.prototype.toString.call(obj) == '[object Object]';
    }

    function defineGetter(object, property, value, options) {
      options.value = value;
      options.writable = options.writable !== false;
      options.enumerable = options.enumerable !== false;
      options.configurable = options.configurable !== false;
      Object.defineProperty(object, property, options);
    }

    function objectEach(object, iteratee) {
      for (var key in object) {
        if (!object.hasOwnProperty || object.hasOwnProperty && Object.prototype.hasOwnProperty.call(object, key)) {
          if (iteratee(object[key], key, object) === false) {
            break;
          }
        }
      }
      return object;
    }

    function getProperty(object, name) {
      var names = name.split('.');
      var result = object;
      objectEach(names, function (name) {
        result = result[name];
        if (result === void 0) {
          result = void 0;
          return false;
        }
      });
      return result;
    }

    function deepObjectSize(object) {
      if (!isObject(object)) {
        return 0;
      }
      var recursObjLen = function recursObjLen(obj) {
        var result = 0;
        if (isObject(obj)) {
          objectEach(obj, function (key) {
            result += recursObjLen(key);
          });
        } else {
          result++;
        }
        return result;
      };
      return recursObjLen(object);
    }

    function createObjectPropListener(defaultValue) {
      var _holder;
      var propertyToListen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'value';
      var privateProperty = '_' + propertyToListen;
      var holder = (_holder = {
        _touched: false
      }, _defineProperty(_holder, privateProperty, defaultValue), _defineProperty(_holder, 'isTouched', function isTouched() {
        return this._touched;
      }), _holder);
      Object.defineProperty(holder, propertyToListen, {
        get: function get() {
          return this[privateProperty];
        },
        set: function set(value) {
          this._touched = true;
          this[privateProperty] = value;
        },
        enumerable: true,
        configurable: true
      });
      return holder;
    }

    function hasOwnProperty(object, key) {
      return Object.prototype.hasOwnProperty.call(object, key);
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    exports.getListenersCounter = getListenersCounter;
    var _element = __webpack_require__(0);
    var _object = __webpack_require__(3);
    var _feature = __webpack_require__(34);
    var _event = __webpack_require__(7);

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var listenersCounter = 0;
    var EventManager = function () {
      function EventManager() {
        var context = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
        _classCallCheck(this, EventManager);
        this.context = context || this;
        if (!this.context.eventListeners) {
          this.context.eventListeners = [];
        }
      }
      _createClass(EventManager, [{
        key: 'addEventListener',
        value: function addEventListener(element, eventName, callback) {
          var _this = this;
          var context = this.context;

          function callbackProxy(event) {
            event = extendEvent(context, event);
            callback.call(this, event);
          }
          this.context.eventListeners.push({
            element: element,
            event: eventName,
            callback: callback,
            callbackProxy: callbackProxy
          });
          if (window.addEventListener) {
            element.addEventListener(eventName, callbackProxy, false);
          } else {
            element.attachEvent('on' + eventName, callbackProxy);
          }
          listenersCounter++;
          return function () {
            _this.removeEventListener(element, eventName, callback);
          };
        }
      }, {
        key: 'removeEventListener',
        value: function removeEventListener(element, eventName, callback) {
          var len = this.context.eventListeners.length;
          var tmpEvent = void 0;
          while (len--) {
            tmpEvent = this.context.eventListeners[len];
            if (tmpEvent.event == eventName && tmpEvent.element == element) {
              if (callback && callback != tmpEvent.callback) {
                continue;
              }
              this.context.eventListeners.splice(len, 1);
              if (tmpEvent.element.removeEventListener) {
                tmpEvent.element.removeEventListener(tmpEvent.event, tmpEvent.callbackProxy, false);
              } else {
                tmpEvent.element.detachEvent('on' + tmpEvent.event, tmpEvent.callbackProxy);
              }
              listenersCounter--;
            }
          }
        }
      }, {
        key: 'clearEvents',
        value: function clearEvents() {
          if (!this.context) {
            return;
          }
          var len = this.context.eventListeners.length;
          while (len--) {
            var event = this.context.eventListeners[len];
            if (event) {
              this.removeEventListener(event.element, event.event, event.callback);
            }
          }
        }
      }, {
        key: 'clear',
        value: function clear() {
          this.clearEvents();
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          this.clearEvents();
          this.context = null;
        }
      }, {
        key: 'fireEvent',
        value: function fireEvent(element, eventName) {
          var options = {
            bubbles: true,
            cancelable: eventName !== 'mousemove',
            view: window,
            detail: 0,
            screenX: 0,
            screenY: 0,
            clientX: 1,
            clientY: 1,
            ctrlKey: false,
            altKey: false,
            shiftKey: false,
            metaKey: false,
            button: 0,
            relatedTarget: undefined
          };
          var event;
          if (document.createEvent) {
            event = document.createEvent('MouseEvents');
            event.initMouseEvent(eventName, options.bubbles, options.cancelable, options.view, options.detail, options.screenX, options.screenY, options.clientX, options.clientY, options.ctrlKey, options.altKey, options.shiftKey, options.metaKey, options.button, options.relatedTarget || document.body.parentNode);
          } else {
            event = document.createEventObject();
          }
          if (element.dispatchEvent) {
            element.dispatchEvent(event);
          } else {
            element.fireEvent('on' + eventName, event);
          }
        }
      }]);
      return EventManager;
    }();

    function extendEvent(context, event) {
      var componentName = 'HOT-TABLE';
      var isHotTableSpotted = void 0;
      var fromElement = void 0;
      var realTarget = void 0;
      var target = void 0;
      var len = void 0;
      var nativeStopImmediatePropagation = void 0;
      event.isTargetWebComponent = false;
      event.realTarget = event.target;
      nativeStopImmediatePropagation = event.stopImmediatePropagation;
      event.stopImmediatePropagation = function () {
        nativeStopImmediatePropagation.apply(this);
        (0, _event.stopImmediatePropagation)(this);
      };
      if (!EventManager.isHotTableEnv) {
        return event;
      }
      event = (0, _element.polymerWrap)(event);
      len = event.path ? event.path.length : 0;
      while (len--) {
        if (event.path[len].nodeName === componentName) {
          isHotTableSpotted = true;
        } else if (isHotTableSpotted && event.path[len].shadowRoot) {
          target = event.path[len];
          break;
        }
        if (len === 0 && !target) {
          target = event.path[len];
        }
      }
      if (!target) {
        target = event.target;
      }
      event.isTargetWebComponent = true;
      if ((0, _feature.isWebComponentSupportedNatively)()) {
        event.realTarget = event.srcElement || event.toElement;
      } else if ((0, _object.hasOwnProperty)(context, 'hot') || context.isHotTableEnv || context.wtTable) {
        if ((0, _object.hasOwnProperty)(context, 'hot')) {
          fromElement = context.hot ? context.hot.view.wt.wtTable.TABLE : null;
        } else if (context.isHotTableEnv) {
          fromElement = context.view.activeWt.wtTable.TABLE.parentNode.parentNode;
        } else if (context.wtTable) {
          fromElement = context.wtTable.TABLE.parentNode.parentNode;
        }
        realTarget = (0, _element.closest)(event.target, [componentName], fromElement);
        if (realTarget) {
          event.realTarget = fromElement.querySelector(componentName) || event.target;
        } else {
          event.realTarget = event.target;
        }
      }
      Object.defineProperty(event, 'target', {
        get: function get() {
          return (0, _element.polymerWrap)(target);
        },
        enumerable: true,
        configurable: true
      });
      return event;
    }
    exports.default = EventManager;

    function getListenersCounter() {
      return listenersCounter;
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
      return typeof obj;
    } : function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
    exports.isNumeric = isNumeric;
    exports.rangeEach = rangeEach;
    exports.rangeEachReverse = rangeEachReverse;
    exports.valueAccordingPercent = valueAccordingPercent;

    function isNumeric(n) {
      var t = typeof n === 'undefined' ? 'undefined' : _typeof(n);
      return t == 'number' ? !isNaN(n) && isFinite(n) : t == 'string' ? !n.length ? false : n.length == 1 ? /\d/.test(n) : /^\s*[+-]?\s*(?:(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?)|(?:0x[a-f\d]+))\s*$/i.test(n) : t == 'object' ? !!n && typeof n.valueOf() == 'number' && !(n instanceof Date) : false;
    }

    function rangeEach(rangeFrom, rangeTo, iteratee) {
      var index = -1;
      if (typeof rangeTo === 'function') {
        iteratee = rangeTo;
        rangeTo = rangeFrom;
      } else {
        index = rangeFrom - 1;
      }
      while (++index <= rangeTo) {
        if (iteratee(index) === false) {
          break;
        }
      }
    }

    function rangeEachReverse(rangeFrom, rangeTo, iteratee) {
      var index = rangeFrom + 1;
      if (typeof rangeTo === 'function') {
        iteratee = rangeTo;
        rangeTo = 0;
      }
      while (--index >= rangeTo) {
        if (iteratee(index) === false) {
          break;
        }
      }
    }

    function valueAccordingPercent(value, percent) {
      percent = parseInt(percent.toString().replace('%', ''), 10);
      percent = parseInt(value * percent / 100, 10);
      return percent;
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.getRegisteredRenderers = exports.getRegisteredRendererNames = exports.hasRenderer = exports.getRenderer = exports.registerRenderer = undefined;
    var _staticRegister2 = __webpack_require__(53);
    var _staticRegister3 = _interopRequireDefault(_staticRegister2);
    var _cellDecorator = __webpack_require__(376);
    var _cellDecorator2 = _interopRequireDefault(_cellDecorator);
    var _autocompleteRenderer = __webpack_require__(377);
    var _autocompleteRenderer2 = _interopRequireDefault(_autocompleteRenderer);
    var _checkboxRenderer = __webpack_require__(378);
    var _checkboxRenderer2 = _interopRequireDefault(_checkboxRenderer);
    var _htmlRenderer = __webpack_require__(379);
    var _htmlRenderer2 = _interopRequireDefault(_htmlRenderer);
    var _numericRenderer = __webpack_require__(380);
    var _numericRenderer2 = _interopRequireDefault(_numericRenderer);
    var _passwordRenderer = __webpack_require__(381);
    var _passwordRenderer2 = _interopRequireDefault(_passwordRenderer);
    var _textRenderer = __webpack_require__(382);
    var _textRenderer2 = _interopRequireDefault(_textRenderer);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }
    var _staticRegister = (0, _staticRegister3.default)('renderers'),
      register = _staticRegister.register,
      getItem = _staticRegister.getItem,
      hasItem = _staticRegister.hasItem,
      getNames = _staticRegister.getNames,
      getValues = _staticRegister.getValues;
    register('base', _cellDecorator2.default);
    register('autocomplete', _autocompleteRenderer2.default);
    register('checkbox', _checkboxRenderer2.default);
    register('html', _htmlRenderer2.default);
    register('numeric', _numericRenderer2.default);
    register('password', _passwordRenderer2.default);
    register('text', _textRenderer2.default);

    function _getItem(name) {
      if (typeof name === 'function') {
        return name;
      }
      if (!hasItem(name)) {
        throw Error('No registered renderer found under "' + name + '" name');
      }
      return getItem(name);
    }
    exports.registerRenderer = register;
    exports.getRenderer = _getItem;
    exports.hasRenderer = hasItem;
    exports.getRegisteredRendererNames = getNames;
    exports.getRegisteredRenderers = getValues;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.stopImmediatePropagation = stopImmediatePropagation;
    exports.isImmediatePropagationStopped = isImmediatePropagationStopped;
    exports.stopPropagation = stopPropagation;
    exports.pageX = pageX;
    exports.pageY = pageY;
    exports.isRightClick = isRightClick;
    exports.isLeftClick = isLeftClick;
    var _element = __webpack_require__(0);

    function stopImmediatePropagation(event) {
      event.isImmediatePropagationEnabled = false;
      event.cancelBubble = true;
    }

    function isImmediatePropagationStopped(event) {
      return event.isImmediatePropagationEnabled === false;
    }

    function stopPropagation(event) {
      if (typeof event.stopPropagation === 'function') {
        event.stopPropagation();
      } else {
        event.cancelBubble = true;
      }
    }

    function pageX(event) {
      if (event.pageX) {
        return event.pageX;
      }
      return event.clientX + (0, _element.getWindowScrollLeft)();
    }

    function pageY(event) {
      if (event.pageY) {
        return event.pageY;
      }
      return event.clientY + (0, _element.getWindowScrollTop)();
    }

    function isRightClick(event) {
      return event.button === 2;
    }

    function isLeftClick(event) {
      return event.button === 0;
    }
  }), (function (module, exports, __webpack_require__) {
    var store = __webpack_require__(84)('wks');
    var uid = __webpack_require__(51);
    var Symbol = __webpack_require__(10).Symbol;
    var USE_SYMBOL = typeof Symbol == 'function';
    var $exports = module.exports = function (name) {
      return store[name] || (store[name] = USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
    };
    $exports.store = store;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.getPluginName = exports.getRegistredPluginNames = exports.getPlugin = exports.registerPlugin = undefined;
    var _pluginHooks = __webpack_require__(11);
    var _pluginHooks2 = _interopRequireDefault(_pluginHooks);
    var _object = __webpack_require__(3);
    var _string = __webpack_require__(28);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }
    var registeredPlugins = new WeakMap();

    function registerPlugin(pluginName, PluginClass) {
      pluginName = (0, _string.toUpperCaseFirst)(pluginName);
      _pluginHooks2.default.getSingleton().add('construct', function () {
        var holder = void 0;
        if (!registeredPlugins.has(this)) {
          registeredPlugins.set(this, {});
        }
        holder = registeredPlugins.get(this);
        if (!holder[pluginName]) {
          holder[pluginName] = new PluginClass(this);
        }
      });
      _pluginHooks2.default.getSingleton().add('afterDestroy', function () {
        if (registeredPlugins.has(this)) {
          var pluginsHolder = registeredPlugins.get(this);
          (0, _object.objectEach)(pluginsHolder, function (plugin) {
            return plugin.destroy();
          });
          registeredPlugins.delete(this);
        }
      });
    }

    function getPlugin(instance, pluginName) {
      if (typeof pluginName != 'string') {
        throw Error('Only strings can be passed as "plugin" parameter');
      }
      var _pluginName = (0, _string.toUpperCaseFirst)(pluginName);
      if (!registeredPlugins.has(instance) || !registeredPlugins.get(instance)[_pluginName]) {
        return void 0;
      }
      return registeredPlugins.get(instance)[_pluginName];
    }

    function getRegistredPluginNames(hotInstance) {
      return registeredPlugins.has(hotInstance) ? Object.keys(registeredPlugins.get(hotInstance)) : [];
    }

    function getPluginName(hotInstance, plugin) {
      var pluginName = null;
      if (registeredPlugins.has(hotInstance)) {
        (0, _object.objectEach)(registeredPlugins.get(hotInstance), function (pluginInstance, name) {
          if (pluginInstance === plugin) {
            pluginName = name;
          }
        });
      }
      return pluginName;
    }
    exports.registerPlugin = registerPlugin;
    exports.getPlugin = getPlugin;
    exports.getRegistredPluginNames = getRegistredPluginNames;
    exports.getPluginName = getPluginName;
  }), (function (module, exports) {
    var global = module.exports = typeof window != 'undefined' && window.Math == Math ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
    if (typeof __g == 'number') __g = global;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _array = __webpack_require__(2);
    var _object = __webpack_require__(3);

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var REGISTERED_HOOKS = ['afterCellMetaReset', 'afterChange', 'afterChangesObserved', 'afterContextMenuDefaultOptions', 'beforeContextMenuSetItems', 'afterDropdownMenuDefaultOptions', 'beforeDropdownMenuSetItems', 'afterContextMenuHide', 'afterContextMenuShow', 'afterCopyLimit', 'beforeCreateCol', 'afterCreateCol', 'beforeCreateRow', 'afterCreateRow', 'afterDeselect', 'afterDestroy', 'afterDocumentKeyDown', 'afterGetCellMeta', 'afterGetColHeader', 'afterGetRowHeader', 'afterInit', 'afterLoadData', 'afterMomentumScroll', 'afterOnCellCornerMouseDown', 'afterOnCellCornerDblClick', 'afterOnCellMouseDown', 'afterOnCellMouseOver', 'afterOnCellMouseOut', 'afterRemoveCol', 'afterRemoveRow', 'afterRender', 'beforeRenderer', 'afterRenderer', 'afterScrollHorizontally', 'afterScrollVertically', 'afterSelection', 'afterSelectionByProp', 'afterSelectionEnd', 'afterSelectionEndByProp', 'afterSetCellMeta', 'afterRemoveCellMeta', 'afterSetDataAtCell', 'afterSetDataAtRowProp', 'afterUpdateSettings', 'afterValidate', 'beforeAutofill', 'beforeCellAlignment', 'beforeChange', 'beforeChangeRender', 'beforeDrawBorders', 'beforeGetCellMeta', 'beforeRemoveCellMeta', 'beforeInit', 'beforeInitWalkontable', 'beforeKeyDown', 'beforeOnCellMouseDown', 'beforeOnCellMouseOver', 'beforeOnCellMouseOut', 'beforeRemoveCol', 'beforeRemoveRow', 'beforeRender', 'beforeSetRangeStart', 'beforeSetRangeEnd', 'beforeTouchScroll', 'beforeValidate', 'beforeValueRender', 'construct', 'init', 'modifyCol', 'unmodifyCol', 'unmodifyRow', 'modifyColHeader', 'modifyColWidth', 'modifyRow', 'modifyRowHeader', 'modifyRowHeight', 'modifyData', 'modifyRowData', 'persistentStateLoad', 'persistentStateReset', 'persistentStateSave', 'beforeColumnSort', 'afterColumnSort', 'modifyAutofillRange', 'modifyCopyableRange', 'beforeCut', 'afterCut', 'beforeCopy', 'afterCopy', 'beforePaste', 'afterPaste', 'beforeColumnMove', 'afterColumnMove', 'beforeRowMove', 'afterRowMove', 'beforeColumnResize', 'afterColumnResize', 'beforeRowResize', 'afterRowResize', 'afterGetColumnHeaderRenderers', 'afterGetRowHeaderRenderers', 'beforeStretchingColumnWidth', 'beforeFilter', 'afterFilter', 'modifyColumnHeaderHeight', 'beforeUndo', 'afterUndo', 'beforeRedo', 'afterRedo', 'modifyRowHeaderWidth', 'beforeAutofillInsidePopulate', 'modifyTransformStart', 'modifyTransformEnd', 'afterModifyTransformStart', 'afterModifyTransformEnd', 'afterViewportRowCalculatorOverride', 'afterViewportColumnCalculatorOverride', 'afterPluginsInitialized', 'manualRowHeights', 'skipLengthCache', 'afterTrimRow', 'afterUntrimRow', 'afterDropdownMenuShow', 'afterDropdownMenuHide', 'hiddenRow', 'hiddenColumn', 'beforeAddChild', 'afterAddChild', 'beforeDetachChild', 'afterDetachChild', 'afterBeginEditing'];
    var Hooks = function () {
      _createClass(Hooks, null, [{
        key: 'getSingleton',
        value: function getSingleton() {
          return globalSingleton;
        }
      }]);

      function Hooks() {
        _classCallCheck(this, Hooks);
        this.globalBucket = this.createEmptyBucket();
      }
      _createClass(Hooks, [{
        key: 'createEmptyBucket',
        value: function createEmptyBucket() {
          var bucket = Object.create(null);
          (0, _array.arrayEach)(REGISTERED_HOOKS, function (hook) {
            return bucket[hook] = [];
          });
          return bucket;
        }
      }, {
        key: 'getBucket',
        value: function getBucket() {
          var context = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
          if (context) {
            if (!context.pluginHookBucket) {
              context.pluginHookBucket = this.createEmptyBucket();
            }
            return context.pluginHookBucket;
          }
          return this.globalBucket;
        }
      }, {
        key: 'add',
        value: function add(key, callback) {
          var _this = this;
          var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
          if (Array.isArray(callback)) {
            (0, _array.arrayEach)(callback, function (c) {
              return _this.add(key, c, context);
            });
          } else {
            var bucket = this.getBucket(context);
            if (typeof bucket[key] === 'undefined') {
              this.register(key);
              bucket[key] = [];
            }
            callback.skip = false;
            if (bucket[key].indexOf(callback) === -1) {
              var foundInitialHook = false;
              if (callback.initialHook) {
                (0, _array.arrayEach)(bucket[key], function (cb, i) {
                  if (cb.initialHook) {
                    bucket[key][i] = callback;
                    foundInitialHook = true;
                    return false;
                  }
                });
              }
              if (!foundInitialHook) {
                bucket[key].push(callback);
              }
            }
          }
          return this;
        }
      }, {
        key: 'once',
        value: function once(key, callback) {
          var _this2 = this;
          var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
          if (Array.isArray(callback)) {
            (0, _array.arrayEach)(callback, function (c) {
              return _this2.once(key, c, context);
            });
          } else {
            callback.runOnce = true;
            this.add(key, callback, context);
          }
        }
      }, {
        key: 'remove',
        value: function remove(key, callback) {
          var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
          var bucket = this.getBucket(context);
          if (typeof bucket[key] !== 'undefined') {
            if (bucket[key].indexOf(callback) >= 0) {
              callback.skip = true;
              return true;
            }
          }
          return false;
        }
      }, {
        key: 'has',
        value: function has(key) {
          var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
          var bucket = this.getBucket(context);
          return !!(bucket[key] !== void 0 && bucket[key].length);
        }
      }, {
        key: 'run',
        value: function run(context, key, p1, p2, p3, p4, p5, p6) {
          {
            var globalHandlers = this.globalBucket[key];
            var index = -1;
            var length = globalHandlers ? globalHandlers.length : 0;
            if (length) {
              while (++index < length) {
                if (!globalHandlers[index] || globalHandlers[index].skip) {
                  continue;
                }
                var res = globalHandlers[index].call(context, p1, p2, p3, p4, p5, p6);
                if (res !== void 0) {
                  p1 = res;
                }
                if (globalHandlers[index] && globalHandlers[index].runOnce) {
                  this.remove(key, globalHandlers[index]);
                }
              }
            }
          } {
            var localHandlers = this.getBucket(context)[key];
            var _index = -1;
            var _length = localHandlers ? localHandlers.length : 0;
            if (_length) {
              while (++_index < _length) {
                if (!localHandlers[_index] || localHandlers[_index].skip) {
                  continue;
                }
                var _res = localHandlers[_index].call(context, p1, p2, p3, p4, p5, p6);
                if (_res !== void 0) {
                  p1 = _res;
                }
                if (localHandlers[_index] && localHandlers[_index].runOnce) {
                  this.remove(key, localHandlers[_index], context);
                }
              }
            }
          }
          return p1;
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          var context = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
          (0, _object.objectEach)(this.getBucket(context), function (value, key, bucket) {
            return bucket[key].length = 0;
          });
        }
      }, {
        key: 'register',
        value: function register(key) {
          if (!this.isRegistered(key)) {
            REGISTERED_HOOKS.push(key);
          }
        }
      }, {
        key: 'deregister',
        value: function deregister(key) {
          if (this.isRegistered(key)) {
            REGISTERED_HOOKS.splice(REGISTERED_HOOKS.indexOf(key), 1);
          }
        }
      }, {
        key: 'isRegistered',
        value: function isRegistered(key) {
          return REGISTERED_HOOKS.indexOf(key) >= 0;
        }
      }, {
        key: 'getRegistered',
        value: function getRegistered() {
          return REGISTERED_HOOKS;
        }
      }]);
      return Hooks;
    }();
    var globalSingleton = new Hooks();
    exports.default = Hooks;
  }), (function (module, exports) {
    module.exports = function (it) {
      return typeof it === 'object' ? it !== null : typeof it === 'function';
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.getRegisteredEditors = exports.getRegisteredEditorNames = exports.hasEditor = exports.getEditorInstance = exports.getEditor = exports.registerEditor = undefined;
    exports.RegisteredEditor = RegisteredEditor;
    exports._getEditorInstance = _getEditorInstance;
    var _staticRegister2 = __webpack_require__(53);
    var _staticRegister3 = _interopRequireDefault(_staticRegister2);
    var _pluginHooks = __webpack_require__(11);
    var _pluginHooks2 = _interopRequireDefault(_pluginHooks);
    var _baseEditor = __webpack_require__(36);
    var _baseEditor2 = _interopRequireDefault(_baseEditor);
    var _autocompleteEditor = __webpack_require__(263);
    var _autocompleteEditor2 = _interopRequireDefault(_autocompleteEditor);
    var _checkboxEditor = __webpack_require__(324);
    var _checkboxEditor2 = _interopRequireDefault(_checkboxEditor);
    var _dateEditor = __webpack_require__(325);
    var _dateEditor2 = _interopRequireDefault(_dateEditor);
    var _dropdownEditor = __webpack_require__(326);
    var _dropdownEditor2 = _interopRequireDefault(_dropdownEditor);
    var _handsontableEditor = __webpack_require__(264);
    var _handsontableEditor2 = _interopRequireDefault(_handsontableEditor);
    var _mobileTextEditor = __webpack_require__(327);
    var _mobileTextEditor2 = _interopRequireDefault(_mobileTextEditor);
    var _numericEditor = __webpack_require__(328);
    var _numericEditor2 = _interopRequireDefault(_numericEditor);
    var _passwordEditor = __webpack_require__(329);
    var _passwordEditor2 = _interopRequireDefault(_passwordEditor);
    var _selectEditor = __webpack_require__(330);
    var _selectEditor2 = _interopRequireDefault(_selectEditor);
    var _textEditor = __webpack_require__(44);
    var _textEditor2 = _interopRequireDefault(_textEditor);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }
    var registeredEditorClasses = new WeakMap();
    var _staticRegister = (0, _staticRegister3.default)('editors'),
      register = _staticRegister.register,
      getItem = _staticRegister.getItem,
      hasItem = _staticRegister.hasItem,
      getNames = _staticRegister.getNames,
      getValues = _staticRegister.getValues;
    _register('base', _baseEditor2.default);
    _register('autocomplete', _autocompleteEditor2.default);
    _register('checkbox', _checkboxEditor2.default);
    _register('date', _dateEditor2.default);
    _register('dropdown', _dropdownEditor2.default);
    _register('handsontable', _handsontableEditor2.default);
    _register('mobile', _mobileTextEditor2.default);
    _register('numeric', _numericEditor2.default);
    _register('password', _passwordEditor2.default);
    _register('select', _selectEditor2.default);
    _register('text', _textEditor2.default);

    function RegisteredEditor(editorClass) {
      var instances = {};
      var Clazz = editorClass;
      this.getConstructor = function () {
        return editorClass;
      };
      this.getInstance = function (hotInstance) {
        if (!(hotInstance.guid in instances)) {
          instances[hotInstance.guid] = new Clazz(hotInstance);
        }
        return instances[hotInstance.guid];
      };
      _pluginHooks2.default.getSingleton().add('afterDestroy', function () {
        instances = {};
      });
    }

    function _getEditorInstance(name, hotInstance) {
      var editor = void 0;
      if (typeof name === 'function') {
        if (!registeredEditorClasses.get(name)) {
          _register(null, name);
        }
        editor = registeredEditorClasses.get(name);
      } else if (typeof name === 'string') {
        editor = getItem(name);
      } else {
        throw Error('Only strings and functions can be passed as "editor" parameter');
      }
      if (!editor) {
        throw Error('No editor registered under name "' + name + '"');
      }
      return editor.getInstance(hotInstance);
    }

    function _getItem(name) {
      if (!hasItem(name)) {
        throw Error('No registered editor found under "' + name + '" name');
      }
      return getItem(name).getConstructor();
    }

    function _register(name, editorClass) {
      var editorWrapper = new RegisteredEditor(editorClass);
      if (typeof name === 'string') {
        register(name, editorWrapper);
      }
      registeredEditorClasses.set(editorClass, editorWrapper);
    }
    exports.registerEditor = _register;
    exports.getEditor = _getItem;
    exports.getEditorInstance = _getEditorInstance;
    exports.hasEditor = hasItem;
    exports.getRegisteredEditorNames = getNames;
    exports.getRegisteredEditors = getValues;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.Viewport = exports.TableRenderer = exports.Table = exports.Settings = exports.Selection = exports.Scroll = exports.Overlays = exports.Event = exports.Core = exports.default = exports.Border = exports.TopLeftCornerOverlay = exports.TopOverlay = exports.LeftOverlay = exports.DebugOverlay = exports.RowFilter = exports.ColumnFilter = exports.CellRange = exports.CellCoords = exports.ViewportRowsCalculator = exports.ViewportColumnsCalculator = undefined;
    __webpack_require__(98);
    __webpack_require__(115);
    __webpack_require__(124);
    __webpack_require__(125);
    __webpack_require__(109);
    __webpack_require__(123);
    __webpack_require__(106);
    __webpack_require__(107);
    __webpack_require__(108);
    __webpack_require__(97);
    __webpack_require__(120);
    __webpack_require__(118);
    __webpack_require__(116);
    __webpack_require__(121);
    __webpack_require__(122);
    __webpack_require__(117);
    __webpack_require__(119);
    __webpack_require__(110);
    __webpack_require__(111);
    __webpack_require__(112);
    __webpack_require__(114);
    __webpack_require__(113);
    __webpack_require__(95);
    __webpack_require__(96);
    __webpack_require__(91);
    __webpack_require__(94);
    __webpack_require__(93);
    __webpack_require__(92);
    __webpack_require__(70);
    __webpack_require__(100);
    __webpack_require__(101);
    __webpack_require__(103);
    __webpack_require__(102);
    __webpack_require__(99);
    __webpack_require__(105);
    __webpack_require__(104);
    __webpack_require__(126);
    __webpack_require__(129);
    __webpack_require__(127);
    __webpack_require__(128);
    __webpack_require__(131);
    __webpack_require__(130);
    __webpack_require__(133);
    __webpack_require__(132);
    var _viewportColumns = __webpack_require__(251);
    var _viewportColumns2 = _interopRequireDefault(_viewportColumns);
    var _viewportRows = __webpack_require__(252);
    var _viewportRows2 = _interopRequireDefault(_viewportRows);
    var _coords = __webpack_require__(43);
    var _coords2 = _interopRequireDefault(_coords);
    var _range = __webpack_require__(71);
    var _range2 = _interopRequireDefault(_range);
    var _column = __webpack_require__(255);
    var _column2 = _interopRequireDefault(_column);
    var _row = __webpack_require__(256);
    var _row2 = _interopRequireDefault(_row);
    var _debug = __webpack_require__(307);
    var _debug2 = _interopRequireDefault(_debug);
    var _left = __webpack_require__(308);
    var _left2 = _interopRequireDefault(_left);
    var _top = __webpack_require__(309);
    var _top2 = _interopRequireDefault(_top);
    var _topLeftCorner = __webpack_require__(310);
    var _topLeftCorner2 = _interopRequireDefault(_topLeftCorner);
    var _border = __webpack_require__(250);
    var _border2 = _interopRequireDefault(_border);
    var _core = __webpack_require__(253);
    var _core2 = _interopRequireDefault(_core);
    var _event = __webpack_require__(254);
    var _event2 = _interopRequireDefault(_event);
    var _overlays = __webpack_require__(257);
    var _overlays2 = _interopRequireDefault(_overlays);
    var _scroll = __webpack_require__(258);
    var _scroll2 = _interopRequireDefault(_scroll);
    var _selection = __webpack_require__(311);
    var _selection2 = _interopRequireDefault(_selection);
    var _settings = __webpack_require__(259);
    var _settings2 = _interopRequireDefault(_settings);
    var _table = __webpack_require__(260);
    var _table2 = _interopRequireDefault(_table);
    var _tableRenderer = __webpack_require__(261);
    var _tableRenderer2 = _interopRequireDefault(_tableRenderer);
    var _viewport = __webpack_require__(262);
    var _viewport2 = _interopRequireDefault(_viewport);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }
    exports.ViewportColumnsCalculator = _viewportColumns2.default;
    exports.ViewportRowsCalculator = _viewportRows2.default;
    exports.CellCoords = _coords2.default;
    exports.CellRange = _range2.default;
    exports.ColumnFilter = _column2.default;
    exports.RowFilter = _row2.default;
    exports.DebugOverlay = _debug2.default;
    exports.LeftOverlay = _left2.default;
    exports.TopOverlay = _top2.default;
    exports.TopLeftCornerOverlay = _topLeftCorner2.default;
    exports.Border = _border2.default;
    exports.default = _core2.default;
    exports.Core = _core2.default;
    exports.Event = _event2.default;
    exports.Overlays = _overlays2.default;
    exports.Scroll = _scroll2.default;
    exports.Selection = _selection2.default;
    exports.Settings = _settings2.default;
    exports.Table = _table2.default;
    exports.TableRenderer = _tableRenderer2.default;
    exports.Viewport = _viewport2.default;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.KEY_CODES = undefined;
    exports.isPrintableChar = isPrintableChar;
    exports.isMetaKey = isMetaKey;
    exports.isCtrlKey = isCtrlKey;
    exports.isKey = isKey;
    var _array = __webpack_require__(2);
    var KEY_CODES = exports.KEY_CODES = {
      MOUSE_LEFT: 1,
      MOUSE_RIGHT: 3,
      MOUSE_MIDDLE: 2,
      BACKSPACE: 8,
      COMMA: 188,
      INSERT: 45,
      DELETE: 46,
      END: 35,
      ENTER: 13,
      ESCAPE: 27,
      CONTROL_LEFT: 91,
      COMMAND_LEFT: 17,
      COMMAND_RIGHT: 93,
      ALT: 18,
      HOME: 36,
      PAGE_DOWN: 34,
      PAGE_UP: 33,
      PERIOD: 190,
      SPACE: 32,
      SHIFT: 16,
      CAPS_LOCK: 20,
      TAB: 9,
      ARROW_RIGHT: 39,
      ARROW_LEFT: 37,
      ARROW_UP: 38,
      ARROW_DOWN: 40,
      F1: 112,
      F2: 113,
      F3: 114,
      F4: 115,
      F5: 116,
      F6: 117,
      F7: 118,
      F8: 119,
      F9: 120,
      F10: 121,
      F11: 122,
      F12: 123,
      A: 65,
      X: 88,
      C: 67,
      V: 86
    };

    function isPrintableChar(keyCode) {
      return keyCode == 32 || keyCode >= 48 && keyCode <= 57 || keyCode >= 96 && keyCode <= 111 || keyCode >= 186 && keyCode <= 192 || keyCode >= 219 && keyCode <= 222 || keyCode >= 226 || keyCode >= 65 && keyCode <= 90;
    }

    function isMetaKey(keyCode) {
      var metaKeys = [KEY_CODES.ARROW_DOWN, KEY_CODES.ARROW_UP, KEY_CODES.ARROW_LEFT, KEY_CODES.ARROW_RIGHT, KEY_CODES.HOME, KEY_CODES.END, KEY_CODES.DELETE, KEY_CODES.BACKSPACE, KEY_CODES.F1, KEY_CODES.F2, KEY_CODES.F3, KEY_CODES.F4, KEY_CODES.F5, KEY_CODES.F6, KEY_CODES.F7, KEY_CODES.F8, KEY_CODES.F9, KEY_CODES.F10, KEY_CODES.F11, KEY_CODES.F12, KEY_CODES.TAB, KEY_CODES.PAGE_DOWN, KEY_CODES.PAGE_UP, KEY_CODES.ENTER, KEY_CODES.ESCAPE, KEY_CODES.SHIFT, KEY_CODES.CAPS_LOCK, KEY_CODES.ALT];
      return metaKeys.indexOf(keyCode) !== -1;
    }

    function isCtrlKey(keyCode) {
      return [KEY_CODES.CONTROL_LEFT, 224, KEY_CODES.COMMAND_LEFT, KEY_CODES.COMMAND_RIGHT].indexOf(keyCode) !== -1;
    }

    function isKey(keyCode, baseCode) {
      var keys = baseCode.split('|');
      var result = false;
      (0, _array.arrayEach)(keys, function (key) {
        if (keyCode === KEY_CODES[key]) {
          result = true;
          return false;
        }
      });
      return result;
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _object = __webpack_require__(3);
    var _array = __webpack_require__(2);
    var _recordTranslator = __webpack_require__(268);
    var _plugins = __webpack_require__(9);

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var privatePool = new WeakMap();
    var initializedPlugins = null;
    var BasePlugin = function () {
      function BasePlugin(hotInstance) {
        var _this = this;
        _classCallCheck(this, BasePlugin);
        (0, _object.defineGetter)(this, 'hot', hotInstance, {
          writable: false
        });
        (0, _object.defineGetter)(this, 't', (0, _recordTranslator.getTranslator)(hotInstance), {
          writable: false
        });
        privatePool.set(this, {
          hooks: {}
        });
        initializedPlugins = null;
        this.pluginName = null;
        this.pluginsInitializedCallbacks = [];
        this.isPluginsReady = false;
        this.enabled = false;
        this.initialized = false;
        this.hot.addHook('afterPluginsInitialized', function () {
          return _this.onAfterPluginsInitialized();
        });
        this.hot.addHook('afterUpdateSettings', function () {
          return _this.onUpdateSettings();
        });
        this.hot.addHook('beforeInit', function () {
          return _this.init();
        });
      }
      _createClass(BasePlugin, [{
        key: 'init',
        value: function init() {
          this.pluginName = (0, _plugins.getPluginName)(this.hot, this);
          if (this.isEnabled && this.isEnabled()) {
            this.enablePlugin();
          }
          if (!initializedPlugins) {
            initializedPlugins = (0, _plugins.getRegistredPluginNames)(this.hot);
          }
          if (initializedPlugins.indexOf(this.pluginName) >= 0) {
            initializedPlugins.splice(initializedPlugins.indexOf(this.pluginName), 1);
          }
          if (!initializedPlugins.length) {
            this.hot.runHooks('afterPluginsInitialized');
          }
          this.initialized = true;
        }
      }, {
        key: 'enablePlugin',
        value: function enablePlugin() {
          this.enabled = true;
        }
      }, {
        key: 'disablePlugin',
        value: function disablePlugin() {
          if (this.eventManager) {
            this.eventManager.clear();
          }
          this.clearHooks();
          this.enabled = false;
        }
      }, {
        key: 'addHook',
        value: function addHook(name, callback) {
          privatePool.get(this).hooks[name] = privatePool.get(this).hooks[name] || [];
          var hooks = privatePool.get(this).hooks[name];
          this.hot.addHook(name, callback);
          hooks.push(callback);
          privatePool.get(this).hooks[name] = hooks;
        }
      }, {
        key: 'removeHooks',
        value: function removeHooks(name) {
          var _this2 = this;
          (0, _array.arrayEach)(privatePool.get(this).hooks[name] || [], function (callback) {
            _this2.hot.removeHook(name, callback);
          });
        }
      }, {
        key: 'clearHooks',
        value: function clearHooks() {
          var _this3 = this;
          var hooks = privatePool.get(this).hooks;
          (0, _object.objectEach)(hooks, function (callbacks, name) {
            return _this3.removeHooks(name);
          });
          hooks.length = 0;
        }
      }, {
        key: 'callOnPluginsReady',
        value: function callOnPluginsReady(callback) {
          if (this.isPluginsReady) {
            callback();
          } else {
            this.pluginsInitializedCallbacks.push(callback);
          }
        }
      }, {
        key: 'onAfterPluginsInitialized',
        value: function onAfterPluginsInitialized() {
          (0, _array.arrayEach)(this.pluginsInitializedCallbacks, function (callback) {
            return callback();
          });
          this.pluginsInitializedCallbacks.length = 0;
          this.isPluginsReady = true;
        }
      }, {
        key: 'onUpdateSettings',
        value: function onUpdateSettings() {
          if (this.isEnabled) {
            if (this.enabled && !this.isEnabled()) {
              this.disablePlugin();
            }
            if (!this.enabled && this.isEnabled()) {
              this.enablePlugin();
            }
            if (this.enabled && this.isEnabled()) {
              this.updatePlugin();
            }
          }
        }
      }, {
        key: 'updatePlugin',
        value: function updatePlugin() { }
      }, {
        key: 'destroy',
        value: function destroy() {
          var _this4 = this;
          if (this.eventManager) {
            this.eventManager.destroy();
          }
          this.clearHooks();
          (0, _object.objectEach)(this, function (value, property) {
            if (property !== 'hot' && property !== 't') {
              _this4[property] = null;
            }
          });
          delete this.t;
          delete this.hot;
        }
      }]);
      return BasePlugin;
    }();
    exports.default = BasePlugin;
  }), (function (module, exports, __webpack_require__) {
    var isObject = __webpack_require__(12);
    module.exports = function (it) {
      if (!isObject(it)) throw TypeError(it + ' is not an object!');
      return it;
    };
  }), (function (module, exports, __webpack_require__) {
    var anObject = __webpack_require__(17);
    var IE8_DOM_DEFINE = __webpack_require__(275);
    var toPrimitive = __webpack_require__(87);
    var dP = Object.defineProperty;
    exports.f = __webpack_require__(20) ? Object.defineProperty : function defineProperty(O, P, Attributes) {
      anObject(O);
      P = toPrimitive(P, true);
      anObject(Attributes);
      if (IE8_DOM_DEFINE) try {
        return dP(O, P, Attributes);
      } catch (e) { }
      if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
      if ('value' in Attributes) O[P] = Attributes.value;
      return O;
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.normalizeSelection = normalizeSelection;
    exports.isSeparator = isSeparator;
    exports.hasSubMenu = hasSubMenu;
    exports.isDisabled = isDisabled;
    exports.isSelectionDisabled = isSelectionDisabled;
    exports.getValidSelection = getValidSelection;
    exports.prepareVerticalAlignClass = prepareVerticalAlignClass;
    exports.prepareHorizontalAlignClass = prepareHorizontalAlignClass;
    exports.getAlignmentClasses = getAlignmentClasses;
    exports.align = align;
    exports.checkSelectionConsistency = checkSelectionConsistency;
    exports.markLabelAsSelected = markLabelAsSelected;
    exports.isItemHidden = isItemHidden;
    exports.filterSeparators = filterSeparators;
    var _array = __webpack_require__(2);
    var _element = __webpack_require__(0);
    var _separator = __webpack_require__(73);

    function normalizeSelection(selRange) {
      return {
        start: selRange.getTopLeftCorner(),
        end: selRange.getBottomRightCorner()
      };
    }

    function isSeparator(cell) {
      return (0, _element.hasClass)(cell, 'htSeparator');
    }

    function hasSubMenu(cell) {
      return (0, _element.hasClass)(cell, 'htSubmenu');
    }

    function isDisabled(cell) {
      return (0, _element.hasClass)(cell, 'htDisabled');
    }

    function isSelectionDisabled(cell) {
      return (0, _element.hasClass)(cell, 'htSelectionDisabled');
    }

    function getValidSelection(hot) {
      var selected = hot.getSelected();
      if (!selected) {
        return null;
      }
      if (selected[0] < 0) {
        return null;
      }
      return selected;
    }

    function prepareVerticalAlignClass(className, alignment) {
      if (className.indexOf(alignment) != -1) {
        return className;
      }
      className = className.replace('htTop', '').replace('htMiddle', '').replace('htBottom', '').replace('  ', '');
      className += ' ' + alignment;
      return className;
    }

    function prepareHorizontalAlignClass(className, alignment) {
      if (className.indexOf(alignment) != -1) {
        return className;
      }
      className = className.replace('htLeft', '').replace('htCenter', '').replace('htRight', '').replace('htJustify', '').replace('  ', '');
      className += ' ' + alignment;
      return className;
    }

    function getAlignmentClasses(range, callback) {
      var classes = {};
      for (var row = range.from.row; row <= range.to.row; row++) {
        for (var col = range.from.col; col <= range.to.col; col++) {
          if (!classes[row]) {
            classes[row] = [];
          }
          classes[row][col] = callback(row, col);
        }
      }
      return classes;
    }

    function align(range, type, alignment, cellDescriptor, propertySetter) {
      if (range.from.row == range.to.row && range.from.col == range.to.col) {
        applyAlignClassName(range.from.row, range.from.col, type, alignment, cellDescriptor, propertySetter);
      } else {
        for (var row = range.from.row; row <= range.to.row; row++) {
          for (var col = range.from.col; col <= range.to.col; col++) {
            applyAlignClassName(row, col, type, alignment, cellDescriptor, propertySetter);
          }
        }
      }
    }

    function applyAlignClassName(row, col, type, alignment, cellDescriptor, propertySetter) {
      var cellMeta = cellDescriptor(row, col);
      var className = alignment;
      if (cellMeta.className) {
        if (type === 'vertical') {
          className = prepareVerticalAlignClass(cellMeta.className, alignment);
        } else {
          className = prepareHorizontalAlignClass(cellMeta.className, alignment);
        }
      }
      propertySetter(row, col, 'className', className);
    }

    function checkSelectionConsistency(range, comparator) {
      var result = false;
      if (range) {
        range.forAll(function (row, col) {
          if (comparator(row, col)) {
            result = true;
            return false;
          }
        });
      }
      return result;
    }

    function markLabelAsSelected(label) {
      return '<span class="selected">' + String.fromCharCode(10003) + '</span>' + label;
    }

    function isItemHidden(item, instance) {
      return !item.hidden || !(typeof item.hidden == 'function' && item.hidden.call(instance));
    }

    function shiftSeparators(items, separator) {
      var result = items.slice(0);
      for (var i = 0; i < result.length;) {
        if (result[i].name === separator) {
          result.shift();
        } else {
          break;
        }
      }
      return result;
    }

    function popSeparators(items, separator) {
      var result = items.slice(0);
      result.reverse();
      result = shiftSeparators(result, separator);
      result.reverse();
      return result;
    }

    function removeDuplicatedSeparators(items) {
      var result = [];
      (0, _array.arrayEach)(items, function (value, index) {
        if (index > 0) {
          if (result[result.length - 1].name !== value.name) {
            result.push(value);
          }
        } else {
          result.push(value);
        }
      });
      return result;
    }

    function filterSeparators(items) {
      var separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _separator.KEY;
      var result = items.slice(0);
      result = shiftSeparators(result, separator);
      result = popSeparators(result, separator);
      result = removeDuplicatedSeparators(result);
      return result;
    }
  }), (function (module, exports, __webpack_require__) {
    module.exports = !__webpack_require__(25)(function () {
      return Object.defineProperty({}, 'a', {
        get: function () {
          return 7;
        }
      }).a != 7;
    });
  }), (function (module, exports, __webpack_require__) {
    var toInteger = __webpack_require__(64);
    var min = Math.min;
    module.exports = function (it) {
      return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0;
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.isIE8 = isIE8;
    exports.isIE9 = isIE9;
    exports.isSafari = isSafari;
    exports.isChrome = isChrome;
    exports.isMobileBrowser = isMobileBrowser;
    var _isIE8 = !document.createTextNode('test').textContent;

    function isIE8() {
      return _isIE8;
    }
    var _isIE9 = !!document.documentMode;

    function isIE9() {
      return _isIE9;
    }
    var _isSafari = /Safari/.test(navigator.userAgent) && /Apple Computer/.test(navigator.vendor);

    function isSafari() {
      return _isSafari;
    }
    var _isChrome = /Chrome/.test(navigator.userAgent) && /Google/.test(navigator.vendor);

    function isChrome() {
      return _isChrome;
    }

    function isMobileBrowser(userAgent) {
      if (!userAgent) {
        userAgent = navigator.userAgent;
      }
      return (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(userAgent));
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
      return typeof obj;
    } : function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
    var _templateObject = _taggedTemplateLiteral(['\n          Your license key of Handsontable Pro has expired.\u200C\u200C\u200C\u200C \n          Renew your maintenance plan at https://handsontable.com or downgrade to the previous version of the software.\n          '], ['\n          Your license key of Handsontable Pro has expired.\u200C\u200C\u200C\u200C\\x20\n          Renew your maintenance plan at https://handsontable.com or downgrade to the previous version of the software.\n          ']);
    exports.stringify = stringify;
    exports.isDefined = isDefined;
    exports.isUndefined = isUndefined;
    exports.isEmpty = isEmpty;
    exports.isRegExp = isRegExp;
    exports._injectProductInfo = _injectProductInfo;
    var _element = __webpack_require__(0);
    var _templateLiteralTag = __webpack_require__(331);

    function _taggedTemplateLiteral(strings, raw) {
      return Object.freeze(Object.defineProperties(strings, {
        raw: {
          value: Object.freeze(raw)
        }
      }));
    }

    function stringify(value) {
      var result = void 0;
      switch (typeof value === 'undefined' ? 'undefined' : _typeof(value)) {
        case 'string':
        case 'number':
          result = '' + value;
          break;
        case 'object':
          result = value === null ? '' : value.toString();
          break;
        case 'undefined':
          result = '';
          break;
        default:
          result = value.toString();
          break;
      }
      return result;
    }

    function isDefined(variable) {
      return typeof variable !== 'undefined';
    }

    function isUndefined(variable) {
      return typeof variable === 'undefined';
    }

    function isEmpty(variable) {
      return variable === null || variable === '' || isUndefined(variable);
    }

    function isRegExp(variable) {
      return Object.prototype.toString.call(variable) === '[object RegExp]';
    }
    var _m = '\x6C\x65\x6E\x67\x74\x68';
    var _hd = function _hd(v) {
      return parseInt(v, 16);
    };
    var _pi = function _pi(v) {
      return parseInt(v, 10);
    };
    var _ss = function _ss(v, s, l) {
      return v['\x73\x75\x62\x73\x74\x72'](s, l);
    };
    var _cp = function _cp(v) {
      return v['\x63\x6F\x64\x65\x50\x6F\x69\x6E\x74\x41\x74'](0) - 65;
    };
    var _norm = function _norm(v) {
      return v.replace(/\-/g, '');
    };
    var _extractTime = function _extractTime(v) {
      return _hd(_ss(_norm(v), _hd('12'), _cp('\x46'))) / (_hd(_ss(_norm(v), _cp('\x42'), ~~![][_m])) || 9);
    };
    var _ignored = function _ignored() {
      return typeof location !== 'undefined' && /^([a-z0-9\-]+\.)?\x68\x61\x6E\x64\x73\x6F\x6E\x74\x61\x62\x6C\x65\x2E\x63\x6F\x6D$/i.test(location.host);
    };
    var _notified = false;

    function _injectProductInfo(key, element) {
      key = _norm(key || '');
      var warningMessage = '';
      var showDomMessage = true;
      var schemaValidity = _checkKeySchema(key);
      var ignored = _ignored();
      var trial = isEmpty(key) || key === 'trial';
      if (trial || schemaValidity) {
        if (schemaValidity) {
          var releaseTime = Math.floor(moment(undefined, 'DD/MM/YYYY').toDate().getTime() / 8.64e7);
          var keyGenTime = _extractTime(key);
          if (keyGenTime > 45000 || keyGenTime !== parseInt(keyGenTime, 10)) {
            warningMessage = 'The license key provided to Handsontable Pro is invalid. Make sure you pass it correctly.';
          }
          if (!warningMessage) {
            if (releaseTime > keyGenTime + 1) {
              warningMessage = (0, _templateLiteralTag.toSingleLine)(_templateObject);
            }
            showDomMessage = releaseTime > keyGenTime + 15;
          }
        } else {
          warningMessage = 'Evaluation version of Handsontable Pro. Not licensed for use in a production environment.';
        }
      } else {
        warningMessage = 'The license key provided to Handsontable Pro is invalid. Make sure you pass it correctly.';
      }
      if (ignored) {
        warningMessage = false;
        showDomMessage = false;
      }
      if (warningMessage && !_notified) {
        console[trial ? 'info' : 'warn'](warningMessage);
        _notified = true;
      }
      if (showDomMessage && element.parentNode) {
        var message = document.createElement('div');
        (0, _element.addClass)(message, 'display-license-info');
        message.appendChild(document.createTextNode('Evaluation version of Handsontable Pro.'));
        message.appendChild(document.createElement('br'));
        message.appendChild(document.createTextNode('Not licensed for production use.'));
        element.parentNode.insertBefore(message, element.nextSibling);
      }
    }

    function _checkKeySchema(v) {
      var z = [][_m];
      var p = z;
      if (v[_m] !== _cp('\x5A')) {
        return false;
      }
      for (var c = '', i = '\x42\x3C\x48\x34\x50\x2B'.split(''), j = _cp(i.shift()); j; j = _cp(i.shift() || 'A')) {
        --j < ''[_m] ? p = p | (_pi('' + _pi(_hd(c) + (_hd(_ss(v, Math.abs(j), 2)) + []).padStart(2, '0'))) % _cp('\xA2') || 2) >> 1 : c = _ss(v, j, !j ? 6 : i[_m] === 1 ? 9 : 8);
      }
      return p === z;
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.getRegisteredValidators = exports.getRegisteredValidatorNames = exports.hasValidator = exports.getValidator = exports.registerValidator = undefined;
    var _staticRegister2 = __webpack_require__(53);
    var _staticRegister3 = _interopRequireDefault(_staticRegister2);
    var _autocompleteValidator = __webpack_require__(385);
    var _autocompleteValidator2 = _interopRequireDefault(_autocompleteValidator);
    var _dateValidator = __webpack_require__(386);
    var _dateValidator2 = _interopRequireDefault(_dateValidator);
    var _numericValidator = __webpack_require__(387);
    var _numericValidator2 = _interopRequireDefault(_numericValidator);
    var _timeValidator = __webpack_require__(388);
    var _timeValidator2 = _interopRequireDefault(_timeValidator);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }
    var _staticRegister = (0, _staticRegister3.default)('validators'),
      register = _staticRegister.register,
      getItem = _staticRegister.getItem,
      hasItem = _staticRegister.hasItem,
      getNames = _staticRegister.getNames,
      getValues = _staticRegister.getValues;
    register('autocomplete', _autocompleteValidator2.default);
    register('date', _dateValidator2.default);
    register('numeric', _numericValidator2.default);
    register('time', _timeValidator2.default);

    function _getItem(name) {
      if (typeof name === 'function') {
        return name;
      }
      if (!hasItem(name)) {
        throw Error('No registered validator found under "' + name + '" name');
      }
      return getItem(name);
    }
    exports.registerValidator = register;
    exports.getValidator = _getItem;
    exports.hasValidator = hasItem;
    exports.getRegisteredValidatorNames = getNames;
    exports.getRegisteredValidators = getValues;
  }), (function (module, exports) {
    module.exports = function (exec) {
      try {
        return !!exec();
      } catch (e) {
        return true;
      }
    };
  }), (function (module, exports) {
    var hasOwnProperty = {}.hasOwnProperty;
    module.exports = function (it, key) {
      return hasOwnProperty.call(it, key);
    };
  }), (function (module, exports, __webpack_require__) {
    var IObject = __webpack_require__(78);
    var defined = __webpack_require__(33);
    module.exports = function (it) {
      return IObject(defined(it));
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.toUpperCaseFirst = toUpperCaseFirst;
    exports.equalsIgnoreCase = equalsIgnoreCase;
    exports.randomString = randomString;
    exports.isPercentValue = isPercentValue;
    exports.substitute = substitute;
    exports.stripTags = stripTags;
    var _mixed = __webpack_require__(23);
    var _number = __webpack_require__(5);

    function toUpperCaseFirst(string) {
      return string[0].toUpperCase() + string.substr(1);
    }

    function equalsIgnoreCase() {
      var unique = [];
      for (var _len = arguments.length, strings = Array(_len), _key = 0; _key < _len; _key++) {
        strings[_key] = arguments[_key];
      }
      var length = strings.length;
      while (length--) {
        var string = (0, _mixed.stringify)(strings[length]).toLowerCase();
        if (unique.indexOf(string) === -1) {
          unique.push(string);
        }
      }
      return unique.length === 1;
    }

    function randomString() {
      function s4() {
        return Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);
      }
      return s4() + s4() + s4() + s4();
    }

    function isPercentValue(value) {
      return (/^([0-9][0-9]?%$)|(^100%$)/.test(value));
    }

    function substitute(template) {
      var variables = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      return ('' + template).replace(/(?:\\)?\[([^[\]]+)]/g, function (match, name) {
        if (match.charAt(0) === '\\') {
          return match.substr(1, match.length - 1);
        }
        return variables[name] === void 0 ? '' : variables[name];
      });
    }
    var STRIP_TAGS_REGEX = /<\/?\w+\/?>|<\w+[\s|/][^>]*>/gi;

    function stripTags(string) {
      string += '';
      return string.replace(STRIP_TAGS_REGEX, '');
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _element = __webpack_require__(0);
    var _object = __webpack_require__(3);
    var _array = __webpack_require__(2);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _core = __webpack_require__(253);
    var _core2 = _interopRequireDefault(_core);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var registeredOverlays = {};
    var Overlay = function () {
      _createClass(Overlay, null, [{
        key: 'registerOverlay',
        value: function registerOverlay(type, overlayClass) {
          if (Overlay.CLONE_TYPES.indexOf(type) === -1) {
            throw new Error('Unsupported overlay (' + type + ').');
          }
          registeredOverlays[type] = overlayClass;
        }
      }, {
        key: 'createOverlay',
        value: function createOverlay(type, wot) {
          return new registeredOverlays[type](wot);
        }
      }, {
        key: 'hasOverlay',
        value: function hasOverlay(type) {
          return registeredOverlays[type] !== void 0;
        }
      }, {
        key: 'isOverlayTypeOf',
        value: function isOverlayTypeOf(overlay, type) {
          if (!overlay || !registeredOverlays[type]) {
            return false;
          }
          return overlay instanceof registeredOverlays[type];
        }
      }, {
        key: 'CLONE_TOP',
        get: function get() {
          return 'top';
        }
      }, {
        key: 'CLONE_BOTTOM',
        get: function get() {
          return 'bottom';
        }
      }, {
        key: 'CLONE_LEFT',
        get: function get() {
          return 'left';
        }
      }, {
        key: 'CLONE_TOP_LEFT_CORNER',
        get: function get() {
          return 'top_left_corner';
        }
      }, {
        key: 'CLONE_BOTTOM_LEFT_CORNER',
        get: function get() {
          return 'bottom_left_corner';
        }
      }, {
        key: 'CLONE_DEBUG',
        get: function get() {
          return 'debug';
        }
      }, {
        key: 'CLONE_TYPES',
        get: function get() {
          return [Overlay.CLONE_TOP, Overlay.CLONE_BOTTOM, Overlay.CLONE_LEFT, Overlay.CLONE_TOP_LEFT_CORNER, Overlay.CLONE_BOTTOM_LEFT_CORNER, Overlay.CLONE_DEBUG];
        }
      }]);

      function Overlay(wotInstance) {
        _classCallCheck(this, Overlay);
        (0, _object.defineGetter)(this, 'wot', wotInstance, {
          writable: false
        });
        this.instance = this.wot;
        this.type = '';
        this.mainTableScrollableElement = null;
        this.TABLE = this.wot.wtTable.TABLE;
        this.hider = this.wot.wtTable.hider;
        this.spreader = this.wot.wtTable.spreader;
        this.holder = this.wot.wtTable.holder;
        this.wtRootElement = this.wot.wtTable.wtRootElement;
        this.trimmingContainer = (0, _element.getTrimmingContainer)(this.hider.parentNode.parentNode);
        this.areElementSizesAdjusted = false;
        this.updateStateOfRendering();
      }
      _createClass(Overlay, [{
        key: 'updateStateOfRendering',
        value: function updateStateOfRendering() {
          var previousState = this.needFullRender;
          this.needFullRender = this.shouldBeRendered();
          var changed = previousState !== this.needFullRender;
          if (changed && !this.needFullRender) {
            this.reset();
          }
          return changed;
        }
      }, {
        key: 'shouldBeRendered',
        value: function shouldBeRendered() {
          return true;
        }
      }, {
        key: 'updateTrimmingContainer',
        value: function updateTrimmingContainer() {
          this.trimmingContainer = (0, _element.getTrimmingContainer)(this.hider.parentNode.parentNode);
        }
      }, {
        key: 'updateMainScrollableElement',
        value: function updateMainScrollableElement() {
          this.mainTableScrollableElement = (0, _element.getScrollableElement)(this.wot.wtTable.TABLE);
        }
      }, {
        key: 'makeClone',
        value: function makeClone(direction) {
          if (Overlay.CLONE_TYPES.indexOf(direction) === -1) {
            throw new Error('Clone type "' + direction + '" is not supported.');
          }
          var clone = document.createElement('DIV');
          var clonedTable = document.createElement('TABLE');
          clone.className = 'ht_clone_' + direction + ' handsontable';
          clone.style.position = 'absolute';
          clone.style.top = 0;
          clone.style.left = 0;
          clone.style.overflow = 'hidden';
          clonedTable.className = this.wot.wtTable.TABLE.className;
          clone.appendChild(clonedTable);
          this.type = direction;
          this.wot.wtTable.wtRootElement.parentNode.appendChild(clone);
          var preventOverflow = this.wot.getSetting('preventOverflow');
          if (preventOverflow === true || preventOverflow === 'horizontal' && this.type === Overlay.CLONE_TOP || preventOverflow === 'vertical' && this.type === Overlay.CLONE_LEFT) {
            this.mainTableScrollableElement = window;
          } else {
            this.mainTableScrollableElement = (0, _element.getScrollableElement)(this.wot.wtTable.TABLE);
          }
          return new _core2.default({
            cloneSource: this.wot,
            cloneOverlay: this,
            table: clonedTable
          });
        }
      }, {
        key: 'refresh',
        value: function refresh() {
          var fastDraw = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
          var nextCycleRenderFlag = this.shouldBeRendered();
          if (this.clone && (this.needFullRender || nextCycleRenderFlag)) {
            this.clone.draw(fastDraw);
          }
          this.needFullRender = nextCycleRenderFlag;
        }
      }, {
        key: 'reset',
        value: function reset() {
          if (!this.clone) {
            return;
          }
          var holder = this.clone.wtTable.holder;
          var hider = this.clone.wtTable.hider;
          var holderStyle = holder.style;
          var hidderStyle = hider.style;
          var rootStyle = holder.parentNode.style;
          (0, _array.arrayEach)([holderStyle, hidderStyle, rootStyle], function (style) {
            style.width = '';
            style.height = '';
          });
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          new _eventManager2.default(this.clone).destroy();
        }
      }]);
      return Overlay;
    }();
    exports.default = Overlay;
  }), (function (module, exports, __webpack_require__) {
    var aFunction = __webpack_require__(54);
    module.exports = function (fn, that, length) {
      aFunction(fn);
      if (that === undefined) return fn;
      switch (length) {
        case 1:
          return function (a) {
            return fn.call(that, a);
          };
        case 2:
          return function (a, b) {
            return fn.call(that, a, b);
          };
        case 3:
          return function (a, b, c) {
            return fn.call(that, a, b, c);
          };
      }
      return function () {
        return fn.apply(that, arguments);
      };
    };
  }), (function (module, exports, __webpack_require__) {
    var dP = __webpack_require__(18);
    var createDesc = __webpack_require__(49);
    module.exports = __webpack_require__(20) ? function (object, key, value) {
      return dP.f(object, key, createDesc(1, value));
    } : function (object, key, value) {
      object[key] = value;
      return object;
    };
  }), (function (module, exports, __webpack_require__) {
    var global = __webpack_require__(10);
    var hide = __webpack_require__(31);
    var has = __webpack_require__(26);
    var SRC = __webpack_require__(51)('src');
    var TO_STRING = 'toString';
    var $toString = Function[TO_STRING];
    var TPL = ('' + $toString).split(TO_STRING);
    __webpack_require__(45).inspectSource = function (it) {
      return $toString.call(it);
    };
    (module.exports = function (O, key, val, safe) {
      var isFunction = typeof val == 'function';
      if (isFunction) has(val, 'name') || hide(val, 'name', key);
      if (O[key] === val) return;
      if (isFunction) has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));
      if (O === global) {
        O[key] = val;
      } else if (!safe) {
        delete O[key];
        hide(O, key, val);
      } else if (O[key]) {
        O[key] = val;
      } else {
        hide(O, key, val);
      }
    })(Function.prototype, TO_STRING, function toString() {
      return typeof this == 'function' && this[SRC] || $toString.call(this);
    });
  }), (function (module, exports) {
    module.exports = function (it) {
      if (it == undefined) throw TypeError("Can't call method on  " + it);
      return it;
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
      return typeof obj;
    } : function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
    exports.requestAnimationFrame = requestAnimationFrame;
    exports.cancelAnimationFrame = cancelAnimationFrame;
    exports.isTouchSupported = isTouchSupported;
    exports.isWebComponentSupportedNatively = isWebComponentSupportedNatively;
    exports.hasCaptionProblem = hasCaptionProblem;
    exports.getComparisonFunction = getComparisonFunction;
    var lastTime = 0;
    var vendors = ['ms', 'moz', 'webkit', 'o'];
    var _requestAnimationFrame = window.requestAnimationFrame;
    var _cancelAnimationFrame = window.cancelAnimationFrame;
    for (var x = 0; x < vendors.length && !_requestAnimationFrame; ++x) {
      _requestAnimationFrame = window[vendors[x] + 'RequestAnimationFrame'];
      _cancelAnimationFrame = window[vendors[x] + 'CancelAnimationFrame'] || window[vendors[x] + 'CancelRequestAnimationFrame'];
    }
    if (!_requestAnimationFrame) {
      _requestAnimationFrame = function _requestAnimationFrame(callback) {
        var currTime = new Date().getTime();
        var timeToCall = Math.max(0, 16 - (currTime - lastTime));
        var id = window.setTimeout(function () {
          callback(currTime + timeToCall);
        }, timeToCall);
        lastTime = currTime + timeToCall;
        return id;
      };
    }
    if (!_cancelAnimationFrame) {
      _cancelAnimationFrame = function _cancelAnimationFrame(id) {
        clearTimeout(id);
      };
    }

    function requestAnimationFrame(callback) {
      return _requestAnimationFrame.call(window, callback);
    }

    function cancelAnimationFrame(id) {
      _cancelAnimationFrame.call(window, id);
    }

    function isTouchSupported() {
      return 'ontouchstart' in window;
    }

    function isWebComponentSupportedNatively() {
      var test = document.createElement('div');
      return !!(test.createShadowRoot && test.createShadowRoot.toString().match(/\[native code\]/));
    }
    var _hasCaptionProblem;

    function detectCaptionProblem() {
      var TABLE = document.createElement('TABLE');
      TABLE.style.borderSpacing = 0;
      TABLE.style.borderWidth = 0;
      TABLE.style.padding = 0;
      var TBODY = document.createElement('TBODY');
      TABLE.appendChild(TBODY);
      TBODY.appendChild(document.createElement('TR'));
      TBODY.firstChild.appendChild(document.createElement('TD'));
      TBODY.firstChild.firstChild.innerHTML = '<tr><td>t<br>t</td></tr>';
      var CAPTION = document.createElement('CAPTION');
      CAPTION.innerHTML = 'c<br>c<br>c<br>c';
      CAPTION.style.padding = 0;
      CAPTION.style.margin = 0;
      TABLE.insertBefore(CAPTION, TBODY);
      document.body.appendChild(TABLE);
      _hasCaptionProblem = TABLE.offsetHeight < 2 * TABLE.lastChild.offsetHeight;
      document.body.removeChild(TABLE);
    }

    function hasCaptionProblem() {
      if (_hasCaptionProblem === void 0) {
        detectCaptionProblem();
      }
      return _hasCaptionProblem;
    }
    var comparisonFunction = void 0;

    function getComparisonFunction(language) {
      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      if (comparisonFunction) {
        return comparisonFunction;
      }
      if ((typeof Intl === 'undefined' ? 'undefined' : _typeof(Intl)) === 'object') {
        comparisonFunction = new Intl.Collator(language, options).compare;
      } else if (typeof String.prototype.localeCompare === 'function') {
        comparisonFunction = function comparisonFunction(a, b) {
          return ('' + a).localeCompare(b);
        };
      } else {
        comparisonFunction = function comparisonFunction(a, b) {
          if (a === b) {
            return 0;
          }
          return a > b ? -1 : 1;
        };
      }
      return comparisonFunction;
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.isFunction = isFunction;
    exports.throttle = throttle;
    exports.throttleAfterHits = throttleAfterHits;
    exports.debounce = debounce;
    exports.pipe = pipe;
    exports.partial = partial;
    exports.curry = curry;
    exports.curryRight = curryRight;
    var _array = __webpack_require__(2);

    function isFunction(func) {
      return typeof func === 'function';
    }

    function throttle(func) {
      var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 200;
      var lastCalled = 0;
      var result = {
        lastCallThrottled: true
      };
      var lastTimer = null;

      function _throttle() {
        var _this = this;
        var args = arguments;
        var stamp = Date.now();
        var needCall = false;
        result.lastCallThrottled = true;
        if (!lastCalled) {
          lastCalled = stamp;
          needCall = true;
        }
        var remaining = wait - (stamp - lastCalled);
        if (needCall) {
          result.lastCallThrottled = false;
          func.apply(this, args);
        } else {
          if (lastTimer) {
            clearTimeout(lastTimer);
          }
          lastTimer = setTimeout(function () {
            result.lastCallThrottled = false;
            func.apply(_this, args);
            lastCalled = 0;
            lastTimer = void 0;
          }, remaining);
        }
        return result;
      }
      return _throttle;
    }

    function throttleAfterHits(func) {
      var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 200;
      var hits = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 10;
      var funcThrottle = throttle(func, wait);
      var remainHits = hits;

      function _clearHits() {
        remainHits = hits;
      }

      function _throttleAfterHits() {
        if (remainHits) {
          remainHits--;
          return func.apply(this, arguments);
        }
        return funcThrottle.apply(this, arguments);
      }
      _throttleAfterHits.clearHits = _clearHits;
      return _throttleAfterHits;
    }

    function debounce(func) {
      var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 200;
      var lastTimer = null;
      var result = void 0;

      function _debounce() {
        var _this2 = this;
        var args = arguments;
        if (lastTimer) {
          clearTimeout(lastTimer);
        }
        lastTimer = setTimeout(function () {
          result = func.apply(_this2, args);
        }, wait);
        return result;
      }
      return _debounce;
    }

    function pipe() {
      for (var _len = arguments.length, functions = Array(_len), _key = 0; _key < _len; _key++) {
        functions[_key] = arguments[_key];
      }
      var firstFunc = functions[0],
        restFunc = functions.slice(1);
      return function _pipe() {
        return (0, _array.arrayReduce)(restFunc, function (acc, fn) {
          return fn(acc);
        }, firstFunc.apply(this, arguments));
      };
    }

    function partial(func) {
      for (var _len2 = arguments.length, params = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
        params[_key2 - 1] = arguments[_key2];
      }
      return function _partial() {
        for (var _len3 = arguments.length, restParams = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
          restParams[_key3] = arguments[_key3];
        }
        return func.apply(this, params.concat(restParams));
      };
    }

    function curry(func) {
      var argsLength = func.length;

      function given(argsSoFar) {
        return function _curry() {
          for (var _len4 = arguments.length, params = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
            params[_key4] = arguments[_key4];
          }
          var passedArgsSoFar = argsSoFar.concat(params);
          var result = void 0;
          if (passedArgsSoFar.length >= argsLength) {
            result = func.apply(this, passedArgsSoFar);
          } else {
            result = given(passedArgsSoFar);
          }
          return result;
        };
      }
      return given([]);
    }

    function curryRight(func) {
      var argsLength = func.length;

      function given(argsSoFar) {
        return function _curry() {
          for (var _len5 = arguments.length, params = Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
            params[_key5] = arguments[_key5];
          }
          var passedArgsSoFar = argsSoFar.concat(params.reverse());
          var result = void 0;
          if (passedArgsSoFar.length >= argsLength) {
            result = func.apply(this, passedArgsSoFar);
          } else {
            result = given(passedArgsSoFar);
          }
          return result;
        };
      }
      return given([]);
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.EditorState = undefined;
    var _src = __webpack_require__(14);
    var _mixed = __webpack_require__(23);
    var EditorState = exports.EditorState = {
      VIRGIN: 'STATE_VIRGIN',
      EDITING: 'STATE_EDITING',
      WAITING: 'STATE_WAITING',
      FINISHED: 'STATE_FINISHED'
    };

    function BaseEditor(instance) {
      this.instance = instance;
      this.state = EditorState.VIRGIN;
      this._opened = false;
      this._fullEditMode = false;
      this._closeCallback = null;
      this.init();
    }
    BaseEditor.prototype._fireCallbacks = function (result) {
      if (this._closeCallback) {
        this._closeCallback(result);
        this._closeCallback = null;
      }
    };
    BaseEditor.prototype.init = function () { };
    BaseEditor.prototype.getValue = function () {
      throw Error('Editor getValue() method unimplemented');
    };
    BaseEditor.prototype.setValue = function (newValue) {
      throw Error('Editor setValue() method unimplemented');
    };
    BaseEditor.prototype.open = function () {
      throw Error('Editor open() method unimplemented');
    };
    BaseEditor.prototype.close = function () {
      throw Error('Editor close() method unimplemented');
    };
    BaseEditor.prototype.prepare = function (row, col, prop, td, originalValue, cellProperties) {
      this.TD = td;
      this.row = row;
      this.col = col;
      this.prop = prop;
      this.originalValue = originalValue;
      this.cellProperties = cellProperties;
      this.state = EditorState.VIRGIN;
    };
    BaseEditor.prototype.extend = function () {
      var baseClass = this.constructor;

      function Editor() {
        baseClass.apply(this, arguments);
      }

      function inherit(Child, Parent) {
        function Bridge() { }
        Bridge.prototype = Parent.prototype;
        Child.prototype = new Bridge();
        Child.prototype.constructor = Child;
        return Child;
      }
      return inherit(Editor, baseClass);
    };
    BaseEditor.prototype.saveValue = function (value, ctrlDown) {
      var selection = void 0;
      var tmp = void 0;
      if (ctrlDown) {
        selection = this.instance.getSelected();
        if (selection[0] > selection[2]) {
          tmp = selection[0];
          selection[0] = selection[2];
          selection[2] = tmp;
        }
        if (selection[1] > selection[3]) {
          tmp = selection[1];
          selection[1] = selection[3];
          selection[3] = tmp;
        }
      } else {
        selection = [this.row, this.col, null, null];
      }
      this.instance.populateFromArray(selection[0], selection[1], value, selection[2], selection[3], 'edit');
    };
    BaseEditor.prototype.beginEditing = function (initialValue, event) {
      if (this.state != EditorState.VIRGIN) {
        return;
      }
      this.instance.view.scrollViewport(new _src.CellCoords(this.row, this.col));
      this.instance.view.render();
      this.state = EditorState.EDITING;
      initialValue = typeof initialValue == 'string' ? initialValue : this.originalValue;
      this.setValue((0, _mixed.stringify)(initialValue));
      this.open(event);
      this._opened = true;
      this.focus();
      this.instance.view.render();
      this.instance.runHooks('afterBeginEditing', this.row, this.col);
    };
    BaseEditor.prototype.finishEditing = function (restoreOriginalValue, ctrlDown, callback) {
      var _this = this,
        val;
      if (callback) {
        var previousCloseCallback = this._closeCallback;
        this._closeCallback = function (result) {
          if (previousCloseCallback) {
            previousCloseCallback(result);
          }
          callback(result);
          _this.instance.view.render();
        };
      }
      if (this.isWaiting()) {
        return;
      }
      if (this.state == EditorState.VIRGIN) {
        this.instance._registerTimeout(setTimeout(function () {
          _this._fireCallbacks(true);
        }, 0));
        return;
      }
      if (this.state == EditorState.EDITING) {
        if (restoreOriginalValue) {
          this.cancelChanges();
          this.instance.view.render();
          return;
        }
        var value = this.getValue();
        if (this.instance.getSettings().trimWhitespace) {
          val = [
            [typeof value === 'string' ? String.prototype.trim.call(value || '') : value]
          ];
        } else {
          val = [
            [value]
          ];
        }
        this.state = EditorState.WAITING;
        this.saveValue(val, ctrlDown);
        if (this.instance.getCellValidator(this.cellProperties)) {
          this.instance.addHookOnce('postAfterValidate', function (result) {
            _this.state = EditorState.FINISHED;
            _this.discardEditor(result);
          });
        } else {
          this.state = EditorState.FINISHED;
          this.discardEditor(true);
        }
      }
    };
    BaseEditor.prototype.cancelChanges = function () {
      this.state = EditorState.FINISHED;
      this.discardEditor();
    };
    BaseEditor.prototype.discardEditor = function (result) {
      if (this.state !== EditorState.FINISHED) {
        return;
      }
      if (result === false && this.cellProperties.allowInvalid !== true) {
        this.instance.selectCell(this.row, this.col);
        this.focus();
        this.state = EditorState.EDITING;
        this._fireCallbacks(false);
      } else {
        this.close();
        this._opened = false;
        this._fullEditMode = false;
        this.state = EditorState.VIRGIN;
        this._fireCallbacks(true);
      }
    };
    BaseEditor.prototype.enableFullEditMode = function () {
      this._fullEditMode = true;
    };
    BaseEditor.prototype.isInFullEditMode = function () {
      return this._fullEditMode;
    };
    BaseEditor.prototype.isOpened = function () {
      return this._opened;
    };
    BaseEditor.prototype.isWaiting = function () {
      return this.state === EditorState.WAITING;
    };
    BaseEditor.prototype.checkEditorSection = function () {
      var totalRows = this.instance.countRows();
      var section = '';
      if (this.row < this.instance.getSettings().fixedRowsTop) {
        if (this.col < this.instance.getSettings().fixedColumnsLeft) {
          section = 'top-left-corner';
        } else {
          section = 'top';
        }
      } else if (this.instance.getSettings().fixedRowsBottom && this.row >= totalRows - this.instance.getSettings().fixedRowsBottom) {
        if (this.col < this.instance.getSettings().fixedColumnsLeft) {
          section = 'bottom-left-corner';
        } else {
          section = 'bottom';
        }
      } else if (this.col < this.instance.getSettings().fixedColumnsLeft) {
        section = 'left';
      }
      return section;
    };
    exports.default = BaseEditor;
  }), (function (module, exports, __webpack_require__) {
    var UNSCOPABLES = __webpack_require__(8)('unscopables');
    var ArrayProto = Array.prototype;
    if (ArrayProto[UNSCOPABLES] == undefined) __webpack_require__(31)(ArrayProto, UNSCOPABLES, {});
    module.exports = function (key) {
      ArrayProto[UNSCOPABLES][key] = true;
    };
  }), (function (module, exports) {
    var toString = {}.toString;
    module.exports = function (it) {
      return toString.call(it).slice(8, -1);
    };
  }), (function (module, exports, __webpack_require__) {
    var $keys = __webpack_require__(285);
    var enumBugKeys = __webpack_require__(76);
    module.exports = Object.keys || function keys(O) {
      return $keys(O, enumBugKeys);
    };
  }), (function (module, exports, __webpack_require__) {
    var defined = __webpack_require__(33);
    module.exports = function (it) {
      return Object(defined(it));
    };
  }), (function (module, exports, __webpack_require__) {
    var isObject = __webpack_require__(12);
    module.exports = function (it, TYPE) {
      if (!isObject(it) || it._t !== TYPE) throw TypeError('Incompatible receiver, ' + TYPE + ' required!');
      return it;
    };
  }), (function (module, exports, __webpack_require__) {
    (function (module) {
      ;
      (function (global, factory) {
        true ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : global.moment = factory()
      }(this, (function () {
        'use strict';
        var hookCallback;

        function hooks() {
          return hookCallback.apply(null, arguments);
        }

        function setHookCallback(callback) {
          hookCallback = callback;
        }

        function isArray(input) {
          return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';
        }

        function isObject(input) {
          return input != null && Object.prototype.toString.call(input) === '[object Object]';
        }

        function isObjectEmpty(obj) {
          var k;
          for (k in obj) {
            return false;
          }
          return true;
        }

        function isUndefined(input) {
          return input === void 0;
        }

        function isNumber(input) {
          return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';
        }

        function isDate(input) {
          return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
        }

        function map(arr, fn) {
          var res = [],
            i;
          for (i = 0; i < arr.length; ++i) {
            res.push(fn(arr[i], i));
          }
          return res;
        }

        function hasOwnProp(a, b) {
          return Object.prototype.hasOwnProperty.call(a, b);
        }

        function extend(a, b) {
          for (var i in b) {
            if (hasOwnProp(b, i)) {
              a[i] = b[i];
            }
          }
          if (hasOwnProp(b, 'toString')) {
            a.toString = b.toString;
          }
          if (hasOwnProp(b, 'valueOf')) {
            a.valueOf = b.valueOf;
          }
          return a;
        }

        function createUTC(input, format, locale, strict) {
          return createLocalOrUTC(input, format, locale, strict, true).utc();
        }

        function defaultParsingFlags() {
          return {
            empty: false,
            unusedTokens: [],
            unusedInput: [],
            overflow: -2,
            charsLeftOver: 0,
            nullInput: false,
            invalidMonth: null,
            invalidFormat: false,
            userInvalidated: false,
            iso: false,
            parsedDateParts: [],
            meridiem: null,
            rfc2822: false,
            weekdayMismatch: false
          };
        }

        function getParsingFlags(m) {
          if (m._pf == null) {
            m._pf = defaultParsingFlags();
          }
          return m._pf;
        }
        var some;
        if (Array.prototype.some) {
          some = Array.prototype.some;
        } else {
          some = function (fun) {
            var t = Object(this);
            var len = t.length >>> 0;
            for (var i = 0; i < len; i++) {
              if (i in t && fun.call(this, t[i], i, t)) {
                return true;
              }
            }
            return false;
          };
        }
        var some$1 = some;

        function isValid(m) {
          if (m._isValid == null) {
            var flags = getParsingFlags(m);
            var parsedParts = some$1.call(flags.parsedDateParts, function (i) {
              return i != null;
            });
            var isNowValid = !isNaN(m._d.getTime()) && flags.overflow < 0 && !flags.empty && !flags.invalidMonth && !flags.invalidWeekday && !flags.nullInput && !flags.invalidFormat && !flags.userInvalidated && (!flags.meridiem || (flags.meridiem && parsedParts));
            if (m._strict) {
              isNowValid = isNowValid && flags.charsLeftOver === 0 && flags.unusedTokens.length === 0 && flags.bigHour === undefined;
            }
            if (Object.isFrozen == null || !Object.isFrozen(m)) {
              m._isValid = isNowValid;
            } else {
              return isNowValid;
            }
          }
          return m._isValid;
        }

        function createInvalid(flags) {
          var m = createUTC(NaN);
          if (flags != null) {
            extend(getParsingFlags(m), flags);
          } else {
            getParsingFlags(m).userInvalidated = true;
          }
          return m;
        }
        var momentProperties = hooks.momentProperties = [];

        function copyConfig(to, from) {
          var i, prop, val;
          if (!isUndefined(from._isAMomentObject)) {
            to._isAMomentObject = from._isAMomentObject;
          }
          if (!isUndefined(from._i)) {
            to._i = from._i;
          }
          if (!isUndefined(from._f)) {
            to._f = from._f;
          }
          if (!isUndefined(from._l)) {
            to._l = from._l;
          }
          if (!isUndefined(from._strict)) {
            to._strict = from._strict;
          }
          if (!isUndefined(from._tzm)) {
            to._tzm = from._tzm;
          }
          if (!isUndefined(from._isUTC)) {
            to._isUTC = from._isUTC;
          }
          if (!isUndefined(from._offset)) {
            to._offset = from._offset;
          }
          if (!isUndefined(from._pf)) {
            to._pf = getParsingFlags(from);
          }
          if (!isUndefined(from._locale)) {
            to._locale = from._locale;
          }
          if (momentProperties.length > 0) {
            for (i = 0; i < momentProperties.length; i++) {
              prop = momentProperties[i];
              val = from[prop];
              if (!isUndefined(val)) {
                to[prop] = val;
              }
            }
          }
          return to;
        }
        var updateInProgress = false;

        function Moment(config) {
          copyConfig(this, config);
          this._d = new Date(config._d != null ? config._d.getTime() : NaN);
          if (!this.isValid()) {
            this._d = new Date(NaN);
          }
          if (updateInProgress === false) {
            updateInProgress = true;
            hooks.updateOffset(this);
            updateInProgress = false;
          }
        }

        function isMoment(obj) {
          return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
        }

        function absFloor(number) {
          if (number < 0) {
            return Math.ceil(number) || 0;
          } else {
            return Math.floor(number);
          }
        }

        function toInt(argumentForCoercion) {
          var coercedNumber = +argumentForCoercion,
            value = 0;
          if (coercedNumber !== 0 && isFinite(coercedNumber)) {
            value = absFloor(coercedNumber);
          }
          return value;
        }

        function compareArrays(array1, array2, dontConvert) {
          var len = Math.min(array1.length, array2.length),
            lengthDiff = Math.abs(array1.length - array2.length),
            diffs = 0,
            i;
          for (i = 0; i < len; i++) {
            if ((dontConvert && array1[i] !== array2[i]) || (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
              diffs++;
            }
          }
          return diffs + lengthDiff;
        }

        function warn(msg) {
          if (hooks.suppressDeprecationWarnings === false && (typeof console !== 'undefined') && console.warn) {
            console.warn('Deprecation warning: ' + msg);
          }
        }

        function deprecate(msg, fn) {
          var firstTime = true;
          return extend(function () {
            if (hooks.deprecationHandler != null) {
              hooks.deprecationHandler(null, msg);
            }
            if (firstTime) {
              var args = [];
              var arg;
              for (var i = 0; i < arguments.length; i++) {
                arg = '';
                if (typeof arguments[i] === 'object') {
                  arg += '\n[' + i + '] ';
                  for (var key in arguments[0]) {
                    arg += key + ': ' + arguments[0][key] + ', ';
                  }
                  arg = arg.slice(0, -2);
                } else {
                  arg = arguments[i];
                }
                args.push(arg);
              }
              warn(msg + '\nArguments: ' + Array.prototype.slice.call(args).join('') + '\n' + (new Error()).stack);
              firstTime = false;
            }
            return fn.apply(this, arguments);
          }, fn);
        }
        var deprecations = {};

        function deprecateSimple(name, msg) {
          if (hooks.deprecationHandler != null) {
            hooks.deprecationHandler(name, msg);
          }
          if (!deprecations[name]) {
            warn(msg);
            deprecations[name] = true;
          }
        }
        hooks.suppressDeprecationWarnings = false;
        hooks.deprecationHandler = null;

        function isFunction(input) {
          return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
        }

        function set(config) {
          var prop, i;
          for (i in config) {
            prop = config[i];
            if (isFunction(prop)) {
              this[i] = prop;
            } else {
              this['_' + i] = prop;
            }
          }
          this._config = config;
          this._dayOfMonthOrdinalParseLenient = new RegExp((this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) + '|' + (/\d{1,2}/).source);
        }

        function mergeConfigs(parentConfig, childConfig) {
          var res = extend({}, parentConfig),
            prop;
          for (prop in childConfig) {
            if (hasOwnProp(childConfig, prop)) {
              if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
                res[prop] = {};
                extend(res[prop], parentConfig[prop]);
                extend(res[prop], childConfig[prop]);
              } else if (childConfig[prop] != null) {
                res[prop] = childConfig[prop];
              } else {
                delete res[prop];
              }
            }
          }
          for (prop in parentConfig) {
            if (hasOwnProp(parentConfig, prop) && !hasOwnProp(childConfig, prop) && isObject(parentConfig[prop])) {
              res[prop] = extend({}, res[prop]);
            }
          }
          return res;
        }

        function Locale(config) {
          if (config != null) {
            this.set(config);
          }
        }
        var keys;
        if (Object.keys) {
          keys = Object.keys;
        } else {
          keys = function (obj) {
            var i, res = [];
            for (i in obj) {
              if (hasOwnProp(obj, i)) {
                res.push(i);
              }
            }
            return res;
          };
        }
        var keys$1 = keys;
        var defaultCalendar = {
          sameDay: '[Today at] LT',
          nextDay: '[Tomorrow at] LT',
          nextWeek: 'dddd [at] LT',
          lastDay: '[Yesterday at] LT',
          lastWeek: '[Last] dddd [at] LT',
          sameElse: 'L'
        };

        function calendar(key, mom, now) {
          var output = this._calendar[key] || this._calendar['sameElse'];
          return isFunction(output) ? output.call(mom, now) : output;
        }
        var defaultLongDateFormat = {
          LTS: 'h:mm:ss A',
          LT: 'h:mm A',
          L: 'MM/DD/YYYY',
          LL: 'MMMM D, YYYY',
          LLL: 'MMMM D, YYYY h:mm A',
          LLLL: 'dddd, MMMM D, YYYY h:mm A'
        };

        function longDateFormat(key) {
          var format = this._longDateFormat[key],
            formatUpper = this._longDateFormat[key.toUpperCase()];
          if (format || !formatUpper) {
            return format;
          }
          this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
            return val.slice(1);
          });
          return this._longDateFormat[key];
        }
        var defaultInvalidDate = 'Invalid date';

        function invalidDate() {
          return this._invalidDate;
        }
        var defaultOrdinal = '%d';
        var defaultDayOfMonthOrdinalParse = /\d{1,2}/;

        function ordinal(number) {
          return this._ordinal.replace('%d', number);
        }
        var defaultRelativeTime = {
          future: 'in %s',
          past: '%s ago',
          s: 'a few seconds',
          ss: '%d seconds',
          m: 'a minute',
          mm: '%d minutes',
          h: 'an hour',
          hh: '%d hours',
          d: 'a day',
          dd: '%d days',
          M: 'a month',
          MM: '%d months',
          y: 'a year',
          yy: '%d years'
        };

        function relativeTime(number, withoutSuffix, string, isFuture) {
          var output = this._relativeTime[string];
          return (isFunction(output)) ? output(number, withoutSuffix, string, isFuture) : output.replace(/%d/i, number);
        }

        function pastFuture(diff, output) {
          var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
          return isFunction(format) ? format(output) : format.replace(/%s/i, output);
        }
        var aliases = {};

        function addUnitAlias(unit, shorthand) {
          var lowerCase = unit.toLowerCase();
          aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
        }

        function normalizeUnits(units) {
          return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
        }

        function normalizeObjectUnits(inputObject) {
          var normalizedInput = {},
            normalizedProp, prop;
          for (prop in inputObject) {
            if (hasOwnProp(inputObject, prop)) {
              normalizedProp = normalizeUnits(prop);
              if (normalizedProp) {
                normalizedInput[normalizedProp] = inputObject[prop];
              }
            }
          }
          return normalizedInput;
        }
        var priorities = {};

        function addUnitPriority(unit, priority) {
          priorities[unit] = priority;
        }

        function getPrioritizedUnits(unitsObj) {
          var units = [];
          for (var u in unitsObj) {
            units.push({
              unit: u,
              priority: priorities[u]
            });
          }
          units.sort(function (a, b) {
            return a.priority - b.priority;
          });
          return units;
        }

        function makeGetSet(unit, keepTime) {
          return function (value) {
            if (value != null) {
              set$1(this, unit, value);
              hooks.updateOffset(this, keepTime);
              return this;
            } else {
              return get(this, unit);
            }
          };
        }

        function get(mom, unit) {
          return mom.isValid() ? mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;
        }

        function set$1(mom, unit, value) {
          if (mom.isValid()) {
            mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
          }
        }

        function stringGet(units) {
          units = normalizeUnits(units);
          if (isFunction(this[units])) {
            return this[units]();
          }
          return this;
        }

        function stringSet(units, value) {
          if (typeof units === 'object') {
            units = normalizeObjectUnits(units);
            var prioritized = getPrioritizedUnits(units);
            for (var i = 0; i < prioritized.length; i++) {
              this[prioritized[i].unit](units[prioritized[i].unit]);
            }
          } else {
            units = normalizeUnits(units);
            if (isFunction(this[units])) {
              return this[units](value);
            }
          }
          return this;
        }

        function zeroFill(number, targetLength, forceSign) {
          var absNumber = '' + Math.abs(number),
            zerosToFill = targetLength - absNumber.length,
            sign = number >= 0;
          return (sign ? (forceSign ? '+' : '') : '-') + Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
        }
        var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;
        var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
        var formatFunctions = {};
        var formatTokenFunctions = {};

        function addFormatToken(token, padded, ordinal, callback) {
          var func = callback;
          if (typeof callback === 'string') {
            func = function () {
              return this[callback]();
            };
          }
          if (token) {
            formatTokenFunctions[token] = func;
          }
          if (padded) {
            formatTokenFunctions[padded[0]] = function () {
              return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
            };
          }
          if (ordinal) {
            formatTokenFunctions[ordinal] = function () {
              return this.localeData().ordinal(func.apply(this, arguments), token);
            };
          }
        }

        function removeFormattingTokens(input) {
          if (input.match(/\[[\s\S]/)) {
            return input.replace(/^\[|\]$/g, '');
          }
          return input.replace(/\\/g, '');
        }

        function makeFormatFunction(format) {
          var array = format.match(formattingTokens),
            i, length;
          for (i = 0, length = array.length; i < length; i++) {
            if (formatTokenFunctions[array[i]]) {
              array[i] = formatTokenFunctions[array[i]];
            } else {
              array[i] = removeFormattingTokens(array[i]);
            }
          }
          return function (mom) {
            var output = '',
              i;
            for (i = 0; i < length; i++) {
              output += isFunction(array[i]) ? array[i].call(mom, format) : array[i];
            }
            return output;
          };
        }

        function formatMoment(m, format) {
          if (!m.isValid()) {
            return m.localeData().invalidDate();
          }
          format = expandFormat(format, m.localeData());
          formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
          return formatFunctions[format](m);
        }

        function expandFormat(format, locale) {
          var i = 5;

          function replaceLongDateFormatTokens(input) {
            return locale.longDateFormat(input) || input;
          }
          localFormattingTokens.lastIndex = 0;
          while (i >= 0 && localFormattingTokens.test(format)) {
            format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
            localFormattingTokens.lastIndex = 0;
            i -= 1;
          }
          return format;
        }
        var match1 = /\d/;
        var match2 = /\d\d/;
        var match3 = /\d{3}/;
        var match4 = /\d{4}/;
        var match6 = /[+-]?\d{6}/;
        var match1to2 = /\d\d?/;
        var match3to4 = /\d\d\d\d?/;
        var match5to6 = /\d\d\d\d\d\d?/;
        var match1to3 = /\d{1,3}/;
        var match1to4 = /\d{1,4}/;
        var match1to6 = /[+-]?\d{1,6}/;
        var matchUnsigned = /\d+/;
        var matchSigned = /[+-]?\d+/;
        var matchOffset = /Z|[+-]\d\d:?\d\d/gi;
        var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi;
        var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/;
        var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
        var regexes = {};

        function addRegexToken(token, regex, strictRegex) {
          regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
            return (isStrict && strictRegex) ? strictRegex : regex;
          };
        }

        function getParseRegexForToken(token, config) {
          if (!hasOwnProp(regexes, token)) {
            return new RegExp(unescapeFormat(token));
          }
          return regexes[token](config._strict, config._locale);
        }

        function unescapeFormat(s) {
          return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
            return p1 || p2 || p3 || p4;
          }));
        }

        function regexEscape(s) {
          return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
        }
        var tokens = {};

        function addParseToken(token, callback) {
          var i, func = callback;
          if (typeof token === 'string') {
            token = [token];
          }
          if (isNumber(callback)) {
            func = function (input, array) {
              array[callback] = toInt(input);
            };
          }
          for (i = 0; i < token.length; i++) {
            tokens[token[i]] = func;
          }
        }

        function addWeekParseToken(token, callback) {
          addParseToken(token, function (input, array, config, token) {
            config._w = config._w || {};
            callback(input, config._w, config, token);
          });
        }

        function addTimeToArrayFromToken(token, input, config) {
          if (input != null && hasOwnProp(tokens, token)) {
            tokens[token](input, config._a, config, token);
          }
        }
        var YEAR = 0;
        var MONTH = 1;
        var DATE = 2;
        var HOUR = 3;
        var MINUTE = 4;
        var SECOND = 5;
        var MILLISECOND = 6;
        var WEEK = 7;
        var WEEKDAY = 8;
        var indexOf;
        if (Array.prototype.indexOf) {
          indexOf = Array.prototype.indexOf;
        } else {
          indexOf = function (o) {
            var i;
            for (i = 0; i < this.length; ++i) {
              if (this[i] === o) {
                return i;
              }
            }
            return -1;
          };
        }
        var indexOf$1 = indexOf;

        function daysInMonth(year, month) {
          return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
        }
        addFormatToken('M', ['MM', 2], 'Mo', function () {
          return this.month() + 1;
        });
        addFormatToken('MMM', 0, 0, function (format) {
          return this.localeData().monthsShort(this, format);
        });
        addFormatToken('MMMM', 0, 0, function (format) {
          return this.localeData().months(this, format);
        });
        addUnitAlias('month', 'M');
        addUnitPriority('month', 8);
        addRegexToken('M', match1to2);
        addRegexToken('MM', match1to2, match2);
        addRegexToken('MMM', function (isStrict, locale) {
          return locale.monthsShortRegex(isStrict);
        });
        addRegexToken('MMMM', function (isStrict, locale) {
          return locale.monthsRegex(isStrict);
        });
        addParseToken(['M', 'MM'], function (input, array) {
          array[MONTH] = toInt(input) - 1;
        });
        addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
          var month = config._locale.monthsParse(input, token, config._strict);
          if (month != null) {
            array[MONTH] = month;
          } else {
            getParsingFlags(config).invalidMonth = input;
          }
        });
        var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/;
        var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');

        function localeMonths(m, format) {
          if (!m) {
            return isArray(this._months) ? this._months : this._months['standalone'];
          }
          return isArray(this._months) ? this._months[m.month()] : this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];
        }
        var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');

        function localeMonthsShort(m, format) {
          if (!m) {
            return isArray(this._monthsShort) ? this._monthsShort : this._monthsShort['standalone'];
          }
          return isArray(this._monthsShort) ? this._monthsShort[m.month()] : this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
        }

        function handleStrictParse(monthName, format, strict) {
          var i, ii, mom, llc = monthName.toLocaleLowerCase();
          if (!this._monthsParse) {
            this._monthsParse = [];
            this._longMonthsParse = [];
            this._shortMonthsParse = [];
            for (i = 0; i < 12; ++i) {
              mom = createUTC([2000, i]);
              this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();
              this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
            }
          }
          if (strict) {
            if (format === 'MMM') {
              ii = indexOf$1.call(this._shortMonthsParse, llc);
              return ii !== -1 ? ii : null;
            } else {
              ii = indexOf$1.call(this._longMonthsParse, llc);
              return ii !== -1 ? ii : null;
            }
          } else {
            if (format === 'MMM') {
              ii = indexOf$1.call(this._shortMonthsParse, llc);
              if (ii !== -1) {
                return ii;
              }
              ii = indexOf$1.call(this._longMonthsParse, llc);
              return ii !== -1 ? ii : null;
            } else {
              ii = indexOf$1.call(this._longMonthsParse, llc);
              if (ii !== -1) {
                return ii;
              }
              ii = indexOf$1.call(this._shortMonthsParse, llc);
              return ii !== -1 ? ii : null;
            }
          }
        }

        function localeMonthsParse(monthName, format, strict) {
          var i, mom, regex;
          if (this._monthsParseExact) {
            return handleStrictParse.call(this, monthName, format, strict);
          }
          if (!this._monthsParse) {
            this._monthsParse = [];
            this._longMonthsParse = [];
            this._shortMonthsParse = [];
          }
          for (i = 0; i < 12; i++) {
            mom = createUTC([2000, i]);
            if (strict && !this._longMonthsParse[i]) {
              this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
              this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
            }
            if (!strict && !this._monthsParse[i]) {
              regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
              this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
            }
            if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
              return i;
            } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
              return i;
            } else if (!strict && this._monthsParse[i].test(monthName)) {
              return i;
            }
          }
        }

        function setMonth(mom, value) {
          var dayOfMonth;
          if (!mom.isValid()) {
            return mom;
          }
          if (typeof value === 'string') {
            if (/^\d+$/.test(value)) {
              value = toInt(value);
            } else {
              value = mom.localeData().monthsParse(value);
              if (!isNumber(value)) {
                return mom;
              }
            }
          }
          dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
          mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
          return mom;
        }

        function getSetMonth(value) {
          if (value != null) {
            setMonth(this, value);
            hooks.updateOffset(this, true);
            return this;
          } else {
            return get(this, 'Month');
          }
        }

        function getDaysInMonth() {
          return daysInMonth(this.year(), this.month());
        }
        var defaultMonthsShortRegex = matchWord;

        function monthsShortRegex(isStrict) {
          if (this._monthsParseExact) {
            if (!hasOwnProp(this, '_monthsRegex')) {
              computeMonthsParse.call(this);
            }
            if (isStrict) {
              return this._monthsShortStrictRegex;
            } else {
              return this._monthsShortRegex;
            }
          } else {
            if (!hasOwnProp(this, '_monthsShortRegex')) {
              this._monthsShortRegex = defaultMonthsShortRegex;
            }
            return this._monthsShortStrictRegex && isStrict ? this._monthsShortStrictRegex : this._monthsShortRegex;
          }
        }
        var defaultMonthsRegex = matchWord;

        function monthsRegex(isStrict) {
          if (this._monthsParseExact) {
            if (!hasOwnProp(this, '_monthsRegex')) {
              computeMonthsParse.call(this);
            }
            if (isStrict) {
              return this._monthsStrictRegex;
            } else {
              return this._monthsRegex;
            }
          } else {
            if (!hasOwnProp(this, '_monthsRegex')) {
              this._monthsRegex = defaultMonthsRegex;
            }
            return this._monthsStrictRegex && isStrict ? this._monthsStrictRegex : this._monthsRegex;
          }
        }

        function computeMonthsParse() {
          function cmpLenRev(a, b) {
            return b.length - a.length;
          }
          var shortPieces = [],
            longPieces = [],
            mixedPieces = [],
            i, mom;
          for (i = 0; i < 12; i++) {
            mom = createUTC([2000, i]);
            shortPieces.push(this.monthsShort(mom, ''));
            longPieces.push(this.months(mom, ''));
            mixedPieces.push(this.months(mom, ''));
            mixedPieces.push(this.monthsShort(mom, ''));
          }
          shortPieces.sort(cmpLenRev);
          longPieces.sort(cmpLenRev);
          mixedPieces.sort(cmpLenRev);
          for (i = 0; i < 12; i++) {
            shortPieces[i] = regexEscape(shortPieces[i]);
            longPieces[i] = regexEscape(longPieces[i]);
          }
          for (i = 0; i < 24; i++) {
            mixedPieces[i] = regexEscape(mixedPieces[i]);
          }
          this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
          this._monthsShortRegex = this._monthsRegex;
          this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
          this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
        }
        addFormatToken('Y', 0, 0, function () {
          var y = this.year();
          return y <= 9999 ? '' + y : '+' + y;
        });
        addFormatToken(0, ['YY', 2], 0, function () {
          return this.year() % 100;
        });
        addFormatToken(0, ['YYYY', 4], 0, 'year');
        addFormatToken(0, ['YYYYY', 5], 0, 'year');
        addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
        addUnitAlias('year', 'y');
        addUnitPriority('year', 1);
        addRegexToken('Y', matchSigned);
        addRegexToken('YY', match1to2, match2);
        addRegexToken('YYYY', match1to4, match4);
        addRegexToken('YYYYY', match1to6, match6);
        addRegexToken('YYYYYY', match1to6, match6);
        addParseToken(['YYYYY', 'YYYYYY'], YEAR);
        addParseToken('YYYY', function (input, array) {
          array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
        });
        addParseToken('YY', function (input, array) {
          array[YEAR] = hooks.parseTwoDigitYear(input);
        });
        addParseToken('Y', function (input, array) {
          array[YEAR] = parseInt(input, 10);
        });

        function daysInYear(year) {
          return isLeapYear(year) ? 366 : 365;
        }

        function isLeapYear(year) {
          return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
        }
        hooks.parseTwoDigitYear = function (input) {
          return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
        };
        var getSetYear = makeGetSet('FullYear', true);

        function getIsLeapYear() {
          return isLeapYear(this.year());
        }

        function createDate(y, m, d, h, M, s, ms) {
          var date = new Date(y, m, d, h, M, s, ms);
          if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {
            date.setFullYear(y);
          }
          return date;
        }

        function createUTCDate(y) {
          var date = new Date(Date.UTC.apply(null, arguments));
          if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {
            date.setUTCFullYear(y);
          }
          return date;
        }

        function firstWeekOffset(year, dow, doy) {
          var fwd = 7 + dow - doy,
            fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
          return -fwdlw + fwd - 1;
        }

        function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
          var localWeekday = (7 + weekday - dow) % 7,
            weekOffset = firstWeekOffset(year, dow, doy),
            dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
            resYear, resDayOfYear;
          if (dayOfYear <= 0) {
            resYear = year - 1;
            resDayOfYear = daysInYear(resYear) + dayOfYear;
          } else if (dayOfYear > daysInYear(year)) {
            resYear = year + 1;
            resDayOfYear = dayOfYear - daysInYear(year);
          } else {
            resYear = year;
            resDayOfYear = dayOfYear;
          }
          return {
            year: resYear,
            dayOfYear: resDayOfYear
          };
        }

        function weekOfYear(mom, dow, doy) {
          var weekOffset = firstWeekOffset(mom.year(), dow, doy),
            week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
            resWeek, resYear;
          if (week < 1) {
            resYear = mom.year() - 1;
            resWeek = week + weeksInYear(resYear, dow, doy);
          } else if (week > weeksInYear(mom.year(), dow, doy)) {
            resWeek = week - weeksInYear(mom.year(), dow, doy);
            resYear = mom.year() + 1;
          } else {
            resYear = mom.year();
            resWeek = week;
          }
          return {
            week: resWeek,
            year: resYear
          };
        }

        function weeksInYear(year, dow, doy) {
          var weekOffset = firstWeekOffset(year, dow, doy),
            weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
          return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
        }
        addFormatToken('w', ['ww', 2], 'wo', 'week');
        addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
        addUnitAlias('week', 'w');
        addUnitAlias('isoWeek', 'W');
        addUnitPriority('week', 5);
        addUnitPriority('isoWeek', 5);
        addRegexToken('w', match1to2);
        addRegexToken('ww', match1to2, match2);
        addRegexToken('W', match1to2);
        addRegexToken('WW', match1to2, match2);
        addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
          week[token.substr(0, 1)] = toInt(input);
        });

        function localeWeek(mom) {
          return weekOfYear(mom, this._week.dow, this._week.doy).week;
        }
        var defaultLocaleWeek = {
          dow: 0,
          doy: 6
        };

        function localeFirstDayOfWeek() {
          return this._week.dow;
        }

        function localeFirstDayOfYear() {
          return this._week.doy;
        }

        function getSetWeek(input) {
          var week = this.localeData().week(this);
          return input == null ? week : this.add((input - week) * 7, 'd');
        }

        function getSetISOWeek(input) {
          var week = weekOfYear(this, 1, 4).week;
          return input == null ? week : this.add((input - week) * 7, 'd');
        }
        addFormatToken('d', 0, 'do', 'day');
        addFormatToken('dd', 0, 0, function (format) {
          return this.localeData().weekdaysMin(this, format);
        });
        addFormatToken('ddd', 0, 0, function (format) {
          return this.localeData().weekdaysShort(this, format);
        });
        addFormatToken('dddd', 0, 0, function (format) {
          return this.localeData().weekdays(this, format);
        });
        addFormatToken('e', 0, 0, 'weekday');
        addFormatToken('E', 0, 0, 'isoWeekday');
        addUnitAlias('day', 'd');
        addUnitAlias('weekday', 'e');
        addUnitAlias('isoWeekday', 'E');
        addUnitPriority('day', 11);
        addUnitPriority('weekday', 11);
        addUnitPriority('isoWeekday', 11);
        addRegexToken('d', match1to2);
        addRegexToken('e', match1to2);
        addRegexToken('E', match1to2);
        addRegexToken('dd', function (isStrict, locale) {
          return locale.weekdaysMinRegex(isStrict);
        });
        addRegexToken('ddd', function (isStrict, locale) {
          return locale.weekdaysShortRegex(isStrict);
        });
        addRegexToken('dddd', function (isStrict, locale) {
          return locale.weekdaysRegex(isStrict);
        });
        addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
          var weekday = config._locale.weekdaysParse(input, token, config._strict);
          if (weekday != null) {
            week.d = weekday;
          } else {
            getParsingFlags(config).invalidWeekday = input;
          }
        });
        addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
          week[token] = toInt(input);
        });

        function parseWeekday(input, locale) {
          if (typeof input !== 'string') {
            return input;
          }
          if (!isNaN(input)) {
            return parseInt(input, 10);
          }
          input = locale.weekdaysParse(input);
          if (typeof input === 'number') {
            return input;
          }
          return null;
        }

        function parseIsoWeekday(input, locale) {
          if (typeof input === 'string') {
            return locale.weekdaysParse(input) % 7 || 7;
          }
          return isNaN(input) ? null : input;
        }
        var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');

        function localeWeekdays(m, format) {
          if (!m) {
            return isArray(this._weekdays) ? this._weekdays : this._weekdays['standalone'];
          }
          return isArray(this._weekdays) ? this._weekdays[m.day()] : this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()];
        }
        var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');

        function localeWeekdaysShort(m) {
          return (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;
        }
        var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');

        function localeWeekdaysMin(m) {
          return (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;
        }

        function handleStrictParse$1(weekdayName, format, strict) {
          var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
          if (!this._weekdaysParse) {
            this._weekdaysParse = [];
            this._shortWeekdaysParse = [];
            this._minWeekdaysParse = [];
            for (i = 0; i < 7; ++i) {
              mom = createUTC([2000, 1]).day(i);
              this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();
              this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();
              this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
            }
          }
          if (strict) {
            if (format === 'dddd') {
              ii = indexOf$1.call(this._weekdaysParse, llc);
              return ii !== -1 ? ii : null;
            } else if (format === 'ddd') {
              ii = indexOf$1.call(this._shortWeekdaysParse, llc);
              return ii !== -1 ? ii : null;
            } else {
              ii = indexOf$1.call(this._minWeekdaysParse, llc);
              return ii !== -1 ? ii : null;
            }
          } else {
            if (format === 'dddd') {
              ii = indexOf$1.call(this._weekdaysParse, llc);
              if (ii !== -1) {
                return ii;
              }
              ii = indexOf$1.call(this._shortWeekdaysParse, llc);
              if (ii !== -1) {
                return ii;
              }
              ii = indexOf$1.call(this._minWeekdaysParse, llc);
              return ii !== -1 ? ii : null;
            } else if (format === 'ddd') {
              ii = indexOf$1.call(this._shortWeekdaysParse, llc);
              if (ii !== -1) {
                return ii;
              }
              ii = indexOf$1.call(this._weekdaysParse, llc);
              if (ii !== -1) {
                return ii;
              }
              ii = indexOf$1.call(this._minWeekdaysParse, llc);
              return ii !== -1 ? ii : null;
            } else {
              ii = indexOf$1.call(this._minWeekdaysParse, llc);
              if (ii !== -1) {
                return ii;
              }
              ii = indexOf$1.call(this._weekdaysParse, llc);
              if (ii !== -1) {
                return ii;
              }
              ii = indexOf$1.call(this._shortWeekdaysParse, llc);
              return ii !== -1 ? ii : null;
            }
          }
        }

        function localeWeekdaysParse(weekdayName, format, strict) {
          var i, mom, regex;
          if (this._weekdaysParseExact) {
            return handleStrictParse$1.call(this, weekdayName, format, strict);
          }
          if (!this._weekdaysParse) {
            this._weekdaysParse = [];
            this._minWeekdaysParse = [];
            this._shortWeekdaysParse = [];
            this._fullWeekdaysParse = [];
          }
          for (i = 0; i < 7; i++) {
            mom = createUTC([2000, 1]).day(i);
            if (strict && !this._fullWeekdaysParse[i]) {
              this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\.?') + '$', 'i');
              this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\.?') + '$', 'i');
              this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\.?') + '$', 'i');
            }
            if (!this._weekdaysParse[i]) {
              regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
              this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
            }
            if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {
              return i;
            } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {
              return i;
            } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {
              return i;
            } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
              return i;
            }
          }
        }

        function getSetDayOfWeek(input) {
          if (!this.isValid()) {
            return input != null ? this : NaN;
          }
          var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
          if (input != null) {
            input = parseWeekday(input, this.localeData());
            return this.add(input - day, 'd');
          } else {
            return day;
          }
        }

        function getSetLocaleDayOfWeek(input) {
          if (!this.isValid()) {
            return input != null ? this : NaN;
          }
          var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
          return input == null ? weekday : this.add(input - weekday, 'd');
        }

        function getSetISODayOfWeek(input) {
          if (!this.isValid()) {
            return input != null ? this : NaN;
          }
          if (input != null) {
            var weekday = parseIsoWeekday(input, this.localeData());
            return this.day(this.day() % 7 ? weekday : weekday - 7);
          } else {
            return this.day() || 7;
          }
        }
        var defaultWeekdaysRegex = matchWord;

        function weekdaysRegex(isStrict) {
          if (this._weekdaysParseExact) {
            if (!hasOwnProp(this, '_weekdaysRegex')) {
              computeWeekdaysParse.call(this);
            }
            if (isStrict) {
              return this._weekdaysStrictRegex;
            } else {
              return this._weekdaysRegex;
            }
          } else {
            if (!hasOwnProp(this, '_weekdaysRegex')) {
              this._weekdaysRegex = defaultWeekdaysRegex;
            }
            return this._weekdaysStrictRegex && isStrict ? this._weekdaysStrictRegex : this._weekdaysRegex;
          }
        }
        var defaultWeekdaysShortRegex = matchWord;

        function weekdaysShortRegex(isStrict) {
          if (this._weekdaysParseExact) {
            if (!hasOwnProp(this, '_weekdaysRegex')) {
              computeWeekdaysParse.call(this);
            }
            if (isStrict) {
              return this._weekdaysShortStrictRegex;
            } else {
              return this._weekdaysShortRegex;
            }
          } else {
            if (!hasOwnProp(this, '_weekdaysShortRegex')) {
              this._weekdaysShortRegex = defaultWeekdaysShortRegex;
            }
            return this._weekdaysShortStrictRegex && isStrict ? this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
          }
        }
        var defaultWeekdaysMinRegex = matchWord;

        function weekdaysMinRegex(isStrict) {
          if (this._weekdaysParseExact) {
            if (!hasOwnProp(this, '_weekdaysRegex')) {
              computeWeekdaysParse.call(this);
            }
            if (isStrict) {
              return this._weekdaysMinStrictRegex;
            } else {
              return this._weekdaysMinRegex;
            }
          } else {
            if (!hasOwnProp(this, '_weekdaysMinRegex')) {
              this._weekdaysMinRegex = defaultWeekdaysMinRegex;
            }
            return this._weekdaysMinStrictRegex && isStrict ? this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
          }
        }

        function computeWeekdaysParse() {
          function cmpLenRev(a, b) {
            return b.length - a.length;
          }
          var minPieces = [],
            shortPieces = [],
            longPieces = [],
            mixedPieces = [],
            i, mom, minp, shortp, longp;
          for (i = 0; i < 7; i++) {
            mom = createUTC([2000, 1]).day(i);
            minp = this.weekdaysMin(mom, '');
            shortp = this.weekdaysShort(mom, '');
            longp = this.weekdays(mom, '');
            minPieces.push(minp);
            shortPieces.push(shortp);
            longPieces.push(longp);
            mixedPieces.push(minp);
            mixedPieces.push(shortp);
            mixedPieces.push(longp);
          }
          minPieces.sort(cmpLenRev);
          shortPieces.sort(cmpLenRev);
          longPieces.sort(cmpLenRev);
          mixedPieces.sort(cmpLenRev);
          for (i = 0; i < 7; i++) {
            shortPieces[i] = regexEscape(shortPieces[i]);
            longPieces[i] = regexEscape(longPieces[i]);
            mixedPieces[i] = regexEscape(mixedPieces[i]);
          }
          this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
          this._weekdaysShortRegex = this._weekdaysRegex;
          this._weekdaysMinRegex = this._weekdaysRegex;
          this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
          this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
          this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');
        }

        function hFormat() {
          return this.hours() % 12 || 12;
        }

        function kFormat() {
          return this.hours() || 24;
        }
        addFormatToken('H', ['HH', 2], 0, 'hour');
        addFormatToken('h', ['hh', 2], 0, hFormat);
        addFormatToken('k', ['kk', 2], 0, kFormat);
        addFormatToken('hmm', 0, 0, function () {
          return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
        });
        addFormatToken('hmmss', 0, 0, function () {
          return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) + zeroFill(this.seconds(), 2);
        });
        addFormatToken('Hmm', 0, 0, function () {
          return '' + this.hours() + zeroFill(this.minutes(), 2);
        });
        addFormatToken('Hmmss', 0, 0, function () {
          return '' + this.hours() + zeroFill(this.minutes(), 2) + zeroFill(this.seconds(), 2);
        });

        function meridiem(token, lowercase) {
          addFormatToken(token, 0, 0, function () {
            return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
          });
        }
        meridiem('a', true);
        meridiem('A', false);
        addUnitAlias('hour', 'h');
        addUnitPriority('hour', 13);

        function matchMeridiem(isStrict, locale) {
          return locale._meridiemParse;
        }
        addRegexToken('a', matchMeridiem);
        addRegexToken('A', matchMeridiem);
        addRegexToken('H', match1to2);
        addRegexToken('h', match1to2);
        addRegexToken('k', match1to2);
        addRegexToken('HH', match1to2, match2);
        addRegexToken('hh', match1to2, match2);
        addRegexToken('kk', match1to2, match2);
        addRegexToken('hmm', match3to4);
        addRegexToken('hmmss', match5to6);
        addRegexToken('Hmm', match3to4);
        addRegexToken('Hmmss', match5to6);
        addParseToken(['H', 'HH'], HOUR);
        addParseToken(['k', 'kk'], function (input, array, config) {
          var kInput = toInt(input);
          array[HOUR] = kInput === 24 ? 0 : kInput;
        });
        addParseToken(['a', 'A'], function (input, array, config) {
          config._isPm = config._locale.isPM(input);
          config._meridiem = input;
        });
        addParseToken(['h', 'hh'], function (input, array, config) {
          array[HOUR] = toInt(input);
          getParsingFlags(config).bigHour = true;
        });
        addParseToken('hmm', function (input, array, config) {
          var pos = input.length - 2;
          array[HOUR] = toInt(input.substr(0, pos));
          array[MINUTE] = toInt(input.substr(pos));
          getParsingFlags(config).bigHour = true;
        });
        addParseToken('hmmss', function (input, array, config) {
          var pos1 = input.length - 4;
          var pos2 = input.length - 2;
          array[HOUR] = toInt(input.substr(0, pos1));
          array[MINUTE] = toInt(input.substr(pos1, 2));
          array[SECOND] = toInt(input.substr(pos2));
          getParsingFlags(config).bigHour = true;
        });
        addParseToken('Hmm', function (input, array, config) {
          var pos = input.length - 2;
          array[HOUR] = toInt(input.substr(0, pos));
          array[MINUTE] = toInt(input.substr(pos));
        });
        addParseToken('Hmmss', function (input, array, config) {
          var pos1 = input.length - 4;
          var pos2 = input.length - 2;
          array[HOUR] = toInt(input.substr(0, pos1));
          array[MINUTE] = toInt(input.substr(pos1, 2));
          array[SECOND] = toInt(input.substr(pos2));
        });

        function localeIsPM(input) {
          return ((input + '').toLowerCase().charAt(0) === 'p');
        }
        var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;

        function localeMeridiem(hours, minutes, isLower) {
          if (hours > 11) {
            return isLower ? 'pm' : 'PM';
          } else {
            return isLower ? 'am' : 'AM';
          }
        }
        var getSetHour = makeGetSet('Hours', true);
        var baseConfig = {
          calendar: defaultCalendar,
          longDateFormat: defaultLongDateFormat,
          invalidDate: defaultInvalidDate,
          ordinal: defaultOrdinal,
          dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
          relativeTime: defaultRelativeTime,
          months: defaultLocaleMonths,
          monthsShort: defaultLocaleMonthsShort,
          week: defaultLocaleWeek,
          weekdays: defaultLocaleWeekdays,
          weekdaysMin: defaultLocaleWeekdaysMin,
          weekdaysShort: defaultLocaleWeekdaysShort,
          meridiemParse: defaultLocaleMeridiemParse
        };
        var locales = {};
        var localeFamilies = {};
        var globalLocale;

        function normalizeLocale(key) {
          return key ? key.toLowerCase().replace('_', '-') : key;
        }

        function chooseLocale(names) {
          var i = 0,
            j, next, locale, split;
          while (i < names.length) {
            split = normalizeLocale(names[i]).split('-');
            j = split.length;
            next = normalizeLocale(names[i + 1]);
            next = next ? next.split('-') : null;
            while (j > 0) {
              locale = loadLocale(split.slice(0, j).join('-'));
              if (locale) {
                return locale;
              }
              if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
                break;
              }
              j--;
            }
            i++;
          }
          return null;
        }

        function loadLocale(name) {
          var oldLocale = null;
          if (!locales[name] && (typeof module !== 'undefined') && module && module.exports) {
            try {
              oldLocale = globalLocale._abbr;
              __webpack_require__(409)("./" + name);
              getSetGlobalLocale(oldLocale);
            } catch (e) { }
          }
          return locales[name];
        }

        function getSetGlobalLocale(key, values) {
          var data;
          if (key) {
            if (isUndefined(values)) {
              data = getLocale(key);
            } else {
              data = defineLocale(key, values);
            }
            if (data) {
              globalLocale = data;
            }
          }
          return globalLocale._abbr;
        }

        function defineLocale(name, config) {
          if (config !== null) {
            var parentConfig = baseConfig;
            config.abbr = name;
            if (locales[name] != null) {
              deprecateSimple('defineLocaleOverride', 'use moment.updateLocale(localeName, config) to change ' + 'an existing locale. moment.defineLocale(localeName, ' + 'config) should only be used for creating a new locale ' + 'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');
              parentConfig = locales[name]._config;
            } else if (config.parentLocale != null) {
              if (locales[config.parentLocale] != null) {
                parentConfig = locales[config.parentLocale]._config;
              } else {
                if (!localeFamilies[config.parentLocale]) {
                  localeFamilies[config.parentLocale] = [];
                }
                localeFamilies[config.parentLocale].push({
                  name: name,
                  config: config
                });
                return null;
              }
            }
            locales[name] = new Locale(mergeConfigs(parentConfig, config));
            if (localeFamilies[name]) {
              localeFamilies[name].forEach(function (x) {
                defineLocale(x.name, x.config);
              });
            }
            getSetGlobalLocale(name);
            return locales[name];
          } else {
            delete locales[name];
            return null;
          }
        }

        function updateLocale(name, config) {
          if (config != null) {
            var locale, parentConfig = baseConfig;
            if (locales[name] != null) {
              parentConfig = locales[name]._config;
            }
            config = mergeConfigs(parentConfig, config);
            locale = new Locale(config);
            locale.parentLocale = locales[name];
            locales[name] = locale;
            getSetGlobalLocale(name);
          } else {
            if (locales[name] != null) {
              if (locales[name].parentLocale != null) {
                locales[name] = locales[name].parentLocale;
              } else if (locales[name] != null) {
                delete locales[name];
              }
            }
          }
          return locales[name];
        }

        function getLocale(key) {
          var locale;
          if (key && key._locale && key._locale._abbr) {
            key = key._locale._abbr;
          }
          if (!key) {
            return globalLocale;
          }
          if (!isArray(key)) {
            locale = loadLocale(key);
            if (locale) {
              return locale;
            }
            key = [key];
          }
          return chooseLocale(key);
        }

        function listLocales() {
          return keys$1(locales);
        }

        function checkOverflow(m) {
          var overflow;
          var a = m._a;
          if (a && getParsingFlags(m).overflow === -2) {
            overflow = a[MONTH] < 0 || a[MONTH] > 11 ? MONTH : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) ? DATE : a[HOUR] < 0 || a[HOUR] > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR : a[MINUTE] < 0 || a[MINUTE] > 59 ? MINUTE : a[SECOND] < 0 || a[SECOND] > 59 ? SECOND : a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND : -1;
            if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
              overflow = DATE;
            }
            if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
              overflow = WEEK;
            }
            if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
              overflow = WEEKDAY;
            }
            getParsingFlags(m).overflow = overflow;
          }
          return m;
        }
        var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
        var basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
        var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;
        var isoDates = [
          ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
          ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
          ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
          ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
          ['YYYY-DDD', /\d{4}-\d{3}/],
          ['YYYY-MM', /\d{4}-\d\d/, false],
          ['YYYYYYMMDD', /[+-]\d{10}/],
          ['YYYYMMDD', /\d{8}/],
          ['GGGG[W]WWE', /\d{4}W\d{3}/],
          ['GGGG[W]WW', /\d{4}W\d{2}/, false],
          ['YYYYDDD', /\d{7}/]
        ];
        var isoTimes = [
          ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
          ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
          ['HH:mm:ss', /\d\d:\d\d:\d\d/],
          ['HH:mm', /\d\d:\d\d/],
          ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
          ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
          ['HHmmss', /\d\d\d\d\d\d/],
          ['HHmm', /\d\d\d\d/],
          ['HH', /\d\d/]
        ];
        var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;

        function configFromISO(config) {
          var i, l, string = config._i,
            match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
            allowTime, dateFormat, timeFormat, tzFormat;
          if (match) {
            getParsingFlags(config).iso = true;
            for (i = 0, l = isoDates.length; i < l; i++) {
              if (isoDates[i][1].exec(match[1])) {
                dateFormat = isoDates[i][0];
                allowTime = isoDates[i][2] !== false;
                break;
              }
            }
            if (dateFormat == null) {
              config._isValid = false;
              return;
            }
            if (match[3]) {
              for (i = 0, l = isoTimes.length; i < l; i++) {
                if (isoTimes[i][1].exec(match[3])) {
                  timeFormat = (match[2] || ' ') + isoTimes[i][0];
                  break;
                }
              }
              if (timeFormat == null) {
                config._isValid = false;
                return;
              }
            }
            if (!allowTime && timeFormat != null) {
              config._isValid = false;
              return;
            }
            if (match[4]) {
              if (tzRegex.exec(match[4])) {
                tzFormat = 'Z';
              } else {
                config._isValid = false;
                return;
              }
            }
            config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
            configFromStringAndFormat(config);
          } else {
            config._isValid = false;
          }
        }
        var basicRfcRegex = /^((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d?\d\s(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(?:\d\d)?\d\d\s)(\d\d:\d\d)(\:\d\d)?(\s(?:UT|GMT|[ECMP][SD]T|[A-IK-Za-ik-z]|[+-]\d{4}))$/;

        function configFromRFC2822(config) {
          var string, match, dayFormat, dateFormat, timeFormat, tzFormat;
          var timezones = {
            ' GMT': ' +0000',
            ' EDT': ' -0400',
            ' EST': ' -0500',
            ' CDT': ' -0500',
            ' CST': ' -0600',
            ' MDT': ' -0600',
            ' MST': ' -0700',
            ' PDT': ' -0700',
            ' PST': ' -0800'
          };
          var military = 'YXWVUTSRQPONZABCDEFGHIKLM';
          var timezone, timezoneIndex;
          string = config._i.replace(/\([^\)]*\)|[\n\t]/g, ' ').replace(/(\s\s+)/g, ' ').replace(/^\s|\s$/g, '');
          match = basicRfcRegex.exec(string);
          if (match) {
            dayFormat = match[1] ? 'ddd' + ((match[1].length === 5) ? ', ' : ' ') : '';
            dateFormat = 'D MMM ' + ((match[2].length > 10) ? 'YYYY ' : 'YY ');
            timeFormat = 'HH:mm' + (match[4] ? ':ss' : '');
            if (match[1]) {
              var momentDate = new Date(match[2]);
              var momentDay = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'][momentDate.getDay()];
              if (match[1].substr(0, 3) !== momentDay) {
                getParsingFlags(config).weekdayMismatch = true;
                config._isValid = false;
                return;
              }
            }
            switch (match[5].length) {
              case 2:
                if (timezoneIndex === 0) {
                  timezone = ' +0000';
                } else {
                  timezoneIndex = military.indexOf(match[5][1].toUpperCase()) - 12;
                  timezone = ((timezoneIndex < 0) ? ' -' : ' +') + (('' + timezoneIndex).replace(/^-?/, '0')).match(/..$/)[0] + '00';
                }
                break;
              case 4:
                timezone = timezones[match[5]];
                break;
              default:
                timezone = timezones[' GMT'];
            }
            match[5] = timezone;
            config._i = match.splice(1).join('');
            tzFormat = ' ZZ';
            config._f = dayFormat + dateFormat + timeFormat + tzFormat;
            configFromStringAndFormat(config);
            getParsingFlags(config).rfc2822 = true;
          } else {
            config._isValid = false;
          }
        }

        function configFromString(config) {
          var matched = aspNetJsonRegex.exec(config._i);
          if (matched !== null) {
            config._d = new Date(+matched[1]);
            return;
          }
          configFromISO(config);
          if (config._isValid === false) {
            delete config._isValid;
          } else {
            return;
          }
          configFromRFC2822(config);
          if (config._isValid === false) {
            delete config._isValid;
          } else {
            return;
          }
          hooks.createFromInputFallback(config);
        }
        hooks.createFromInputFallback = deprecate('value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' + 'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' + 'discouraged and will be removed in an upcoming major release. Please refer to ' + 'http://momentjs.com/guides/#/warnings/js-date/ for more info.', function (config) {
          config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
        });

        function defaults(a, b, c) {
          if (a != null) {
            return a;
          }
          if (b != null) {
            return b;
          }
          return c;
        }

        function currentDateArray(config) {
          var nowValue = new Date(hooks.now());
          if (config._useUTC) {
            return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
          }
          return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
        }

        function configFromArray(config) {
          var i, date, input = [],
            currentDate, yearToUse;
          if (config._d) {
            return;
          }
          currentDate = currentDateArray(config);
          if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
            dayOfYearFromWeekInfo(config);
          }
          if (config._dayOfYear != null) {
            yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
            if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {
              getParsingFlags(config)._overflowDayOfYear = true;
            }
            date = createUTCDate(yearToUse, 0, config._dayOfYear);
            config._a[MONTH] = date.getUTCMonth();
            config._a[DATE] = date.getUTCDate();
          }
          for (i = 0; i < 3 && config._a[i] == null; ++i) {
            config._a[i] = input[i] = currentDate[i];
          }
          for (; i < 7; i++) {
            config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
          }
          if (config._a[HOUR] === 24 && config._a[MINUTE] === 0 && config._a[SECOND] === 0 && config._a[MILLISECOND] === 0) {
            config._nextDay = true;
            config._a[HOUR] = 0;
          }
          config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
          if (config._tzm != null) {
            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
          }
          if (config._nextDay) {
            config._a[HOUR] = 24;
          }
        }

        function dayOfYearFromWeekInfo(config) {
          var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;
          w = config._w;
          if (w.GG != null || w.W != null || w.E != null) {
            dow = 1;
            doy = 4;
            weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);
            week = defaults(w.W, 1);
            weekday = defaults(w.E, 1);
            if (weekday < 1 || weekday > 7) {
              weekdayOverflow = true;
            }
          } else {
            dow = config._locale._week.dow;
            doy = config._locale._week.doy;
            var curWeek = weekOfYear(createLocal(), dow, doy);
            weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
            week = defaults(w.w, curWeek.week);
            if (w.d != null) {
              weekday = w.d;
              if (weekday < 0 || weekday > 6) {
                weekdayOverflow = true;
              }
            } else if (w.e != null) {
              weekday = w.e + dow;
              if (w.e < 0 || w.e > 6) {
                weekdayOverflow = true;
              }
            } else {
              weekday = dow;
            }
          }
          if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
            getParsingFlags(config)._overflowWeeks = true;
          } else if (weekdayOverflow != null) {
            getParsingFlags(config)._overflowWeekday = true;
          } else {
            temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
            config._a[YEAR] = temp.year;
            config._dayOfYear = temp.dayOfYear;
          }
        }
        hooks.ISO_8601 = function () { };
        hooks.RFC_2822 = function () { };

        function configFromStringAndFormat(config) {
          if (config._f === hooks.ISO_8601) {
            configFromISO(config);
            return;
          }
          if (config._f === hooks.RFC_2822) {
            configFromRFC2822(config);
            return;
          }
          config._a = [];
          getParsingFlags(config).empty = true;
          var string = '' + config._i,
            i, parsedInput, tokens, token, skipped, stringLength = string.length,
            totalParsedInputLength = 0;
          tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
          for (i = 0; i < tokens.length; i++) {
            token = tokens[i];
            parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
            if (parsedInput) {
              skipped = string.substr(0, string.indexOf(parsedInput));
              if (skipped.length > 0) {
                getParsingFlags(config).unusedInput.push(skipped);
              }
              string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
              totalParsedInputLength += parsedInput.length;
            }
            if (formatTokenFunctions[token]) {
              if (parsedInput) {
                getParsingFlags(config).empty = false;
              } else {
                getParsingFlags(config).unusedTokens.push(token);
              }
              addTimeToArrayFromToken(token, parsedInput, config);
            } else if (config._strict && !parsedInput) {
              getParsingFlags(config).unusedTokens.push(token);
            }
          }
          getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
          if (string.length > 0) {
            getParsingFlags(config).unusedInput.push(string);
          }
          if (config._a[HOUR] <= 12 && getParsingFlags(config).bigHour === true && config._a[HOUR] > 0) {
            getParsingFlags(config).bigHour = undefined;
          }
          getParsingFlags(config).parsedDateParts = config._a.slice(0);
          getParsingFlags(config).meridiem = config._meridiem;
          config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
          configFromArray(config);
          checkOverflow(config);
        }

        function meridiemFixWrap(locale, hour, meridiem) {
          var isPm;
          if (meridiem == null) {
            return hour;
          }
          if (locale.meridiemHour != null) {
            return locale.meridiemHour(hour, meridiem);
          } else if (locale.isPM != null) {
            isPm = locale.isPM(meridiem);
            if (isPm && hour < 12) {
              hour += 12;
            }
            if (!isPm && hour === 12) {
              hour = 0;
            }
            return hour;
          } else {
            return hour;
          }
        }

        function configFromStringAndArray(config) {
          var tempConfig, bestMoment, scoreToBeat, i, currentScore;
          if (config._f.length === 0) {
            getParsingFlags(config).invalidFormat = true;
            config._d = new Date(NaN);
            return;
          }
          for (i = 0; i < config._f.length; i++) {
            currentScore = 0;
            tempConfig = copyConfig({}, config);
            if (config._useUTC != null) {
              tempConfig._useUTC = config._useUTC;
            }
            tempConfig._f = config._f[i];
            configFromStringAndFormat(tempConfig);
            if (!isValid(tempConfig)) {
              continue;
            }
            currentScore += getParsingFlags(tempConfig).charsLeftOver;
            currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
            getParsingFlags(tempConfig).score = currentScore;
            if (scoreToBeat == null || currentScore < scoreToBeat) {
              scoreToBeat = currentScore;
              bestMoment = tempConfig;
            }
          }
          extend(config, bestMoment || tempConfig);
        }

        function configFromObject(config) {
          if (config._d) {
            return;
          }
          var i = normalizeObjectUnits(config._i);
          config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {
            return obj && parseInt(obj, 10);
          });
          configFromArray(config);
        }

        function createFromConfig(config) {
          var res = new Moment(checkOverflow(prepareConfig(config)));
          if (res._nextDay) {
            res.add(1, 'd');
            res._nextDay = undefined;
          }
          return res;
        }

        function prepareConfig(config) {
          var input = config._i,
            format = config._f;
          config._locale = config._locale || getLocale(config._l);
          if (input === null || (format === undefined && input === '')) {
            return createInvalid({
              nullInput: true
            });
          }
          if (typeof input === 'string') {
            config._i = input = config._locale.preparse(input);
          }
          if (isMoment(input)) {
            return new Moment(checkOverflow(input));
          } else if (isDate(input)) {
            config._d = input;
          } else if (isArray(format)) {
            configFromStringAndArray(config);
          } else if (format) {
            configFromStringAndFormat(config);
          } else {
            configFromInput(config);
          }
          if (!isValid(config)) {
            config._d = null;
          }
          return config;
        }

        function configFromInput(config) {
          var input = config._i;
          if (isUndefined(input)) {
            config._d = new Date(hooks.now());
          } else if (isDate(input)) {
            config._d = new Date(input.valueOf());
          } else if (typeof input === 'string') {
            configFromString(config);
          } else if (isArray(input)) {
            config._a = map(input.slice(0), function (obj) {
              return parseInt(obj, 10);
            });
            configFromArray(config);
          } else if (isObject(input)) {
            configFromObject(config);
          } else if (isNumber(input)) {
            config._d = new Date(input);
          } else {
            hooks.createFromInputFallback(config);
          }
        }

        function createLocalOrUTC(input, format, locale, strict, isUTC) {
          var c = {};
          if (locale === true || locale === false) {
            strict = locale;
            locale = undefined;
          }
          if ((isObject(input) && isObjectEmpty(input)) || (isArray(input) && input.length === 0)) {
            input = undefined;
          }
          c._isAMomentObject = true;
          c._useUTC = c._isUTC = isUTC;
          c._l = locale;
          c._i = input;
          c._f = format;
          c._strict = strict;
          return createFromConfig(c);
        }

        function createLocal(input, format, locale, strict) {
          return createLocalOrUTC(input, format, locale, strict, false);
        }
        var prototypeMin = deprecate('moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/', function () {
          var other = createLocal.apply(null, arguments);
          if (this.isValid() && other.isValid()) {
            return other < this ? this : other;
          } else {
            return createInvalid();
          }
        });
        var prototypeMax = deprecate('moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/', function () {
          var other = createLocal.apply(null, arguments);
          if (this.isValid() && other.isValid()) {
            return other > this ? this : other;
          } else {
            return createInvalid();
          }
        });

        function pickBy(fn, moments) {
          var res, i;
          if (moments.length === 1 && isArray(moments[0])) {
            moments = moments[0];
          }
          if (!moments.length) {
            return createLocal();
          }
          res = moments[0];
          for (i = 1; i < moments.length; ++i) {
            if (!moments[i].isValid() || moments[i][fn](res)) {
              res = moments[i];
            }
          }
          return res;
        }

        function min() {
          var args = [].slice.call(arguments, 0);
          return pickBy('isBefore', args);
        }

        function max() {
          var args = [].slice.call(arguments, 0);
          return pickBy('isAfter', args);
        }
        var now = function () {
          return Date.now ? Date.now() : +(new Date());
        };
        var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];

        function isDurationValid(m) {
          for (var key in m) {
            if (!(ordering.indexOf(key) !== -1 && (m[key] == null || !isNaN(m[key])))) {
              return false;
            }
          }
          var unitHasDecimal = false;
          for (var i = 0; i < ordering.length; ++i) {
            if (m[ordering[i]]) {
              if (unitHasDecimal) {
                return false;
              }
              if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
                unitHasDecimal = true;
              }
            }
          }
          return true;
        }

        function isValid$1() {
          return this._isValid;
        }

        function createInvalid$1() {
          return createDuration(NaN);
        }

        function Duration(duration) {
          var normalizedInput = normalizeObjectUnits(duration),
            years = normalizedInput.year || 0,
            quarters = normalizedInput.quarter || 0,
            months = normalizedInput.month || 0,
            weeks = normalizedInput.week || 0,
            days = normalizedInput.day || 0,
            hours = normalizedInput.hour || 0,
            minutes = normalizedInput.minute || 0,
            seconds = normalizedInput.second || 0,
            milliseconds = normalizedInput.millisecond || 0;
          this._isValid = isDurationValid(normalizedInput);
          this._milliseconds = +milliseconds + seconds * 1e3 + minutes * 6e4 + hours * 1000 * 60 * 60;
          this._days = +days + weeks * 7;
          this._months = +months + quarters * 3 + years * 12;
          this._data = {};
          this._locale = getLocale();
          this._bubble();
        }

        function isDuration(obj) {
          return obj instanceof Duration;
        }

        function absRound(number) {
          if (number < 0) {
            return Math.round(-1 * number) * -1;
          } else {
            return Math.round(number);
          }
        }

        function offset(token, separator) {
          addFormatToken(token, 0, 0, function () {
            var offset = this.utcOffset();
            var sign = '+';
            if (offset < 0) {
              offset = -offset;
              sign = '-';
            }
            return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
          });
        }
        offset('Z', ':');
        offset('ZZ', '');
        addRegexToken('Z', matchShortOffset);
        addRegexToken('ZZ', matchShortOffset);
        addParseToken(['Z', 'ZZ'], function (input, array, config) {
          config._useUTC = true;
          config._tzm = offsetFromString(matchShortOffset, input);
        });
        var chunkOffset = /([\+\-]|\d\d)/gi;

        function offsetFromString(matcher, string) {
          var matches = (string || '').match(matcher);
          if (matches === null) {
            return null;
          }
          var chunk = matches[matches.length - 1] || [];
          var parts = (chunk + '').match(chunkOffset) || ['-', 0, 0];
          var minutes = +(parts[1] * 60) + toInt(parts[2]);
          return minutes === 0 ? 0 : parts[0] === '+' ? minutes : -minutes;
        }

        function cloneWithOffset(input, model) {
          var res, diff;
          if (model._isUTC) {
            res = model.clone();
            diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();
            res._d.setTime(res._d.valueOf() + diff);
            hooks.updateOffset(res, false);
            return res;
          } else {
            return createLocal(input).local();
          }
        }

        function getDateOffset(m) {
          return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
        }
        hooks.updateOffset = function () { };

        function getSetOffset(input, keepLocalTime, keepMinutes) {
          var offset = this._offset || 0,
            localAdjust;
          if (!this.isValid()) {
            return input != null ? this : NaN;
          }
          if (input != null) {
            if (typeof input === 'string') {
              input = offsetFromString(matchShortOffset, input);
              if (input === null) {
                return this;
              }
            } else if (Math.abs(input) < 16 && !keepMinutes) {
              input = input * 60;
            }
            if (!this._isUTC && keepLocalTime) {
              localAdjust = getDateOffset(this);
            }
            this._offset = input;
            this._isUTC = true;
            if (localAdjust != null) {
              this.add(localAdjust, 'm');
            }
            if (offset !== input) {
              if (!keepLocalTime || this._changeInProgress) {
                addSubtract(this, createDuration(input - offset, 'm'), 1, false);
              } else if (!this._changeInProgress) {
                this._changeInProgress = true;
                hooks.updateOffset(this, true);
                this._changeInProgress = null;
              }
            }
            return this;
          } else {
            return this._isUTC ? offset : getDateOffset(this);
          }
        }

        function getSetZone(input, keepLocalTime) {
          if (input != null) {
            if (typeof input !== 'string') {
              input = -input;
            }
            this.utcOffset(input, keepLocalTime);
            return this;
          } else {
            return -this.utcOffset();
          }
        }

        function setOffsetToUTC(keepLocalTime) {
          return this.utcOffset(0, keepLocalTime);
        }

        function setOffsetToLocal(keepLocalTime) {
          if (this._isUTC) {
            this.utcOffset(0, keepLocalTime);
            this._isUTC = false;
            if (keepLocalTime) {
              this.subtract(getDateOffset(this), 'm');
            }
          }
          return this;
        }

        function setOffsetToParsedOffset() {
          if (this._tzm != null) {
            this.utcOffset(this._tzm, false, true);
          } else if (typeof this._i === 'string') {
            var tZone = offsetFromString(matchOffset, this._i);
            if (tZone != null) {
              this.utcOffset(tZone);
            } else {
              this.utcOffset(0, true);
            }
          }
          return this;
        }

        function hasAlignedHourOffset(input) {
          if (!this.isValid()) {
            return false;
          }
          input = input ? createLocal(input).utcOffset() : 0;
          return (this.utcOffset() - input) % 60 === 0;
        }

        function isDaylightSavingTime() {
          return (this.utcOffset() > this.clone().month(0).utcOffset() || this.utcOffset() > this.clone().month(5).utcOffset());
        }

        function isDaylightSavingTimeShifted() {
          if (!isUndefined(this._isDSTShifted)) {
            return this._isDSTShifted;
          }
          var c = {};
          copyConfig(c, this);
          c = prepareConfig(c);
          if (c._a) {
            var other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
            this._isDSTShifted = this.isValid() && compareArrays(c._a, other.toArray()) > 0;
          } else {
            this._isDSTShifted = false;
          }
          return this._isDSTShifted;
        }

        function isLocal() {
          return this.isValid() ? !this._isUTC : false;
        }

        function isUtcOffset() {
          return this.isValid() ? this._isUTC : false;
        }

        function isUtc() {
          return this.isValid() ? this._isUTC && this._offset === 0 : false;
        }
        var aspNetRegex = /^(\-)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/;
        var isoRegex = /^(-)?P(?:(-?[0-9,.]*)Y)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)W)?(?:(-?[0-9,.]*)D)?(?:T(?:(-?[0-9,.]*)H)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)S)?)?$/;

        function createDuration(input, key) {
          var duration = input,
            match = null,
            sign, ret, diffRes;
          if (isDuration(input)) {
            duration = {
              ms: input._milliseconds,
              d: input._days,
              M: input._months
            };
          } else if (isNumber(input)) {
            duration = {};
            if (key) {
              duration[key] = input;
            } else {
              duration.milliseconds = input;
            }
          } else if (!!(match = aspNetRegex.exec(input))) {
            sign = (match[1] === '-') ? -1 : 1;
            duration = {
              y: 0,
              d: toInt(match[DATE]) * sign,
              h: toInt(match[HOUR]) * sign,
              m: toInt(match[MINUTE]) * sign,
              s: toInt(match[SECOND]) * sign,
              ms: toInt(absRound(match[MILLISECOND] * 1000)) * sign
            };
          } else if (!!(match = isoRegex.exec(input))) {
            sign = (match[1] === '-') ? -1 : 1;
            duration = {
              y: parseIso(match[2], sign),
              M: parseIso(match[3], sign),
              w: parseIso(match[4], sign),
              d: parseIso(match[5], sign),
              h: parseIso(match[6], sign),
              m: parseIso(match[7], sign),
              s: parseIso(match[8], sign)
            };
          } else if (duration == null) {
            duration = {};
          } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
            diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to));
            duration = {};
            duration.ms = diffRes.milliseconds;
            duration.M = diffRes.months;
          }
          ret = new Duration(duration);
          if (isDuration(input) && hasOwnProp(input, '_locale')) {
            ret._locale = input._locale;
          }
          return ret;
        }
        createDuration.fn = Duration.prototype;
        createDuration.invalid = createInvalid$1;

        function parseIso(inp, sign) {
          var res = inp && parseFloat(inp.replace(',', '.'));
          return (isNaN(res) ? 0 : res) * sign;
        }

        function positiveMomentsDifference(base, other) {
          var res = {
            milliseconds: 0,
            months: 0
          };
          res.months = other.month() - base.month() + (other.year() - base.year()) * 12;
          if (base.clone().add(res.months, 'M').isAfter(other)) {
            --res.months;
          }
          res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
          return res;
        }

        function momentsDifference(base, other) {
          var res;
          if (!(base.isValid() && other.isValid())) {
            return {
              milliseconds: 0,
              months: 0
            };
          }
          other = cloneWithOffset(other, base);
          if (base.isBefore(other)) {
            res = positiveMomentsDifference(base, other);
          } else {
            res = positiveMomentsDifference(other, base);
            res.milliseconds = -res.milliseconds;
            res.months = -res.months;
          }
          return res;
        }

        function createAdder(direction, name) {
          return function (val, period) {
            var dur, tmp;
            if (period !== null && !isNaN(+period)) {
              deprecateSimple(name, 'moment().' + name + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' + 'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');
              tmp = val;
              val = period;
              period = tmp;
            }
            val = typeof val === 'string' ? +val : val;
            dur = createDuration(val, period);
            addSubtract(this, dur, direction);
            return this;
          };
        }

        function addSubtract(mom, duration, isAdding, updateOffset) {
          var milliseconds = duration._milliseconds,
            days = absRound(duration._days),
            months = absRound(duration._months);
          if (!mom.isValid()) {
            return;
          }
          updateOffset = updateOffset == null ? true : updateOffset;
          if (milliseconds) {
            mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
          }
          if (days) {
            set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);
          }
          if (months) {
            setMonth(mom, get(mom, 'Month') + months * isAdding);
          }
          if (updateOffset) {
            hooks.updateOffset(mom, days || months);
          }
        }
        var add = createAdder(1, 'add');
        var subtract = createAdder(-1, 'subtract');

        function getCalendarFormat(myMoment, now) {
          var diff = myMoment.diff(now, 'days', true);
          return diff < -6 ? 'sameElse' : diff < -1 ? 'lastWeek' : diff < 0 ? 'lastDay' : diff < 1 ? 'sameDay' : diff < 2 ? 'nextDay' : diff < 7 ? 'nextWeek' : 'sameElse';
        }

        function calendar$1(time, formats) {
          var now = time || createLocal(),
            sod = cloneWithOffset(now, this).startOf('day'),
            format = hooks.calendarFormat(this, sod) || 'sameElse';
          var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);
          return this.format(output || this.localeData().calendar(format, this, createLocal(now)));
        }

        function clone() {
          return new Moment(this);
        }

        function isAfter(input, units) {
          var localInput = isMoment(input) ? input : createLocal(input);
          if (!(this.isValid() && localInput.isValid())) {
            return false;
          }
          units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
          if (units === 'millisecond') {
            return this.valueOf() > localInput.valueOf();
          } else {
            return localInput.valueOf() < this.clone().startOf(units).valueOf();
          }
        }

        function isBefore(input, units) {
          var localInput = isMoment(input) ? input : createLocal(input);
          if (!(this.isValid() && localInput.isValid())) {
            return false;
          }
          units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
          if (units === 'millisecond') {
            return this.valueOf() < localInput.valueOf();
          } else {
            return this.clone().endOf(units).valueOf() < localInput.valueOf();
          }
        }

        function isBetween(from, to, units, inclusivity) {
          inclusivity = inclusivity || '()';
          return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) && (inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units));
        }

        function isSame(input, units) {
          var localInput = isMoment(input) ? input : createLocal(input),
            inputMs;
          if (!(this.isValid() && localInput.isValid())) {
            return false;
          }
          units = normalizeUnits(units || 'millisecond');
          if (units === 'millisecond') {
            return this.valueOf() === localInput.valueOf();
          } else {
            inputMs = localInput.valueOf();
            return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
          }
        }

        function isSameOrAfter(input, units) {
          return this.isSame(input, units) || this.isAfter(input, units);
        }

        function isSameOrBefore(input, units) {
          return this.isSame(input, units) || this.isBefore(input, units);
        }

        function diff(input, units, asFloat) {
          var that, zoneDelta, delta, output;
          if (!this.isValid()) {
            return NaN;
          }
          that = cloneWithOffset(input, this);
          if (!that.isValid()) {
            return NaN;
          }
          zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
          units = normalizeUnits(units);
          if (units === 'year' || units === 'month' || units === 'quarter') {
            output = monthDiff(this, that);
            if (units === 'quarter') {
              output = output / 3;
            } else if (units === 'year') {
              output = output / 12;
            }
          } else {
            delta = this - that;
            output = units === 'second' ? delta / 1e3 : units === 'minute' ? delta / 6e4 : units === 'hour' ? delta / 36e5 : units === 'day' ? (delta - zoneDelta) / 864e5 : units === 'week' ? (delta - zoneDelta) / 6048e5 : delta;
          }
          return asFloat ? output : absFloor(output);
        }

        function monthDiff(a, b) {
          var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
            anchor = a.clone().add(wholeMonthDiff, 'months'),
            anchor2, adjust;
          if (b - anchor < 0) {
            anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
            adjust = (b - anchor) / (anchor - anchor2);
          } else {
            anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
            adjust = (b - anchor) / (anchor2 - anchor);
          }
          return -(wholeMonthDiff + adjust) || 0;
        }
        hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
        hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';

        function toString() {
          return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
        }

        function toISOString() {
          if (!this.isValid()) {
            return null;
          }
          var m = this.clone().utc();
          if (m.year() < 0 || m.year() > 9999) {
            return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
          }
          if (isFunction(Date.prototype.toISOString)) {
            return this.toDate().toISOString();
          }
          return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
        }

        function inspect() {
          if (!this.isValid()) {
            return 'moment.invalid(/* ' + this._i + ' */)';
          }
          var func = 'moment';
          var zone = '';
          if (!this.isLocal()) {
            func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';
            zone = 'Z';
          }
          var prefix = '[' + func + '("]';
          var year = (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY';
          var datetime = '-MM-DD[T]HH:mm:ss.SSS';
          var suffix = zone + '[")]';
          return this.format(prefix + year + datetime + suffix);
        }

        function format(inputString) {
          if (!inputString) {
            inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;
          }
          var output = formatMoment(this, inputString);
          return this.localeData().postformat(output);
        }

        function from(time, withoutSuffix) {
          if (this.isValid() && ((isMoment(time) && time.isValid()) || createLocal(time).isValid())) {
            return createDuration({
              to: this,
              from: time
            }).locale(this.locale()).humanize(!withoutSuffix);
          } else {
            return this.localeData().invalidDate();
          }
        }

        function fromNow(withoutSuffix) {
          return this.from(createLocal(), withoutSuffix);
        }

        function to(time, withoutSuffix) {
          if (this.isValid() && ((isMoment(time) && time.isValid()) || createLocal(time).isValid())) {
            return createDuration({
              from: this,
              to: time
            }).locale(this.locale()).humanize(!withoutSuffix);
          } else {
            return this.localeData().invalidDate();
          }
        }

        function toNow(withoutSuffix) {
          return this.to(createLocal(), withoutSuffix);
        }

        function locale(key) {
          var newLocaleData;
          if (key === undefined) {
            return this._locale._abbr;
          } else {
            newLocaleData = getLocale(key);
            if (newLocaleData != null) {
              this._locale = newLocaleData;
            }
            return this;
          }
        }
        var lang = deprecate('moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.', function (key) {
          if (key === undefined) {
            return this.localeData();
          } else {
            return this.locale(key);
          }
        });

        function localeData() {
          return this._locale;
        }

        function startOf(units) {
          units = normalizeUnits(units);
          switch (units) {
            case 'year':
              this.month(0);
            case 'quarter':
            case 'month':
              this.date(1);
            case 'week':
            case 'isoWeek':
            case 'day':
            case 'date':
              this.hours(0);
            case 'hour':
              this.minutes(0);
            case 'minute':
              this.seconds(0);
            case 'second':
              this.milliseconds(0);
          }
          if (units === 'week') {
            this.weekday(0);
          }
          if (units === 'isoWeek') {
            this.isoWeekday(1);
          }
          if (units === 'quarter') {
            this.month(Math.floor(this.month() / 3) * 3);
          }
          return this;
        }

        function endOf(units) {
          units = normalizeUnits(units);
          if (units === undefined || units === 'millisecond') {
            return this;
          }
          if (units === 'date') {
            units = 'day';
          }
          return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');
        }

        function valueOf() {
          return this._d.valueOf() - ((this._offset || 0) * 60000);
        }

        function unix() {
          return Math.floor(this.valueOf() / 1000);
        }

        function toDate() {
          return new Date(this.valueOf());
        }

        function toArray() {
          var m = this;
          return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
        }

        function toObject() {
          var m = this;
          return {
            years: m.year(),
            months: m.month(),
            date: m.date(),
            hours: m.hours(),
            minutes: m.minutes(),
            seconds: m.seconds(),
            milliseconds: m.milliseconds()
          };
        }

        function toJSON() {
          return this.isValid() ? this.toISOString() : null;
        }

        function isValid$2() {
          return isValid(this);
        }

        function parsingFlags() {
          return extend({}, getParsingFlags(this));
        }

        function invalidAt() {
          return getParsingFlags(this).overflow;
        }

        function creationData() {
          return {
            input: this._i,
            format: this._f,
            locale: this._locale,
            isUTC: this._isUTC,
            strict: this._strict
          };
        }
        addFormatToken(0, ['gg', 2], 0, function () {
          return this.weekYear() % 100;
        });
        addFormatToken(0, ['GG', 2], 0, function () {
          return this.isoWeekYear() % 100;
        });

        function addWeekYearFormatToken(token, getter) {
          addFormatToken(0, [token, token.length], 0, getter);
        }
        addWeekYearFormatToken('gggg', 'weekYear');
        addWeekYearFormatToken('ggggg', 'weekYear');
        addWeekYearFormatToken('GGGG', 'isoWeekYear');
        addWeekYearFormatToken('GGGGG', 'isoWeekYear');
        addUnitAlias('weekYear', 'gg');
        addUnitAlias('isoWeekYear', 'GG');
        addUnitPriority('weekYear', 1);
        addUnitPriority('isoWeekYear', 1);
        addRegexToken('G', matchSigned);
        addRegexToken('g', matchSigned);
        addRegexToken('GG', match1to2, match2);
        addRegexToken('gg', match1to2, match2);
        addRegexToken('GGGG', match1to4, match4);
        addRegexToken('gggg', match1to4, match4);
        addRegexToken('GGGGG', match1to6, match6);
        addRegexToken('ggggg', match1to6, match6);
        addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
          week[token.substr(0, 2)] = toInt(input);
        });
        addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
          week[token] = hooks.parseTwoDigitYear(input);
        });

        function getSetWeekYear(input) {
          return getSetWeekYearHelper.call(this, input, this.week(), this.weekday(), this.localeData()._week.dow, this.localeData()._week.doy);
        }

        function getSetISOWeekYear(input) {
          return getSetWeekYearHelper.call(this, input, this.isoWeek(), this.isoWeekday(), 1, 4);
        }

        function getISOWeeksInYear() {
          return weeksInYear(this.year(), 1, 4);
        }

        function getWeeksInYear() {
          var weekInfo = this.localeData()._week;
          return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
        }

        function getSetWeekYearHelper(input, week, weekday, dow, doy) {
          var weeksTarget;
          if (input == null) {
            return weekOfYear(this, dow, doy).year;
          } else {
            weeksTarget = weeksInYear(input, dow, doy);
            if (week > weeksTarget) {
              week = weeksTarget;
            }
            return setWeekAll.call(this, input, week, weekday, dow, doy);
          }
        }

        function setWeekAll(weekYear, week, weekday, dow, doy) {
          var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
            date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
          this.year(date.getUTCFullYear());
          this.month(date.getUTCMonth());
          this.date(date.getUTCDate());
          return this;
        }
        addFormatToken('Q', 0, 'Qo', 'quarter');
        addUnitAlias('quarter', 'Q');
        addUnitPriority('quarter', 7);
        addRegexToken('Q', match1);
        addParseToken('Q', function (input, array) {
          array[MONTH] = (toInt(input) - 1) * 3;
        });

        function getSetQuarter(input) {
          return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
        }
        addFormatToken('D', ['DD', 2], 'Do', 'date');
        addUnitAlias('date', 'D');
        addUnitPriority('date', 9);
        addRegexToken('D', match1to2);
        addRegexToken('DD', match1to2, match2);
        addRegexToken('Do', function (isStrict, locale) {
          return isStrict ? (locale._dayOfMonthOrdinalParse || locale._ordinalParse) : locale._dayOfMonthOrdinalParseLenient;
        });
        addParseToken(['D', 'DD'], DATE);
        addParseToken('Do', function (input, array) {
          array[DATE] = toInt(input.match(match1to2)[0], 10);
        });
        var getSetDayOfMonth = makeGetSet('Date', true);
        addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
        addUnitAlias('dayOfYear', 'DDD');
        addUnitPriority('dayOfYear', 4);
        addRegexToken('DDD', match1to3);
        addRegexToken('DDDD', match3);
        addParseToken(['DDD', 'DDDD'], function (input, array, config) {
          config._dayOfYear = toInt(input);
        });

        function getSetDayOfYear(input) {
          var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;
          return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');
        }
        addFormatToken('m', ['mm', 2], 0, 'minute');
        addUnitAlias('minute', 'm');
        addUnitPriority('minute', 14);
        addRegexToken('m', match1to2);
        addRegexToken('mm', match1to2, match2);
        addParseToken(['m', 'mm'], MINUTE);
        var getSetMinute = makeGetSet('Minutes', false);
        addFormatToken('s', ['ss', 2], 0, 'second');
        addUnitAlias('second', 's');
        addUnitPriority('second', 15);
        addRegexToken('s', match1to2);
        addRegexToken('ss', match1to2, match2);
        addParseToken(['s', 'ss'], SECOND);
        var getSetSecond = makeGetSet('Seconds', false);
        addFormatToken('S', 0, 0, function () {
          return ~~(this.millisecond() / 100);
        });
        addFormatToken(0, ['SS', 2], 0, function () {
          return ~~(this.millisecond() / 10);
        });
        addFormatToken(0, ['SSS', 3], 0, 'millisecond');
        addFormatToken(0, ['SSSS', 4], 0, function () {
          return this.millisecond() * 10;
        });
        addFormatToken(0, ['SSSSS', 5], 0, function () {
          return this.millisecond() * 100;
        });
        addFormatToken(0, ['SSSSSS', 6], 0, function () {
          return this.millisecond() * 1000;
        });
        addFormatToken(0, ['SSSSSSS', 7], 0, function () {
          return this.millisecond() * 10000;
        });
        addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
          return this.millisecond() * 100000;
        });
        addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
          return this.millisecond() * 1000000;
        });
        addUnitAlias('millisecond', 'ms');
        addUnitPriority('millisecond', 16);
        addRegexToken('S', match1to3, match1);
        addRegexToken('SS', match1to3, match2);
        addRegexToken('SSS', match1to3, match3);
        var token;
        for (token = 'SSSS'; token.length <= 9; token += 'S') {
          addRegexToken(token, matchUnsigned);
        }

        function parseMs(input, array) {
          array[MILLISECOND] = toInt(('0.' + input) * 1000);
        }
        for (token = 'S'; token.length <= 9; token += 'S') {
          addParseToken(token, parseMs);
        }
        var getSetMillisecond = makeGetSet('Milliseconds', false);
        addFormatToken('z', 0, 0, 'zoneAbbr');
        addFormatToken('zz', 0, 0, 'zoneName');

        function getZoneAbbr() {
          return this._isUTC ? 'UTC' : '';
        }

        function getZoneName() {
          return this._isUTC ? 'Coordinated Universal Time' : '';
        }
        var proto = Moment.prototype;
        proto.add = add;
        proto.calendar = calendar$1;
        proto.clone = clone;
        proto.diff = diff;
        proto.endOf = endOf;
        proto.format = format;
        proto.from = from;
        proto.fromNow = fromNow;
        proto.to = to;
        proto.toNow = toNow;
        proto.get = stringGet;
        proto.invalidAt = invalidAt;
        proto.isAfter = isAfter;
        proto.isBefore = isBefore;
        proto.isBetween = isBetween;
        proto.isSame = isSame;
        proto.isSameOrAfter = isSameOrAfter;
        proto.isSameOrBefore = isSameOrBefore;
        proto.isValid = isValid$2;
        proto.lang = lang;
        proto.locale = locale;
        proto.localeData = localeData;
        proto.max = prototypeMax;
        proto.min = prototypeMin;
        proto.parsingFlags = parsingFlags;
        proto.set = stringSet;
        proto.startOf = startOf;
        proto.subtract = subtract;
        proto.toArray = toArray;
        proto.toObject = toObject;
        proto.toDate = toDate;
        proto.toISOString = toISOString;
        proto.inspect = inspect;
        proto.toJSON = toJSON;
        proto.toString = toString;
        proto.unix = unix;
        proto.valueOf = valueOf;
        proto.creationData = creationData;
        proto.year = getSetYear;
        proto.isLeapYear = getIsLeapYear;
        proto.weekYear = getSetWeekYear;
        proto.isoWeekYear = getSetISOWeekYear;
        proto.quarter = proto.quarters = getSetQuarter;
        proto.month = getSetMonth;
        proto.daysInMonth = getDaysInMonth;
        proto.week = proto.weeks = getSetWeek;
        proto.isoWeek = proto.isoWeeks = getSetISOWeek;
        proto.weeksInYear = getWeeksInYear;
        proto.isoWeeksInYear = getISOWeeksInYear;
        proto.date = getSetDayOfMonth;
        proto.day = proto.days = getSetDayOfWeek;
        proto.weekday = getSetLocaleDayOfWeek;
        proto.isoWeekday = getSetISODayOfWeek;
        proto.dayOfYear = getSetDayOfYear;
        proto.hour = proto.hours = getSetHour;
        proto.minute = proto.minutes = getSetMinute;
        proto.second = proto.seconds = getSetSecond;
        proto.millisecond = proto.milliseconds = getSetMillisecond;
        proto.utcOffset = getSetOffset;
        proto.utc = setOffsetToUTC;
        proto.local = setOffsetToLocal;
        proto.parseZone = setOffsetToParsedOffset;
        proto.hasAlignedHourOffset = hasAlignedHourOffset;
        proto.isDST = isDaylightSavingTime;
        proto.isLocal = isLocal;
        proto.isUtcOffset = isUtcOffset;
        proto.isUtc = isUtc;
        proto.isUTC = isUtc;
        proto.zoneAbbr = getZoneAbbr;
        proto.zoneName = getZoneName;
        proto.dates = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
        proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
        proto.years = deprecate('years accessor is deprecated. Use year instead', getSetYear);
        proto.zone = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone);
        proto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted);

        function createUnix(input) {
          return createLocal(input * 1000);
        }

        function createInZone() {
          return createLocal.apply(null, arguments).parseZone();
        }

        function preParsePostFormat(string) {
          return string;
        }
        var proto$1 = Locale.prototype;
        proto$1.calendar = calendar;
        proto$1.longDateFormat = longDateFormat;
        proto$1.invalidDate = invalidDate;
        proto$1.ordinal = ordinal;
        proto$1.preparse = preParsePostFormat;
        proto$1.postformat = preParsePostFormat;
        proto$1.relativeTime = relativeTime;
        proto$1.pastFuture = pastFuture;
        proto$1.set = set;
        proto$1.months = localeMonths;
        proto$1.monthsShort = localeMonthsShort;
        proto$1.monthsParse = localeMonthsParse;
        proto$1.monthsRegex = monthsRegex;
        proto$1.monthsShortRegex = monthsShortRegex;
        proto$1.week = localeWeek;
        proto$1.firstDayOfYear = localeFirstDayOfYear;
        proto$1.firstDayOfWeek = localeFirstDayOfWeek;
        proto$1.weekdays = localeWeekdays;
        proto$1.weekdaysMin = localeWeekdaysMin;
        proto$1.weekdaysShort = localeWeekdaysShort;
        proto$1.weekdaysParse = localeWeekdaysParse;
        proto$1.weekdaysRegex = weekdaysRegex;
        proto$1.weekdaysShortRegex = weekdaysShortRegex;
        proto$1.weekdaysMinRegex = weekdaysMinRegex;
        proto$1.isPM = localeIsPM;
        proto$1.meridiem = localeMeridiem;

        function get$1(format, index, field, setter) {
          var locale = getLocale();
          var utc = createUTC().set(setter, index);
          return locale[field](utc, format);
        }

        function listMonthsImpl(format, index, field) {
          if (isNumber(format)) {
            index = format;
            format = undefined;
          }
          format = format || '';
          if (index != null) {
            return get$1(format, index, field, 'month');
          }
          var i;
          var out = [];
          for (i = 0; i < 12; i++) {
            out[i] = get$1(format, i, field, 'month');
          }
          return out;
        }

        function listWeekdaysImpl(localeSorted, format, index, field) {
          if (typeof localeSorted === 'boolean') {
            if (isNumber(format)) {
              index = format;
              format = undefined;
            }
            format = format || '';
          } else {
            format = localeSorted;
            index = format;
            localeSorted = false;
            if (isNumber(format)) {
              index = format;
              format = undefined;
            }
            format = format || '';
          }
          var locale = getLocale(),
            shift = localeSorted ? locale._week.dow : 0;
          if (index != null) {
            return get$1(format, (index + shift) % 7, field, 'day');
          }
          var i;
          var out = [];
          for (i = 0; i < 7; i++) {
            out[i] = get$1(format, (i + shift) % 7, field, 'day');
          }
          return out;
        }

        function listMonths(format, index) {
          return listMonthsImpl(format, index, 'months');
        }

        function listMonthsShort(format, index) {
          return listMonthsImpl(format, index, 'monthsShort');
        }

        function listWeekdays(localeSorted, format, index) {
          return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
        }

        function listWeekdaysShort(localeSorted, format, index) {
          return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
        }

        function listWeekdaysMin(localeSorted, format, index) {
          return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
        }
        getSetGlobalLocale('en', {
          dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
          ordinal: function (number) {
            var b = number % 10,
              output = (toInt(number % 100 / 10) === 1) ? 'th' : (b === 1) ? 'st' : (b === 2) ? 'nd' : (b === 3) ? 'rd' : 'th';
            return number + output;
          }
        });
        hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale);
        hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);
        var mathAbs = Math.abs;

        function abs() {
          var data = this._data;
          this._milliseconds = mathAbs(this._milliseconds);
          this._days = mathAbs(this._days);
          this._months = mathAbs(this._months);
          data.milliseconds = mathAbs(data.milliseconds);
          data.seconds = mathAbs(data.seconds);
          data.minutes = mathAbs(data.minutes);
          data.hours = mathAbs(data.hours);
          data.months = mathAbs(data.months);
          data.years = mathAbs(data.years);
          return this;
        }

        function addSubtract$1(duration, input, value, direction) {
          var other = createDuration(input, value);
          duration._milliseconds += direction * other._milliseconds;
          duration._days += direction * other._days;
          duration._months += direction * other._months;
          return duration._bubble();
        }

        function add$1(input, value) {
          return addSubtract$1(this, input, value, 1);
        }

        function subtract$1(input, value) {
          return addSubtract$1(this, input, value, -1);
        }

        function absCeil(number) {
          if (number < 0) {
            return Math.floor(number);
          } else {
            return Math.ceil(number);
          }
        }

        function bubble() {
          var milliseconds = this._milliseconds;
          var days = this._days;
          var months = this._months;
          var data = this._data;
          var seconds, minutes, hours, years, monthsFromDays;
          if (!((milliseconds >= 0 && days >= 0 && months >= 0) || (milliseconds <= 0 && days <= 0 && months <= 0))) {
            milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
            days = 0;
            months = 0;
          }
          data.milliseconds = milliseconds % 1000;
          seconds = absFloor(milliseconds / 1000);
          data.seconds = seconds % 60;
          minutes = absFloor(seconds / 60);
          data.minutes = minutes % 60;
          hours = absFloor(minutes / 60);
          data.hours = hours % 24;
          days += absFloor(hours / 24);
          monthsFromDays = absFloor(daysToMonths(days));
          months += monthsFromDays;
          days -= absCeil(monthsToDays(monthsFromDays));
          years = absFloor(months / 12);
          months %= 12;
          data.days = days;
          data.months = months;
          data.years = years;
          return this;
        }

        function daysToMonths(days) {
          return days * 4800 / 146097;
        }

        function monthsToDays(months) {
          return months * 146097 / 4800;
        }

        function as(units) {
          if (!this.isValid()) {
            return NaN;
          }
          var days;
          var months;
          var milliseconds = this._milliseconds;
          units = normalizeUnits(units);
          if (units === 'month' || units === 'year') {
            days = this._days + milliseconds / 864e5;
            months = this._months + daysToMonths(days);
            return units === 'month' ? months : months / 12;
          } else {
            days = this._days + Math.round(monthsToDays(this._months));
            switch (units) {
              case 'week':
                return days / 7 + milliseconds / 6048e5;
              case 'day':
                return days + milliseconds / 864e5;
              case 'hour':
                return days * 24 + milliseconds / 36e5;
              case 'minute':
                return days * 1440 + milliseconds / 6e4;
              case 'second':
                return days * 86400 + milliseconds / 1000;
              case 'millisecond':
                return Math.floor(days * 864e5) + milliseconds;
              default:
                throw new Error('Unknown unit ' + units);
            }
          }
        }

        function valueOf$1() {
          if (!this.isValid()) {
            return NaN;
          }
          return (this._milliseconds + this._days * 864e5 + (this._months % 12) * 2592e6 + toInt(this._months / 12) * 31536e6);
        }

        function makeAs(alias) {
          return function () {
            return this.as(alias);
          };
        }
        var asMilliseconds = makeAs('ms');
        var asSeconds = makeAs('s');
        var asMinutes = makeAs('m');
        var asHours = makeAs('h');
        var asDays = makeAs('d');
        var asWeeks = makeAs('w');
        var asMonths = makeAs('M');
        var asYears = makeAs('y');

        function get$2(units) {
          units = normalizeUnits(units);
          return this.isValid() ? this[units + 's']() : NaN;
        }

        function makeGetter(name) {
          return function () {
            return this.isValid() ? this._data[name] : NaN;
          };
        }
        var milliseconds = makeGetter('milliseconds');
        var seconds = makeGetter('seconds');
        var minutes = makeGetter('minutes');
        var hours = makeGetter('hours');
        var days = makeGetter('days');
        var months = makeGetter('months');
        var years = makeGetter('years');

        function weeks() {
          return absFloor(this.days() / 7);
        }
        var round = Math.round;
        var thresholds = {
          ss: 44,
          s: 45,
          m: 45,
          h: 22,
          d: 26,
          M: 11
        };

        function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
          return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
        }

        function relativeTime$1(posNegDuration, withoutSuffix, locale) {
          var duration = createDuration(posNegDuration).abs();
          var seconds = round(duration.as('s'));
          var minutes = round(duration.as('m'));
          var hours = round(duration.as('h'));
          var days = round(duration.as('d'));
          var months = round(duration.as('M'));
          var years = round(duration.as('y'));
          var a = seconds <= thresholds.ss && ['s', seconds] || seconds < thresholds.s && ['ss', seconds] || minutes <= 1 && ['m'] || minutes < thresholds.m && ['mm', minutes] || hours <= 1 && ['h'] || hours < thresholds.h && ['hh', hours] || days <= 1 && ['d'] || days < thresholds.d && ['dd', days] || months <= 1 && ['M'] || months < thresholds.M && ['MM', months] || years <= 1 && ['y'] || ['yy', years];
          a[2] = withoutSuffix;
          a[3] = +posNegDuration > 0;
          a[4] = locale;
          return substituteTimeAgo.apply(null, a);
        }

        function getSetRelativeTimeRounding(roundingFunction) {
          if (roundingFunction === undefined) {
            return round;
          }
          if (typeof (roundingFunction) === 'function') {
            round = roundingFunction;
            return true;
          }
          return false;
        }

        function getSetRelativeTimeThreshold(threshold, limit) {
          if (thresholds[threshold] === undefined) {
            return false;
          }
          if (limit === undefined) {
            return thresholds[threshold];
          }
          thresholds[threshold] = limit;
          if (threshold === 's') {
            thresholds.ss = limit - 1;
          }
          return true;
        }

        function humanize(withSuffix) {
          if (!this.isValid()) {
            return this.localeData().invalidDate();
          }
          var locale = this.localeData();
          var output = relativeTime$1(this, !withSuffix, locale);
          if (withSuffix) {
            output = locale.pastFuture(+this, output);
          }
          return locale.postformat(output);
        }
        var abs$1 = Math.abs;

        function toISOString$1() {
          if (!this.isValid()) {
            return this.localeData().invalidDate();
          }
          var seconds = abs$1(this._milliseconds) / 1000;
          var days = abs$1(this._days);
          var months = abs$1(this._months);
          var minutes, hours, years;
          minutes = absFloor(seconds / 60);
          hours = absFloor(minutes / 60);
          seconds %= 60;
          minutes %= 60;
          years = absFloor(months / 12);
          months %= 12;
          var Y = years;
          var M = months;
          var D = days;
          var h = hours;
          var m = minutes;
          var s = seconds;
          var total = this.asSeconds();
          if (!total) {
            return 'P0D';
          }
          return (total < 0 ? '-' : '') + 'P' + (Y ? Y + 'Y' : '') + (M ? M + 'M' : '') + (D ? D + 'D' : '') + ((h || m || s) ? 'T' : '') + (h ? h + 'H' : '') + (m ? m + 'M' : '') + (s ? s + 'S' : '');
        }
        var proto$2 = Duration.prototype;
        proto$2.isValid = isValid$1;
        proto$2.abs = abs;
        proto$2.add = add$1;
        proto$2.subtract = subtract$1;
        proto$2.as = as;
        proto$2.asMilliseconds = asMilliseconds;
        proto$2.asSeconds = asSeconds;
        proto$2.asMinutes = asMinutes;
        proto$2.asHours = asHours;
        proto$2.asDays = asDays;
        proto$2.asWeeks = asWeeks;
        proto$2.asMonths = asMonths;
        proto$2.asYears = asYears;
        proto$2.valueOf = valueOf$1;
        proto$2._bubble = bubble;
        proto$2.get = get$2;
        proto$2.milliseconds = milliseconds;
        proto$2.seconds = seconds;
        proto$2.minutes = minutes;
        proto$2.hours = hours;
        proto$2.days = days;
        proto$2.weeks = weeks;
        proto$2.months = months;
        proto$2.years = years;
        proto$2.humanize = humanize;
        proto$2.toISOString = toISOString$1;
        proto$2.toString = toISOString$1;
        proto$2.toJSON = toISOString$1;
        proto$2.locale = locale;
        proto$2.localeData = localeData;
        proto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1);
        proto$2.lang = lang;
        addFormatToken('X', 0, 0, 'unix');
        addFormatToken('x', 0, 0, 'valueOf');
        addRegexToken('x', matchSigned);
        addRegexToken('X', matchTimestamp);
        addParseToken('X', function (input, array, config) {
          config._d = new Date(parseFloat(input, 10) * 1000);
        });
        addParseToken('x', function (input, array, config) {
          config._d = new Date(toInt(input));
        });
        hooks.version = '2.18.1';
        setHookCallback(createLocal);
        hooks.fn = proto;
        hooks.min = min;
        hooks.max = max;
        hooks.now = now;
        hooks.utc = createUTC;
        hooks.unix = createUnix;
        hooks.months = listMonths;
        hooks.isDate = isDate;
        hooks.locale = getSetGlobalLocale;
        hooks.invalid = createInvalid;
        hooks.duration = createDuration;
        hooks.isMoment = isMoment;
        hooks.weekdays = listWeekdays;
        hooks.parseZone = createInZone;
        hooks.localeData = getLocale;
        hooks.isDuration = isDuration;
        hooks.monthsShort = listMonthsShort;
        hooks.weekdaysMin = listWeekdaysMin;
        hooks.defineLocale = defineLocale;
        hooks.updateLocale = updateLocale;
        hooks.locales = listLocales;
        hooks.weekdaysShort = listWeekdaysShort;
        hooks.normalizeUnits = normalizeUnits;
        hooks.relativeTimeRounding = getSetRelativeTimeRounding;
        hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
        hooks.calendarFormat = getCalendarFormat;
        hooks.prototype = proto;
        return hooks;
      })));
      window['moment'] = __webpack_require__(42);
    }.call(exports, __webpack_require__(304)(module)))
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var CellCoords = function () {
      function CellCoords(row, col) {
        _classCallCheck(this, CellCoords);
        if (typeof row !== 'undefined' && typeof col !== 'undefined') {
          this.row = row;
          this.col = col;
        } else {
          this.row = null;
          this.col = null;
        }
      }
      _createClass(CellCoords, [{
        key: 'isValid',
        value: function isValid(wotInstance) {
          if (this.row < 0 || this.col < 0) {
            return false;
          }
          if (this.row >= wotInstance.getSetting('totalRows') || this.col >= wotInstance.getSetting('totalColumns')) {
            return false;
          }
          return true;
        }
      }, {
        key: 'isEqual',
        value: function isEqual(cellCoords) {
          if (cellCoords === this) {
            return true;
          }
          return this.row === cellCoords.row && this.col === cellCoords.col;
        }
      }, {
        key: 'isSouthEastOf',
        value: function isSouthEastOf(testedCoords) {
          return this.row >= testedCoords.row && this.col >= testedCoords.col;
        }
      }, {
        key: 'isNorthWestOf',
        value: function isNorthWestOf(testedCoords) {
          return this.row <= testedCoords.row && this.col <= testedCoords.col;
        }
      }, {
        key: 'isSouthWestOf',
        value: function isSouthWestOf(testedCoords) {
          return this.row >= testedCoords.row && this.col <= testedCoords.col;
        }
      }, {
        key: 'isNorthEastOf',
        value: function isNorthEastOf(testedCoords) {
          return this.row <= testedCoords.row && this.col >= testedCoords.col;
        }
      }]);
      return CellCoords;
    }();
    exports.default = CellCoords;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _element = __webpack_require__(0);
    var _autoResize = __webpack_require__(306);
    var _autoResize2 = _interopRequireDefault(_autoResize);
    var _baseEditor = __webpack_require__(36);
    var _baseEditor2 = _interopRequireDefault(_baseEditor);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _unicode = __webpack_require__(15);
    var _event = __webpack_require__(7);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }
    var TextEditor = _baseEditor2.default.prototype.extend();
    TextEditor.prototype.init = function () {
      var that = this;
      this.createElements();
      this.eventManager = new _eventManager2.default(this);
      this.bindEvents();
      this.autoResize = (0, _autoResize2.default)();
      this.instance.addHook('afterDestroy', function () {
        that.destroy();
      });
    };
    TextEditor.prototype.getValue = function () {
      return this.TEXTAREA.value;
    };
    TextEditor.prototype.setValue = function (newValue) {
      this.TEXTAREA.value = newValue;
    };
    var onBeforeKeyDown = function onBeforeKeyDown(event) {
      var instance = this,
        that = instance.getActiveEditor(),
        ctrlDown;
      ctrlDown = (event.ctrlKey || event.metaKey) && !event.altKey;
      if (event.target !== that.TEXTAREA || (0, _event.isImmediatePropagationStopped)(event)) {
        return;
      }
      if (event.keyCode === 17 || event.keyCode === 224 || event.keyCode === 91 || event.keyCode === 93) {
        (0, _event.stopImmediatePropagation)(event);
        return;
      }
      switch (event.keyCode) {
        case _unicode.KEY_CODES.ARROW_RIGHT:
          if (that.isInFullEditMode()) {
            if (!that.isWaiting() && !that.allowKeyEventPropagation || !that.isWaiting() && that.allowKeyEventPropagation && !that.allowKeyEventPropagation(event.keyCode)) {
              (0, _event.stopImmediatePropagation)(event);
            }
          }
          break;
        case _unicode.KEY_CODES.ARROW_LEFT:
          if (that.isInFullEditMode()) {
            if (!that.isWaiting() && !that.allowKeyEventPropagation || !that.isWaiting() && that.allowKeyEventPropagation && !that.allowKeyEventPropagation(event.keyCode)) {
              (0, _event.stopImmediatePropagation)(event);
            }
          }
          break;
        case _unicode.KEY_CODES.ARROW_UP:
        case _unicode.KEY_CODES.ARROW_DOWN:
          if (that.isInFullEditMode()) {
            if (!that.isWaiting() && !that.allowKeyEventPropagation || !that.isWaiting() && that.allowKeyEventPropagation && !that.allowKeyEventPropagation(event.keyCode)) {
              (0, _event.stopImmediatePropagation)(event);
            }
          }
          break;
        case _unicode.KEY_CODES.ENTER:
          var selected = that.instance.getSelected();
          var isMultipleSelection = !(selected[0] === selected[2] && selected[1] === selected[3]);
          if (ctrlDown && !isMultipleSelection || event.altKey) {
            if (that.isOpened()) {
              var caretPosition = (0, _element.getCaretPosition)(that.TEXTAREA),
                value = that.getValue();
              var newValue = value.slice(0, caretPosition) + '\n' + value.slice(caretPosition);
              that.setValue(newValue);
              (0, _element.setCaretPosition)(that.TEXTAREA, caretPosition + 1);
            } else {
              that.beginEditing(that.originalValue + '\n');
            } (0, _event.stopImmediatePropagation)(event);
          }
          event.preventDefault();
          break;
        case _unicode.KEY_CODES.A:
        case _unicode.KEY_CODES.X:
        case _unicode.KEY_CODES.C:
        case _unicode.KEY_CODES.V:
          if (ctrlDown) {
            (0, _event.stopImmediatePropagation)(event);
          }
          break;
        case _unicode.KEY_CODES.BACKSPACE:
        case _unicode.KEY_CODES.DELETE:
        case _unicode.KEY_CODES.HOME:
        case _unicode.KEY_CODES.END:
          (0, _event.stopImmediatePropagation)(event);
          break;
        default:
          break;
      }
      if ([_unicode.KEY_CODES.ARROW_UP, _unicode.KEY_CODES.ARROW_RIGHT, _unicode.KEY_CODES.ARROW_DOWN, _unicode.KEY_CODES.ARROW_LEFT].indexOf(event.keyCode) === -1) {
        that.autoResize.resize(String.fromCharCode(event.keyCode));
      }
    };
    TextEditor.prototype.open = function () {
      this.refreshDimensions();
      this.instance.addHook('beforeKeyDown', onBeforeKeyDown);
    };
    TextEditor.prototype.close = function (tdOutside) {
      this.textareaParentStyle.display = 'none';
      this.autoResize.unObserve();
      if (document.activeElement === this.TEXTAREA) {
        this.instance.listen();
      }
      this.instance.removeHook('beforeKeyDown', onBeforeKeyDown);
    };
    TextEditor.prototype.focus = function () {
      this.TEXTAREA.focus();
      (0, _element.setCaretPosition)(this.TEXTAREA, this.TEXTAREA.value.length);
    };
    TextEditor.prototype.createElements = function () {
      this.TEXTAREA = document.createElement('TEXTAREA');
      (0, _element.addClass)(this.TEXTAREA, 'handsontableInput');
      this.textareaStyle = this.TEXTAREA.style;
      this.textareaStyle.width = 0;
      this.textareaStyle.height = 0;
      this.TEXTAREA_PARENT = document.createElement('DIV');
      (0, _element.addClass)(this.TEXTAREA_PARENT, 'handsontableInputHolder');
      this.textareaParentStyle = this.TEXTAREA_PARENT.style;
      this.textareaParentStyle.top = 0;
      this.textareaParentStyle.left = 0;
      this.textareaParentStyle.display = 'none';
      this.TEXTAREA_PARENT.appendChild(this.TEXTAREA);
      this.instance.rootElement.appendChild(this.TEXTAREA_PARENT);
      var that = this;
      this.instance._registerTimeout(setTimeout(function () {
        that.refreshDimensions();
      }, 0));
    };
    TextEditor.prototype.getEditedCell = function () {
      var editorSection = this.checkEditorSection(),
        editedCell;
      switch (editorSection) {
        case 'top':
          editedCell = this.instance.view.wt.wtOverlays.topOverlay.clone.wtTable.getCell({
            row: this.row,
            col: this.col
          });
          this.textareaParentStyle.zIndex = 101;
          break;
        case 'top-left-corner':
          editedCell = this.instance.view.wt.wtOverlays.topLeftCornerOverlay.clone.wtTable.getCell({
            row: this.row,
            col: this.col
          });
          this.textareaParentStyle.zIndex = 103;
          break;
        case 'bottom-left-corner':
          editedCell = this.instance.view.wt.wtOverlays.bottomLeftCornerOverlay.clone.wtTable.getCell({
            row: this.row,
            col: this.col
          });
          this.textareaParentStyle.zIndex = 103;
          break;
        case 'left':
          editedCell = this.instance.view.wt.wtOverlays.leftOverlay.clone.wtTable.getCell({
            row: this.row,
            col: this.col
          });
          this.textareaParentStyle.zIndex = 102;
          break;
        case 'bottom':
          editedCell = this.instance.view.wt.wtOverlays.bottomOverlay.clone.wtTable.getCell({
            row: this.row,
            col: this.col
          });
          this.textareaParentStyle.zIndex = 102;
          break;
        default:
          editedCell = this.instance.getCell(this.row, this.col);
          this.textareaParentStyle.zIndex = '';
          break;
      }
      return editedCell != -1 && editedCell != -2 ? editedCell : void 0;
    };
    TextEditor.prototype.refreshValue = function () {
      var sourceData = this.instance.getSourceDataAtCell(this.row, this.prop);
      this.originalValue = sourceData;
      this.setValue(sourceData);
      this.refreshDimensions();
    };
    TextEditor.prototype.refreshDimensions = function () {
      if (this.state !== _baseEditor.EditorState.EDITING) {
        return;
      }
      this.TD = this.getEditedCell();
      if (!this.TD) {
        this.close(true);
        return;
      }
      var currentOffset = (0, _element.offset)(this.TD),
        containerOffset = (0, _element.offset)(this.instance.rootElement),
        scrollableContainer = (0, _element.getScrollableElement)(this.TD),
        totalRowsCount = this.instance.countRows(),
        editTopModifier = currentOffset.top === containerOffset.top ? 0 : 1,
        editTop = currentOffset.top - containerOffset.top - editTopModifier - (scrollableContainer.scrollTop || 0),
        editLeft = currentOffset.left - containerOffset.left - 1 - (scrollableContainer.scrollLeft || 0),
        settings = this.instance.getSettings(),
        rowHeadersCount = this.instance.hasRowHeaders(),
        colHeadersCount = this.instance.hasColHeaders(),
        editorSection = this.checkEditorSection(),
        backgroundColor = this.TD.style.backgroundColor,
        cssTransformOffset;
      switch (editorSection) {
        case 'top':
          cssTransformOffset = (0, _element.getCssTransform)(this.instance.view.wt.wtOverlays.topOverlay.clone.wtTable.holder.parentNode);
          break;
        case 'left':
          cssTransformOffset = (0, _element.getCssTransform)(this.instance.view.wt.wtOverlays.leftOverlay.clone.wtTable.holder.parentNode);
          break;
        case 'top-left-corner':
          cssTransformOffset = (0, _element.getCssTransform)(this.instance.view.wt.wtOverlays.topLeftCornerOverlay.clone.wtTable.holder.parentNode);
          break;
        case 'bottom-left-corner':
          cssTransformOffset = (0, _element.getCssTransform)(this.instance.view.wt.wtOverlays.bottomLeftCornerOverlay.clone.wtTable.holder.parentNode);
          break;
        case 'bottom':
          cssTransformOffset = (0, _element.getCssTransform)(this.instance.view.wt.wtOverlays.bottomOverlay.clone.wtTable.holder.parentNode);
          break;
        default:
          break;
      }
      if (colHeadersCount && this.instance.getSelected()[0] === 0 || settings.fixedRowsBottom && this.instance.getSelected()[0] === totalRowsCount - settings.fixedRowsBottom) {
        editTop += 1;
      }
      if (this.instance.getSelected()[1] === 0) {
        editLeft += 1;
      }
      if (cssTransformOffset && cssTransformOffset != -1) {
        this.textareaParentStyle[cssTransformOffset[0]] = cssTransformOffset[1];
      } else {
        (0, _element.resetCssTransform)(this.TEXTAREA_PARENT);
      }
      this.textareaParentStyle.top = editTop + 'px';
      this.textareaParentStyle.left = editLeft + 'px';
      var firstRowOffset = this.instance.view.wt.wtViewport.rowsRenderCalculator.startPosition;
      var firstColumnOffset = this.instance.view.wt.wtViewport.columnsRenderCalculator.startPosition;
      var horizontalScrollPosition = this.instance.view.wt.wtOverlays.leftOverlay.getScrollPosition();
      var verticalScrollPosition = this.instance.view.wt.wtOverlays.topOverlay.getScrollPosition();
      var scrollbarWidth = (0, _element.getScrollbarWidth)();
      var cellTopOffset = this.TD.offsetTop + firstRowOffset - verticalScrollPosition;
      var cellLeftOffset = this.TD.offsetLeft + firstColumnOffset - horizontalScrollPosition;
      var width = (0, _element.innerWidth)(this.TD) - 8;
      var actualVerticalScrollbarWidth = (0, _element.hasVerticalScrollbar)(scrollableContainer) ? scrollbarWidth : 0;
      var actualHorizontalScrollbarWidth = (0, _element.hasHorizontalScrollbar)(scrollableContainer) ? scrollbarWidth : 0;
      var maxWidth = this.instance.view.maximumVisibleElementWidth(cellLeftOffset) - 9 - actualVerticalScrollbarWidth;
      var height = this.TD.scrollHeight + 1;
      var maxHeight = Math.max(this.instance.view.maximumVisibleElementHeight(cellTopOffset) - actualHorizontalScrollbarWidth, 23);
      var cellComputedStyle = (0, _element.getComputedStyle)(this.TD);
      this.TEXTAREA.style.fontSize = cellComputedStyle.fontSize;
      this.TEXTAREA.style.fontFamily = cellComputedStyle.fontFamily;
      this.TEXTAREA.style.backgroundColor = '';
      this.TEXTAREA.style.backgroundColor = backgroundColor ? backgroundColor : (0, _element.getComputedStyle)(this.TEXTAREA).backgroundColor;
      this.autoResize.init(this.TEXTAREA, {
        minHeight: Math.min(height, maxHeight),
        maxHeight: maxHeight,
        minWidth: Math.min(width, maxWidth),
        maxWidth: maxWidth
      }, true);
      this.textareaParentStyle.display = 'block';
    };
    TextEditor.prototype.bindEvents = function () {
      var editor = this;
      this.eventManager.addEventListener(this.TEXTAREA, 'cut', function (event) {
        (0, _event.stopPropagation)(event);
      });
      this.eventManager.addEventListener(this.TEXTAREA, 'paste', function (event) {
        (0, _event.stopPropagation)(event);
      });
      this.instance.addHook('afterScrollHorizontally', function () {
        editor.refreshDimensions();
      });
      this.instance.addHook('afterScrollVertically', function () {
        editor.refreshDimensions();
      });
      this.instance.addHook('afterColumnResize', function () {
        editor.refreshDimensions();
        editor.focus();
      });
      this.instance.addHook('afterRowResize', function () {
        editor.refreshDimensions();
        editor.focus();
      });
      this.instance.addHook('afterDestroy', function () {
        editor.eventManager.destroy();
      });
    };
    TextEditor.prototype.destroy = function () {
      this.eventManager.destroy();
    };
    exports.default = TextEditor;
  }), (function (module, exports) {
    var core = module.exports = {
      version: '2.5.1'
    };
    if (typeof __e == 'number') __e = core;
  }), (function (module, exports) {
    module.exports = {};
  }), (function (module, exports, __webpack_require__) {
    var META = __webpack_require__(51)('meta');
    var isObject = __webpack_require__(12);
    var has = __webpack_require__(26);
    var setDesc = __webpack_require__(18).f;
    var id = 0;
    var isExtensible = Object.isExtensible || function () {
      return true;
    };
    var FREEZE = !__webpack_require__(25)(function () {
      return isExtensible(Object.preventExtensions({}));
    });
    var setMeta = function (it) {
      setDesc(it, META, {
        value: {
          i: 'O' + ++id,
          w: {}
        }
      });
    };
    var fastKey = function (it, create) {
      if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
      if (!has(it, META)) {
        if (!isExtensible(it)) return 'F';
        if (!create) return 'E';
        setMeta(it);
      }
      return it[META].i;
    };
    var getWeak = function (it, create) {
      if (!has(it, META)) {
        if (!isExtensible(it)) return true;
        if (!create) return false;
        setMeta(it);
      }
      return it[META].w;
    };
    var onFreeze = function (it) {
      if (FREEZE && meta.NEED && isExtensible(it) && !has(it, META)) setMeta(it);
      return it;
    };
    var meta = module.exports = {
      KEY: META,
      NEED: false,
      fastKey: fastKey,
      getWeak: getWeak,
      onFreeze: onFreeze
    };
  }), (function (module, exports) {
    exports.f = {}.propertyIsEnumerable;
  }), (function (module, exports) {
    module.exports = function (bitmap, value) {
      return {
        enumerable: !(bitmap & 1),
        configurable: !(bitmap & 2),
        writable: !(bitmap & 4),
        value: value
      };
    };
  }), (function (module, exports, __webpack_require__) {
    var def = __webpack_require__(18).f;
    var has = __webpack_require__(26);
    var TAG = __webpack_require__(8)('toStringTag');
    module.exports = function (it, tag, stat) {
      if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, {
        configurable: true,
        value: tag
      });
    };
  }), (function (module, exports) {
    var id = 0;
    var px = Math.random();
    module.exports = function (key) {
      return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
    };
  }), (function (module, exports, __webpack_require__) {
    var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;
    (function () {
      'use strict';
      var numbro, VERSION = '1.11.0',
        binarySuffixes = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'],
        decimalSuffixes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],
        bytes = {
          general: {
            scale: 1024,
            suffixes: decimalSuffixes,
            marker: 'bd'
          },
          binary: {
            scale: 1024,
            suffixes: binarySuffixes,
            marker: 'b'
          },
          decimal: {
            scale: 1000,
            suffixes: decimalSuffixes,
            marker: 'd'
          }
        },
        byteFormatOrder = [bytes.general, bytes.binary, bytes.decimal],
        cultures = {},
        languages = cultures,
        currentCulture = 'en-US',
        zeroFormat = null,
        defaultFormat = '0,0',
        defaultCurrencyFormat = '0$',
        hasModule = (typeof module !== 'undefined' && module.exports),
        enUS = {
          delimiters: {
            thousands: ',',
            decimal: '.'
          },
          abbreviations: {
            thousand: 'k',
            million: 'm',
            billion: 'b',
            trillion: 't'
          },
          ordinal: function (number) {
            var b = number % 10;
            return (~~(number % 100 / 10) === 1) ? 'th' : (b === 1) ? 'st' : (b === 2) ? 'nd' : (b === 3) ? 'rd' : 'th';
          },
          currency: {
            symbol: '$',
            position: 'prefix'
          },
          defaults: {
            currencyFormat: ',0000 a'
          },
          formats: {
            fourDigits: '0000 a',
            fullWithTwoDecimals: '$ ,0.00',
            fullWithTwoDecimalsNoCurrency: ',0.00'
          }
        };

      function Numbro(number) {
        this._value = number;
      }

      function numberLength(number) {
        if (number === 0) {
          return 1;
        }
        return Math.floor(Math.log(Math.abs(number)) / Math.LN10) + 1;
      }

      function zeroes(count) {
        var i, ret = '';
        for (i = 0; i < count; i++) {
          ret += '0';
        }
        return ret;
      }

      function toFixedLargeSmall(value, precision) {
        var mantissa, beforeDec, afterDec, exponent, prefix, endStr, zerosStr, str;
        str = value.toString();
        mantissa = str.split('e')[0];
        exponent = str.split('e')[1];
        beforeDec = mantissa.split('.')[0];
        afterDec = mantissa.split('.')[1] || '';
        if (+exponent > 0) {
          str = beforeDec + afterDec + zeroes(exponent - afterDec.length);
        } else {
          if (+beforeDec < 0) {
            prefix = '-0';
          } else {
            prefix = '0';
          }
          if (precision > 0) {
            prefix += '.';
          }
          zerosStr = zeroes((-1 * exponent) - 1);
          endStr = (zerosStr + Math.abs(beforeDec) + afterDec).substr(0, precision);
          str = prefix + endStr;
        }
        if (+exponent > 0 && precision > 0) {
          str += '.' + zeroes(precision);
        }
        return str;
      }

      function toFixed(value, precision, roundingFunction, optionals) {
        var power = Math.pow(10, precision),
          optionalsRegExp, output;
        if (value.toString().indexOf('e') > -1) {
          output = toFixedLargeSmall(value, precision);
          if (output.charAt(0) === '-' && +output >= 0) {
            output = output.substr(1);
          }
        } else {
          output = (roundingFunction(value + 'e+' + precision) / power).toFixed(precision);
        }
        if (optionals) {
          optionalsRegExp = new RegExp('0{1,' + optionals + '}$');
          output = output.replace(optionalsRegExp, '');
        }
        return output;
      }

      function formatNumbro(n, format, roundingFunction) {
        var output, escapedFormat = format.replace(/\{[^\{\}]*\}/g, '');
        if (escapedFormat.indexOf('$') > -1) {
          output = formatCurrency(n, cultures[currentCulture].currency.symbol, format, roundingFunction);
        } else if (escapedFormat.indexOf('%') > -1) {
          output = formatPercentage(n, format, roundingFunction);
        } else if (escapedFormat.indexOf(':') > -1) {
          output = formatTime(n, format);
        } else {
          output = formatNumber(n._value, format, roundingFunction);
        }
        return output;
      }

      function unformatNumbro(n, string) {
        var stringOriginal = string,
          thousandRegExp, millionRegExp, billionRegExp, trillionRegExp, bytesMultiplier = false,
          power;
        if (string.indexOf(':') > -1) {
          n._value = unformatTime(string);
        } else {
          if (string === zeroFormat) {
            n._value = 0;
          } else {
            if (cultures[currentCulture].delimiters.decimal !== '.') {
              string = string.replace(/\./g, '').replace(cultures[currentCulture].delimiters.decimal, '.');
            }
            thousandRegExp = new RegExp('[^a-zA-Z]' + cultures[currentCulture].abbreviations.thousand + '(?:\\)|(\\' + cultures[currentCulture].currency.symbol + ')?(?:\\))?)?$');
            millionRegExp = new RegExp('[^a-zA-Z]' + cultures[currentCulture].abbreviations.million + '(?:\\)|(\\' + cultures[currentCulture].currency.symbol + ')?(?:\\))?)?$');
            billionRegExp = new RegExp('[^a-zA-Z]' + cultures[currentCulture].abbreviations.billion + '(?:\\)|(\\' + cultures[currentCulture].currency.symbol + ')?(?:\\))?)?$');
            trillionRegExp = new RegExp('[^a-zA-Z]' + cultures[currentCulture].abbreviations.trillion + '(?:\\)|(\\' + cultures[currentCulture].currency.symbol + ')?(?:\\))?)?$');
            for (power = 1; power < binarySuffixes.length && !bytesMultiplier; ++power) {
              if (string.indexOf(binarySuffixes[power]) > -1) {
                bytesMultiplier = Math.pow(1024, power);
              } else if (string.indexOf(decimalSuffixes[power]) > -1) {
                bytesMultiplier = Math.pow(1000, power);
              }
            }
            var str = string.replace(/[^0-9\.]+/g, '');
            if (str === '') {
              n._value = NaN;
            } else {
              n._value = ((bytesMultiplier) ? bytesMultiplier : 1) * ((stringOriginal.match(thousandRegExp)) ? Math.pow(10, 3) : 1) * ((stringOriginal.match(millionRegExp)) ? Math.pow(10, 6) : 1) * ((stringOriginal.match(billionRegExp)) ? Math.pow(10, 9) : 1) * ((stringOriginal.match(trillionRegExp)) ? Math.pow(10, 12) : 1) * ((string.indexOf('%') > -1) ? 0.01 : 1) * (((string.split('-').length + Math.min(string.split('(').length - 1, string.split(')').length - 1)) % 2) ? 1 : -1) * Number(str);
              n._value = (bytesMultiplier) ? Math.ceil(n._value) : n._value;
            }
          }
        }
        return n._value;
      }

      function formatCurrency(n, currencySymbol, originalFormat, roundingFunction) {
        var format = originalFormat,
          symbolIndex = format.indexOf('$'),
          openParenIndex = format.indexOf('('),
          plusSignIndex = format.indexOf('+'),
          minusSignIndex = format.indexOf('-'),
          space = '',
          decimalSeparator = '',
          spliceIndex, output;
        if (format.indexOf('$') === -1) {
          if (cultures[currentCulture].currency.position === 'infix') {
            decimalSeparator = currencySymbol;
            if (cultures[currentCulture].currency.spaceSeparated) {
              decimalSeparator = ' ' + decimalSeparator + ' ';
            }
          } else if (cultures[currentCulture].currency.spaceSeparated) {
            space = ' ';
          }
        } else {
          if (format.indexOf(' $') > -1) {
            space = ' ';
            format = format.replace(' $', '');
          } else if (format.indexOf('$ ') > -1) {
            space = ' ';
            format = format.replace('$ ', '');
          } else {
            format = format.replace('$', '');
          }
        }
        output = formatNumber(n._value, format, roundingFunction, decimalSeparator);
        if (originalFormat.indexOf('$') === -1) {
          switch (cultures[currentCulture].currency.position) {
            case 'postfix':
              if (output.indexOf(')') > -1) {
                output = output.split('');
                output.splice(-1, 0, space + currencySymbol);
                output = output.join('');
              } else {
                output = output + space + currencySymbol;
              }
              break;
            case 'infix':
              break;
            case 'prefix':
              if (output.indexOf('(') > -1 || output.indexOf('-') > -1) {
                output = output.split('');
                spliceIndex = Math.max(openParenIndex, minusSignIndex) + 1;
                output.splice(spliceIndex, 0, currencySymbol + space);
                output = output.join('');
              } else {
                output = currencySymbol + space + output;
              }
              break;
            default:
              throw Error('Currency position should be among ["prefix", "infix", "postfix"]');
          }
        } else {
          if (symbolIndex <= 1) {
            if (output.indexOf('(') > -1 || output.indexOf('+') > -1 || output.indexOf('-') > -1) {
              output = output.split('');
              spliceIndex = 1;
              if (symbolIndex < openParenIndex || symbolIndex < plusSignIndex || symbolIndex < minusSignIndex) {
                spliceIndex = 0;
              }
              output.splice(spliceIndex, 0, currencySymbol + space);
              output = output.join('');
            } else {
              output = currencySymbol + space + output;
            }
          } else {
            if (output.indexOf(')') > -1) {
              output = output.split('');
              output.splice(-1, 0, space + currencySymbol);
              output = output.join('');
            } else {
              output = output + space + currencySymbol;
            }
          }
        }
        return output;
      }

      function formatForeignCurrency(n, foreignCurrencySymbol, originalFormat, roundingFunction) {
        return formatCurrency(n, foreignCurrencySymbol, originalFormat, roundingFunction);
      }

      function formatPercentage(n, format, roundingFunction) {
        var space = '',
          output, value = n._value * 100;
        if (format.indexOf(' %') > -1) {
          space = ' ';
          format = format.replace(' %', '');
        } else {
          format = format.replace('%', '');
        }
        output = formatNumber(value, format, roundingFunction);
        if (output.indexOf(')') > -1) {
          output = output.split('');
          output.splice(-1, 0, space + '%');
          output = output.join('');
        } else {
          output = output + space + '%';
        }
        return output;
      }

      function formatTime(n) {
        var hours = Math.floor(n._value / 60 / 60),
          minutes = Math.floor((n._value - (hours * 60 * 60)) / 60),
          seconds = Math.round(n._value - (hours * 60 * 60) - (minutes * 60));
        return hours + ':' + ((minutes < 10) ? '0' + minutes : minutes) + ':' + ((seconds < 10) ? '0' + seconds : seconds);
      }

      function unformatTime(string) {
        var timeArray = string.split(':'),
          seconds = 0;
        if (timeArray.length === 3) {
          seconds = seconds + (Number(timeArray[0]) * 60 * 60);
          seconds = seconds + (Number(timeArray[1]) * 60);
          seconds = seconds + Number(timeArray[2]);
        } else if (timeArray.length === 2) {
          seconds = seconds + (Number(timeArray[0]) * 60);
          seconds = seconds + Number(timeArray[1]);
        }
        return Number(seconds);
      }

      function formatByteUnits(value, suffixes, scale) {
        var suffix = suffixes[0],
          power, min, max, abs = Math.abs(value);
        if (abs >= scale) {
          for (power = 1; power < suffixes.length; ++power) {
            min = Math.pow(scale, power);
            max = Math.pow(scale, power + 1);
            if (abs >= min && abs < max) {
              suffix = suffixes[power];
              value = value / min;
              break;
            }
          }
          if (suffix === suffixes[0]) {
            value = value / Math.pow(scale, suffixes.length - 1);
            suffix = suffixes[suffixes.length - 1];
          }
        }
        return {
          value: value,
          suffix: suffix
        };
      }

      function formatNumber(value, format, roundingFunction, sep) {
        var negP = false,
          signed = false,
          optDec = false,
          abbr = '',
          abbrK = false,
          abbrM = false,
          abbrB = false,
          abbrT = false,
          abbrForce = false,
          bytes = '',
          byteFormat, units, ord = '',
          abs = Math.abs(value),
          totalLength, length, minimumPrecision, pow, w, intPrecision, precision, prefix, postfix, thousands, d = '',
          forcedNeg = false,
          neg = false,
          indexOpenP, indexMinus, paren = '',
          minlen, i;
        if (value === 0 && zeroFormat !== null) {
          return zeroFormat;
        }
        if (!isFinite(value)) {
          return '' + value;
        }
        if (format.indexOf('{') === 0) {
          var end = format.indexOf('}');
          if (end === -1) {
            throw Error('Format should also contain a "}"');
          }
          prefix = format.slice(1, end);
          format = format.slice(end + 1);
        } else {
          prefix = '';
        }
        if (format.indexOf('}') === format.length - 1 && format.length) {
          var start = format.indexOf('{');
          if (start === -1) {
            throw Error('Format should also contain a "{"');
          }
          postfix = format.slice(start + 1, -1);
          format = format.slice(0, start + 1);
        } else {
          postfix = '';
        }
        var info;
        if (format.indexOf('.') === -1) {
          info = format.match(/([0-9]+).*/);
        } else {
          info = format.match(/([0-9]+)\..*/);
        }
        minlen = info === null ? -1 : info[1].length;
        if (format.indexOf('-') !== -1) {
          forcedNeg = true;
        }
        if (format.indexOf('(') > -1) {
          negP = true;
          format = format.slice(1, -1);
        } else if (format.indexOf('+') > -1) {
          signed = true;
          format = format.replace(/\+/g, '');
        }
        if (format.indexOf('a') > -1) {
          intPrecision = format.split('.')[0].match(/[0-9]+/g) || ['0'];
          intPrecision = parseInt(intPrecision[0], 10);
          abbrK = format.indexOf('aK') >= 0;
          abbrM = format.indexOf('aM') >= 0;
          abbrB = format.indexOf('aB') >= 0;
          abbrT = format.indexOf('aT') >= 0;
          abbrForce = abbrK || abbrM || abbrB || abbrT;
          if (format.indexOf(' a') > -1) {
            abbr = ' ';
            format = format.replace(' a', '');
          } else {
            format = format.replace('a', '');
          }
          totalLength = numberLength(value);
          minimumPrecision = totalLength % 3;
          minimumPrecision = minimumPrecision === 0 ? 3 : minimumPrecision;
          if (intPrecision && abs !== 0) {
            pow = 3 * ~~((Math.min(intPrecision, totalLength) - minimumPrecision) / 3);
            abs = abs / Math.pow(10, pow);
          }
          if (totalLength !== intPrecision) {
            if (abs >= Math.pow(10, 12) && !abbrForce || abbrT) {
              abbr = abbr + cultures[currentCulture].abbreviations.trillion;
              value = value / Math.pow(10, 12);
            } else if (abs < Math.pow(10, 12) && abs >= Math.pow(10, 9) && !abbrForce || abbrB) {
              abbr = abbr + cultures[currentCulture].abbreviations.billion;
              value = value / Math.pow(10, 9);
            } else if (abs < Math.pow(10, 9) && abs >= Math.pow(10, 6) && !abbrForce || abbrM) {
              abbr = abbr + cultures[currentCulture].abbreviations.million;
              value = value / Math.pow(10, 6);
            } else if (abs < Math.pow(10, 6) && abs >= Math.pow(10, 3) && !abbrForce || abbrK) {
              abbr = abbr + cultures[currentCulture].abbreviations.thousand;
              value = value / Math.pow(10, 3);
            }
          }
          length = numberLength(value);
          if (intPrecision && length < intPrecision && format.indexOf('.') === -1) {
            format += '[.]';
            format += zeroes(intPrecision - length);
          }
        }
        for (i = 0; i < byteFormatOrder.length; ++i) {
          byteFormat = byteFormatOrder[i];
          if (format.indexOf(byteFormat.marker) > -1) {
            if (format.indexOf(' ' + byteFormat.marker) > -1) {
              bytes = ' ';
            }
            format = format.replace(bytes + byteFormat.marker, '');
            units = formatByteUnits(value, byteFormat.suffixes, byteFormat.scale);
            value = units.value;
            bytes = bytes + units.suffix;
            break;
          }
        }
        if (format.indexOf('o') > -1) {
          if (format.indexOf(' o') > -1) {
            ord = ' ';
            format = format.replace(' o', '');
          } else {
            format = format.replace('o', '');
          }
          if (cultures[currentCulture].ordinal) {
            ord = ord + cultures[currentCulture].ordinal(value);
          }
        }
        if (format.indexOf('[.]') > -1) {
          optDec = true;
          format = format.replace('[.]', '.');
        }
        precision = format.split('.')[1];
        thousands = format.indexOf(',');
        if (precision) {
          var dSplit = [];
          if (precision.indexOf('*') !== -1) {
            d = value.toString();
            dSplit = d.split('.');
            if (dSplit.length > 1) {
              d = toFixed(value, dSplit[1].length, roundingFunction);
            }
          } else {
            if (precision.indexOf('[') > -1) {
              precision = precision.replace(']', '');
              precision = precision.split('[');
              d = toFixed(value, (precision[0].length + precision[1].length), roundingFunction, precision[1].length);
            } else {
              d = toFixed(value, precision.length, roundingFunction);
            }
          }
          dSplit = d.split('.');
          w = dSplit[0];
          if (dSplit.length > 1 && dSplit[1].length) {
            var p = sep ? abbr + sep : cultures[currentCulture].delimiters.decimal;
            d = p + dSplit[1];
          } else {
            d = '';
          }
          if (optDec && Number(d.slice(1)) === 0) {
            d = '';
          }
        } else {
          w = toFixed(value, 0, roundingFunction);
        }
        if (w.indexOf('-') > -1) {
          w = w.slice(1);
          neg = true;
        }
        if (w.length < minlen) {
          w = zeroes(minlen - w.length) + w;
        }
        if (thousands > -1) {
          w = w.toString().replace(/(\d)(?=(\d{3})+(?!\d))/g, '$1' + cultures[currentCulture].delimiters.thousands);
        }
        if (format.indexOf('.') === 0) {
          w = '';
        }
        indexOpenP = format.indexOf('(');
        indexMinus = format.indexOf('-');
        if (indexOpenP < indexMinus) {
          paren = ((negP && neg) ? '(' : '') + (((forcedNeg && neg) || (!negP && neg)) ? '-' : '');
        } else {
          paren = (((forcedNeg && neg) || (!negP && neg)) ? '-' : '') + ((negP && neg) ? '(' : '');
        }
        return prefix + paren + ((!neg && signed && value !== 0) ? '+' : '') + w + d + ((ord) ? ord : '') + ((abbr && !sep) ? abbr : '') + ((bytes) ? bytes : '') + ((negP && neg) ? ')' : '') + postfix;
      }
      numbro = function (input) {
        if (numbro.isNumbro(input)) {
          input = input.value();
        } else if (typeof input === 'string' || typeof input === 'number') {
          input = numbro.fn.unformat(input);
        } else {
          input = NaN;
        }
        return new Numbro(Number(input));
      };
      numbro.version = VERSION;
      numbro.isNumbro = function (obj) {
        return obj instanceof Numbro;
      };
      numbro.setLanguage = function (newLanguage, fallbackLanguage) {
        console.warn('`setLanguage` is deprecated since version 1.6.0. Use `setCulture` instead');
        var key = newLanguage,
          prefix = newLanguage.split('-')[0],
          matchingLanguage = null;
        if (!languages[key]) {
          Object.keys(languages).forEach(function (language) {
            if (!matchingLanguage && language.split('-')[0] === prefix) {
              matchingLanguage = language;
            }
          });
          key = matchingLanguage || fallbackLanguage || 'en-US';
        }
        chooseCulture(key);
      };
      numbro.setCulture = function (newCulture, fallbackCulture) {
        var key = newCulture,
          suffix = newCulture.split('-')[1],
          matchingCulture = null;
        if (!cultures[key]) {
          if (suffix) {
            Object.keys(cultures).forEach(function (language) {
              if (!matchingCulture && language.split('-')[1] === suffix) {
                matchingCulture = language;
              }
            });
          }
          key = matchingCulture || fallbackCulture || 'en-US';
        }
        chooseCulture(key);
      };
      numbro.language = function (key, values) {
        console.warn('`language` is deprecated since version 1.6.0. Use `culture` instead');
        if (!key) {
          return currentCulture;
        }
        if (key && !values) {
          if (!languages[key]) {
            throw new Error('Unknown language : ' + key);
          }
          chooseCulture(key);
        }
        if (values || !languages[key]) {
          setCulture(key, values);
        }
        return numbro;
      };
      numbro.culture = function (code, values) {
        if (!code) {
          return currentCulture;
        }
        if (code && !values) {
          if (!cultures[code]) {
            throw new Error('Unknown culture : ' + code);
          }
          chooseCulture(code);
        }
        if (values || !cultures[code]) {
          setCulture(code, values);
        }
        return numbro;
      };
      numbro.languageData = function (key) {
        console.warn('`languageData` is deprecated since version 1.6.0. Use `cultureData` instead');
        if (!key) {
          return languages[currentCulture];
        }
        if (!languages[key]) {
          throw new Error('Unknown language : ' + key);
        }
        return languages[key];
      };
      numbro.cultureData = function (code) {
        if (!code) {
          return cultures[currentCulture];
        }
        if (!cultures[code]) {
          throw new Error('Unknown culture : ' + code);
        }
        return cultures[code];
      };
      numbro.culture('en-US', enUS);
      numbro.languages = function () {
        console.warn('`languages` is deprecated since version 1.6.0. Use `cultures` instead');
        return languages;
      };
      numbro.cultures = function () {
        return cultures;
      };
      numbro.zeroFormat = function (format) {
        zeroFormat = typeof (format) === 'string' ? format : null;
      };
      numbro.defaultFormat = function (format) {
        defaultFormat = typeof (format) === 'string' ? format : '0.0';
      };
      numbro.defaultCurrencyFormat = function (format) {
        defaultCurrencyFormat = typeof (format) === 'string' ? format : '0$';
      };
      numbro.validate = function (val, culture) {
        var _decimalSep, _thousandSep, _currSymbol, _valArray, _abbrObj, _thousandRegEx, cultureData, temp;
        if (typeof val !== 'string') {
          val += '';
          if (console.warn) {
            console.warn('Numbro.js: Value is not string. It has been co-erced to: ', val);
          }
        }
        val = val.trim();
        val = val.replace(/^[+-]?/, '');
        if (!!val.match(/^\d+$/)) {
          return true;
        }
        if (val === '') {
          return false;
        }
        try {
          cultureData = numbro.cultureData(culture);
        } catch (e) {
          cultureData = numbro.cultureData(numbro.culture());
        }
        _currSymbol = cultureData.currency.symbol;
        _abbrObj = cultureData.abbreviations;
        _decimalSep = cultureData.delimiters.decimal;
        if (cultureData.delimiters.thousands === '.') {
          _thousandSep = '\\.';
        } else {
          _thousandSep = cultureData.delimiters.thousands;
        }
        temp = val.match(/^[^\d\.\,]+/);
        if (temp !== null) {
          val = val.substr(1);
          if (temp[0] !== _currSymbol) {
            return false;
          }
        }
        temp = val.match(/[^\d]+$/);
        if (temp !== null) {
          val = val.slice(0, -1);
          if (temp[0] !== _abbrObj.thousand && temp[0] !== _abbrObj.million && temp[0] !== _abbrObj.billion && temp[0] !== _abbrObj.trillion) {
            return false;
          }
        }
        _thousandRegEx = new RegExp(_thousandSep + '{2}');
        if (!val.match(/[^\d.,]/g)) {
          _valArray = val.split(_decimalSep);
          if (_valArray.length > 2) {
            return false;
          } else {
            if (_valArray.length < 2) {
              return (!!_valArray[0].match(/^\d+.*\d$/) && !_valArray[0].match(_thousandRegEx));
            } else {
              if (_valArray[0] === '') {
                return (!_valArray[0].match(_thousandRegEx) && !!_valArray[1].match(/^\d+$/));
              } else if (_valArray[0].length === 1) {
                return (!!_valArray[0].match(/^\d+$/) && !_valArray[0].match(_thousandRegEx) && !!_valArray[1].match(/^\d+$/));
              } else {
                return (!!_valArray[0].match(/^\d+.*\d$/) && !_valArray[0].match(_thousandRegEx) && !!_valArray[1].match(/^\d+$/));
              }
            }
          }
        }
        return false;
      };
      numbro.loadLanguagesInNode = function () {
        console.warn('`loadLanguagesInNode` is deprecated since version 1.6.0. Use `loadCulturesInNode` instead');
        numbro.loadCulturesInNode();
      };
      numbro.loadCulturesInNode = function () {
        var cultures = __webpack_require__(305);
        for (var langLocaleCode in cultures) {
          if (langLocaleCode) {
            numbro.culture(langLocaleCode, cultures[langLocaleCode]);
          }
        }
      };

      function setCulture(code, values) {
        cultures[code] = values;
      }

      function chooseCulture(code) {
        currentCulture = code;
        var defaults = cultures[code].defaults;
        if (defaults && defaults.format) {
          numbro.defaultFormat(defaults.format);
        }
        if (defaults && defaults.currencyFormat) {
          numbro.defaultCurrencyFormat(defaults.currencyFormat);
        }
      }

      function inNodejsRuntime() {
        return (typeof process !== 'undefined') && (process.browser === undefined) && process.title && (process.title.indexOf('node') !== -1 || process.title.indexOf('meteor-tool') > 0 || process.title === 'grunt' || process.title === 'gulp') && ("function" !== 'undefined');
      }
      if ('function' !== typeof Array.prototype.reduce) {
        Array.prototype.reduce = function (callback, optInitialValue) {
          if (null === this || 'undefined' === typeof this) {
            throw new TypeError('Array.prototype.reduce called on null or undefined');
          }
          if ('function' !== typeof callback) {
            throw new TypeError(callback + ' is not a function');
          }
          var index, value, length = this.length >>> 0,
            isValueSet = false;
          if (1 < arguments.length) {
            value = optInitialValue;
            isValueSet = true;
          }
          for (index = 0; length > index; ++index) {
            if (this.hasOwnProperty(index)) {
              if (isValueSet) {
                value = callback(value, this[index], index, this);
              } else {
                value = this[index];
                isValueSet = true;
              }
            }
          }
          if (!isValueSet) {
            throw new TypeError('Reduce of empty array with no initial value');
          }
          return value;
        };
      }

      function multiplier(x) {
        var parts = x.toString().split('.');
        if (parts.length < 2) {
          return 1;
        }
        return Math.pow(10, parts[1].length);
      }

      function correctionFactor() {
        var args = Array.prototype.slice.call(arguments);
        return args.reduce(function (prev, next) {
          var mp = multiplier(prev),
            mn = multiplier(next);
          return mp > mn ? mp : mn;
        }, -Infinity);
      }
      numbro.fn = Numbro.prototype = {
        clone: function () {
          return numbro(this);
        },
        format: function (inputString, roundingFunction) {
          return formatNumbro(this, inputString ? inputString : defaultFormat, (roundingFunction !== undefined) ? roundingFunction : Math.round);
        },
        formatCurrency: function (inputString, roundingFunction) {
          return formatCurrency(this, cultures[currentCulture].currency.symbol, inputString ? inputString : defaultCurrencyFormat, (roundingFunction !== undefined) ? roundingFunction : Math.round);
        },
        formatForeignCurrency: function (currencySymbol, inputString, roundingFunction) {
          return formatForeignCurrency(this, currencySymbol, inputString ? inputString : defaultCurrencyFormat, (roundingFunction !== undefined) ? roundingFunction : Math.round);
        },
        unformat: function (inputString) {
          if (typeof inputString === 'number') {
            return inputString;
          } else if (typeof inputString === 'string') {
            var result = unformatNumbro(this, inputString);
            return isNaN(result) ? undefined : result;
          } else {
            return undefined;
          }
        },
        binaryByteUnits: function () {
          return formatByteUnits(this._value, bytes.binary.suffixes, bytes.binary.scale).suffix;
        },
        byteUnits: function () {
          return formatByteUnits(this._value, bytes.general.suffixes, bytes.general.scale).suffix;
        },
        decimalByteUnits: function () {
          return formatByteUnits(this._value, bytes.decimal.suffixes, bytes.decimal.scale).suffix;
        },
        value: function () {
          return this._value;
        },
        valueOf: function () {
          return this._value;
        },
        set: function (value) {
          this._value = Number(value);
          return this;
        },
        add: function (value) {
          var corrFactor = correctionFactor.call(null, this._value, value);

          function cback(accum, curr) {
            return accum + corrFactor * curr;
          }
          this._value = [this._value, value].reduce(cback, 0) / corrFactor;
          return this;
        },
        subtract: function (value) {
          var corrFactor = correctionFactor.call(null, this._value, value);

          function cback(accum, curr) {
            return accum - corrFactor * curr;
          }
          this._value = [value].reduce(cback, this._value * corrFactor) / corrFactor;
          return this;
        },
        multiply: function (value) {
          function cback(accum, curr) {
            var corrFactor = correctionFactor(accum, curr),
              result = accum * corrFactor;
            result *= curr * corrFactor;
            result /= corrFactor * corrFactor;
            return result;
          }
          this._value = [this._value, value].reduce(cback, 1);
          return this;
        },
        divide: function (value) {
          function cback(accum, curr) {
            var corrFactor = correctionFactor(accum, curr);
            return (accum * corrFactor) / (curr * corrFactor);
          }
          this._value = [this._value, value].reduce(cback);
          return this;
        },
        difference: function (value) {
          return Math.abs(numbro(this._value).subtract(value).value());
        }
      };
      if (inNodejsRuntime()) {
        numbro.loadCulturesInNode();
      }
      if (hasModule) {
        module.exports = numbro;
      } else {
        if (typeof ender === 'undefined') {
          this.numbro = numbro;
        }
        if (true) {
          !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () {
            return numbro;
          }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
        }
      }
    }.call(typeof window === 'undefined' ? this : window));
    window['numbro'] = __webpack_require__(52);
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.default = staticRegister;

    function _toConsumableArray(arr) {
      if (Array.isArray(arr)) {
        for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
          arr2[i] = arr[i];
        }
        return arr2;
      } else {
        return Array.from(arr);
      }
    }
    var collection = exports.collection = new Map();

    function staticRegister() {
      var namespace = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'common';
      if (!collection.has(namespace)) {
        collection.set(namespace, new Map());
      }
      var subCollection = collection.get(namespace);

      function register(name, item) {
        subCollection.set(name, item);
      }

      function getItem(name) {
        return subCollection.get(name);
      }

      function hasItem(name) {
        return subCollection.has(name);
      }

      function getNames() {
        return [].concat(_toConsumableArray(subCollection.keys()));
      }

      function getValues() {
        return [].concat(_toConsumableArray(subCollection.values()));
      }
      return {
        register: register,
        getItem: getItem,
        hasItem: hasItem,
        getNames: getNames,
        getValues: getValues
      };
    }
  }), (function (module, exports) {
    module.exports = function (it) {
      if (typeof it != 'function') throw TypeError(it + ' is not a function!');
      return it;
    };
  }), (function (module, exports) {
    module.exports = function (it, Constructor, name, forbiddenField) {
      if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) {
        throw TypeError(name + ': incorrect invocation!');
      }
      return it;
    };
  }), (function (module, exports, __webpack_require__) {
    var ctx = __webpack_require__(30);
    var IObject = __webpack_require__(78);
    var toObject = __webpack_require__(40);
    var toLength = __webpack_require__(21);
    var asc = __webpack_require__(392);
    module.exports = function (TYPE, $create) {
      var IS_MAP = TYPE == 1;
      var IS_FILTER = TYPE == 2;
      var IS_SOME = TYPE == 3;
      var IS_EVERY = TYPE == 4;
      var IS_FIND_INDEX = TYPE == 6;
      var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
      var create = $create || asc;
      return function ($this, callbackfn, that) {
        var O = toObject($this);
        var self = IObject(O);
        var f = ctx(callbackfn, that, 3);
        var length = toLength(self.length);
        var index = 0;
        var result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;
        var val, res;
        for (; length > index; index++)
          if (NO_HOLES || index in self) {
            val = self[index];
            res = f(val, index, O);
            if (TYPE) {
              if (IS_MAP) result[index] = res;
              else if (res) switch (TYPE) {
                case 3:
                  return true;
                case 5:
                  return val;
                case 6:
                  return index;
                case 2:
                  result.push(val);
              } else if (IS_EVERY) return false;
            }
          }
        return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
      };
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var global = __webpack_require__(10);
    var $export = __webpack_require__(1);
    var redefine = __webpack_require__(32);
    var redefineAll = __webpack_require__(62);
    var meta = __webpack_require__(47);
    var forOf = __webpack_require__(59);
    var anInstance = __webpack_require__(55);
    var isObject = __webpack_require__(12);
    var fails = __webpack_require__(25);
    var $iterDetect = __webpack_require__(79);
    var setToStringTag = __webpack_require__(50);
    var inheritIfRequired = __webpack_require__(395);
    module.exports = function (NAME, wrapper, methods, common, IS_MAP, IS_WEAK) {
      var Base = global[NAME];
      var C = Base;
      var ADDER = IS_MAP ? 'set' : 'add';
      var proto = C && C.prototype;
      var O = {};
      var fixMethod = function (KEY) {
        var fn = proto[KEY];
        redefine(proto, KEY, KEY == 'delete' ? function (a) {
          return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
        } : KEY == 'has' ? function has(a) {
          return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
        } : KEY == 'get' ? function get(a) {
          return IS_WEAK && !isObject(a) ? undefined : fn.call(this, a === 0 ? 0 : a);
        } : KEY == 'add' ? function add(a) {
          fn.call(this, a === 0 ? 0 : a);
          return this;
        } : function set(a, b) {
          fn.call(this, a === 0 ? 0 : a, b);
          return this;
        });
      };
      if (typeof C != 'function' || !(IS_WEAK || proto.forEach && !fails(function () {
        new C().entries().next();
      }))) {
        C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
        redefineAll(C.prototype, methods);
        meta.NEED = true;
      } else {
        var instance = new C();
        var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;
        var THROWS_ON_PRIMITIVES = fails(function () {
          instance.has(1);
        });
        var ACCEPT_ITERABLES = $iterDetect(function (iter) {
          new C(iter);
        });
        var BUGGY_ZERO = !IS_WEAK && fails(function () {
          var $instance = new C();
          var index = 5;
          while (index--) $instance[ADDER](index, index);
          return !$instance.has(-0);
        });
        if (!ACCEPT_ITERABLES) {
          C = wrapper(function (target, iterable) {
            anInstance(target, C, NAME);
            var that = inheritIfRequired(new Base(), target, C);
            if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);
            return that;
          });
          C.prototype = proto;
          proto.constructor = C;
        }
        if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {
          fixMethod('delete');
          fixMethod('has');
          IS_MAP && fixMethod('get');
        }
        if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);
        if (IS_WEAK && proto.clear) delete proto.clear;
      }
      setToStringTag(C, NAME);
      O[NAME] = C;
      $export($export.G + $export.W + $export.F * (C != Base), O);
      if (!IS_WEAK) common.setStrong(C, NAME, IS_MAP);
      return C;
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var hide = __webpack_require__(31);
    var redefine = __webpack_require__(32);
    var fails = __webpack_require__(25);
    var defined = __webpack_require__(33);
    var wks = __webpack_require__(8);
    module.exports = function (KEY, length, exec) {
      var SYMBOL = wks(KEY);
      var fns = exec(defined, SYMBOL, ''[KEY]);
      var strfn = fns[0];
      var rxfn = fns[1];
      if (fails(function () {
        var O = {};
        O[SYMBOL] = function () {
          return 7;
        };
        return ''[KEY](O) != 7;
      })) {
        redefine(String.prototype, KEY, strfn);
        hide(RegExp.prototype, SYMBOL, length == 2 ? function (string, arg) {
          return rxfn.call(string, this, arg);
        } : function (string) {
          return rxfn.call(string, this);
        });
      }
    };
  }), (function (module, exports, __webpack_require__) {
    var ctx = __webpack_require__(30);
    var call = __webpack_require__(280);
    var isArrayIter = __webpack_require__(276);
    var anObject = __webpack_require__(17);
    var toLength = __webpack_require__(21);
    var getIterFn = __webpack_require__(292);
    var BREAK = {};
    var RETURN = {};
    var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {
      var iterFn = ITERATOR ? function () {
        return iterable;
      } : getIterFn(iterable);
      var f = ctx(fn, that, entries ? 2 : 1);
      var index = 0;
      var length, step, iterator, result;
      if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');
      if (isArrayIter(iterFn))
        for (length = toLength(iterable.length); length > index; index++) {
          result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
          if (result === BREAK || result === RETURN) return result;
        } else
        for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) {
          result = call(iterator, f, step.value, entries);
          if (result === BREAK || result === RETURN) return result;
        }
    };
    exports.BREAK = BREAK;
    exports.RETURN = RETURN;
  }), (function (module, exports) {
    module.exports = false;
  }), (function (module, exports) {
    exports.f = Object.getOwnPropertySymbols;
  }), (function (module, exports, __webpack_require__) {
    var redefine = __webpack_require__(32);
    module.exports = function (target, src, safe) {
      for (var key in src) redefine(target, key, src[key], safe);
      return target;
    };
  }), (function (module, exports, __webpack_require__) {
    var toInteger = __webpack_require__(64);
    var max = Math.max;
    var min = Math.min;
    module.exports = function (index, length) {
      index = toInteger(index);
      return index < 0 ? max(index + length, 0) : min(index, length);
    };
  }), (function (module, exports) {
    var ceil = Math.ceil;
    var floor = Math.floor;
    module.exports = function (it) {
      return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.getRegisteredCellTypes = exports.getRegisteredCellTypeNames = exports.hasCellType = exports.getCellType = exports.registerCellType = undefined;
    var _staticRegister2 = __webpack_require__(53);
    var _staticRegister3 = _interopRequireDefault(_staticRegister2);
    var _editors = __webpack_require__(13);
    var _renderers = __webpack_require__(6);
    var _validators = __webpack_require__(24);
    var _autocompleteType = __webpack_require__(312);
    var _autocompleteType2 = _interopRequireDefault(_autocompleteType);
    var _checkboxType = __webpack_require__(313);
    var _checkboxType2 = _interopRequireDefault(_checkboxType);
    var _dateType = __webpack_require__(314);
    var _dateType2 = _interopRequireDefault(_dateType);
    var _dropdownType = __webpack_require__(315);
    var _dropdownType2 = _interopRequireDefault(_dropdownType);
    var _handsontableType = __webpack_require__(316);
    var _handsontableType2 = _interopRequireDefault(_handsontableType);
    var _numericType = __webpack_require__(317);
    var _numericType2 = _interopRequireDefault(_numericType);
    var _passwordType = __webpack_require__(318);
    var _passwordType2 = _interopRequireDefault(_passwordType);
    var _textType = __webpack_require__(319);
    var _textType2 = _interopRequireDefault(_textType);
    var _timeType = __webpack_require__(320);
    var _timeType2 = _interopRequireDefault(_timeType);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }
    var _staticRegister = (0, _staticRegister3.default)('cellTypes'),
      register = _staticRegister.register,
      getItem = _staticRegister.getItem,
      hasItem = _staticRegister.hasItem,
      getNames = _staticRegister.getNames,
      getValues = _staticRegister.getValues;
    _register('autocomplete', _autocompleteType2.default);
    _register('checkbox', _checkboxType2.default);
    _register('date', _dateType2.default);
    _register('dropdown', _dropdownType2.default);
    _register('handsontable', _handsontableType2.default);
    _register('numeric', _numericType2.default);
    _register('password', _passwordType2.default);
    _register('text', _textType2.default);
    _register('time', _timeType2.default);

    function _getItem(name) {
      if (!hasItem(name)) {
        throw Error('You declared cell type "' + name + '" as a string that is not mapped to a known object.\n                 Cell type must be an object or a string mapped to an object registered by "Handsontable.cellTypes.registerCellType" method');
      }
      return getItem(name);
    }

    function _register(name, type) {
      var editor = type.editor,
        renderer = type.renderer,
        validator = type.validator;
      if (editor) {
        (0, _editors.registerEditor)(name, editor);
      }
      if (renderer) {
        (0, _renderers.registerRenderer)(name, renderer);
      }
      if (validator) {
        (0, _validators.registerValidator)(name, validator);
      }
      register(name, type);
    }
    exports.registerCellType = _register;
    exports.getCellType = _getItem;
    exports.hasCellType = hasItem;
    exports.getRegisteredCellTypeNames = getNames;
    exports.getRegisteredCellTypes = getValues;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _slicedToArray = function () {
      function sliceIterator(arr, i) {
        var _arr = [];
        var _n = true;
        var _d = false;
        var _e = undefined;
        try {
          for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
            _arr.push(_s.value);
            if (i && _arr.length === i) break;
          }
        } catch (err) {
          _d = true;
          _e = err;
        } finally {
          try {
            if (!_n && _i["return"]) _i["return"]();
          } finally {
            if (_d) throw _e;
          }
        }
        return _arr;
      }
      return function (arr, i) {
        if (Array.isArray(arr)) {
          return arr;
        } else if (Symbol.iterator in Object(arr)) {
          return sliceIterator(arr, i);
        } else {
          throw new TypeError("Invalid attempt to destructure non-iterable instance");
        }
      };
    }();
    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
      return typeof obj;
    } : function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
    exports.default = Core;
    var _numbro = __webpack_require__(52);
    var _numbro2 = _interopRequireDefault(_numbro);
    var _element = __webpack_require__(0);
    var _setting = __webpack_require__(68);
    var _function = __webpack_require__(35);
    var _mixed = __webpack_require__(23);
    var _browser = __webpack_require__(22);
    var _dataMap = __webpack_require__(321);
    var _dataMap2 = _interopRequireDefault(_dataMap);
    var _editorManager = __webpack_require__(323);
    var _editorManager2 = _interopRequireDefault(_editorManager);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _object = __webpack_require__(3);
    var _array = __webpack_require__(2);
    var _plugins = __webpack_require__(9);
    var _renderers = __webpack_require__(6);
    var _validators = __webpack_require__(24);
    var _string = __webpack_require__(28);
    var _number = __webpack_require__(5);
    var _tableView = __webpack_require__(383);
    var _tableView2 = _interopRequireDefault(_tableView);
    var _dataSource = __webpack_require__(322);
    var _dataSource2 = _interopRequireDefault(_dataSource);
    var _data = __webpack_require__(67);
    var _recordTranslator = __webpack_require__(268);
    var _rootInstance = __webpack_require__(90);
    var _src = __webpack_require__(14);
    var _pluginHooks = __webpack_require__(11);
    var _pluginHooks2 = _interopRequireDefault(_pluginHooks);
    var _defaultSettings = __webpack_require__(88);
    var _defaultSettings2 = _interopRequireDefault(_defaultSettings);
    var _cellTypes = __webpack_require__(65);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _toConsumableArray(arr) {
      if (Array.isArray(arr)) {
        for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
          arr2[i] = arr[i];
        }
        return arr2;
      } else {
        return Array.from(arr);
      }
    }
    var activeGuid = null;

    function Core(rootElement, userSettings) {
      var rootInstanceSymbol = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
      var priv, datamap, dataSource, grid, selection, editorManager, instance = this,
        GridSettings = function GridSettings() { },
        eventManager = new _eventManager2.default(instance);
      (0, _object.extend)(GridSettings.prototype, _defaultSettings2.default.prototype);
      (0, _object.extend)(GridSettings.prototype, userSettings);
      (0, _object.extend)(GridSettings.prototype, expandType(userSettings));
      if ((0, _rootInstance.hasValidParameter)(rootInstanceSymbol)) {
        (0, _rootInstance.registerAsRootInstance)(this);
      }
      this.rootElement = rootElement;
      this.isHotTableEnv = (0, _element.isChildOfWebComponentTable)(this.rootElement);
      _eventManager2.default.isHotTableEnv = this.isHotTableEnv;
      this.container = document.createElement('div');
      this.renderCall = false;
      rootElement.insertBefore(this.container, rootElement.firstChild);
      if (undefined !== '\x63\x65' && (0, _rootInstance.isRootInstance)(this)) {
        (0, _mixed._injectProductInfo)(userSettings.licenseKey, rootElement);
      }
      this.guid = 'ht_' + (0, _string.randomString)();
      var recordTranslator = (0, _recordTranslator.getTranslator)(instance);
      dataSource = new _dataSource2.default(instance);
      if (!this.rootElement.id || this.rootElement.id.substring(0, 3) === 'ht_') {
        this.rootElement.id = this.guid;
      }
      priv = {
        cellSettings: [],
        columnSettings: [],
        columnsSettingConflicts: ['data', 'width'],
        settings: new GridSettings(),
        selRange: null,
        isPopulated: null,
        scrollable: null,
        firstRun: true
      };
      grid = {
        alter: function alter(action, index, amount, source, keepEmptyRows) {
          var delta;
          amount = amount || 1;

          function spliceWith(data, index, count, toInject) {
            var valueFactory = function valueFactory() {
              var result = void 0;
              if (toInject === 'array') {
                result = [];
              } else if (toInject === 'object') {
                result = {};
              }
              return result;
            };
            var spliceArgs = (0, _array.arrayMap)(new Array(count), function () {
              return valueFactory();
            });
            spliceArgs.unshift(index, 0);
            data.splice.apply(data, _toConsumableArray(spliceArgs));
          }
          switch (action) {
            case 'insert_row':
              var numberOfSourceRows = instance.countSourceRows();
              if (instance.getSettings().maxRows === numberOfSourceRows) {
                return;
              }
              index = (0, _mixed.isDefined)(index) ? index : numberOfSourceRows;
              delta = datamap.createRow(index, amount, source);
              spliceWith(priv.cellSettings, index, amount, 'array');
              if (delta) {
                if (selection.isSelected() && priv.selRange.from.row >= index) {
                  priv.selRange.from.row += delta;
                  selection.transformEnd(delta, 0);
                } else {
                  selection.refreshBorders();
                }
              }
              break;
            case 'insert_col':
              delta = datamap.createCol(index, amount, source);
              for (var row = 0, len = instance.countSourceRows(); row < len; row++) {
                if (priv.cellSettings[row]) {
                  spliceWith(priv.cellSettings[row], index, amount);
                }
              }
              if (delta) {
                if (Array.isArray(instance.getSettings().colHeaders)) {
                  var spliceArray = [index, 0];
                  spliceArray.length += delta;
                  Array.prototype.splice.apply(instance.getSettings().colHeaders, spliceArray);
                }
                if (selection.isSelected() && priv.selRange.from.col >= index) {
                  priv.selRange.from.col += delta;
                  selection.transformEnd(0, delta);
                } else {
                  selection.refreshBorders();
                }
              }
              break;
            case 'remove_row':
              datamap.removeRow(index, amount, source);
              priv.cellSettings.splice(index, amount);
              var totalRows = instance.countRows();
              var fixedRowsTop = instance.getSettings().fixedRowsTop;
              if (fixedRowsTop >= index + 1) {
                instance.getSettings().fixedRowsTop -= Math.min(amount, fixedRowsTop - index);
              }
              var fixedRowsBottom = instance.getSettings().fixedRowsBottom;
              if (fixedRowsBottom && index >= totalRows - fixedRowsBottom) {
                instance.getSettings().fixedRowsBottom -= Math.min(amount, fixedRowsBottom);
              }
              grid.adjustRowsAndCols();
              selection.refreshBorders();
              break;
            case 'remove_col':
              var visualColumnIndex = recordTranslator.toPhysicalColumn(index);
              datamap.removeCol(index, amount, source);
              for (var _row = 0, _len = instance.countSourceRows(); _row < _len; _row++) {
                if (priv.cellSettings[_row]) {
                  priv.cellSettings[_row].splice(visualColumnIndex, amount);
                }
              }
              var fixedColumnsLeft = instance.getSettings().fixedColumnsLeft;
              if (fixedColumnsLeft >= index + 1) {
                instance.getSettings().fixedColumnsLeft -= Math.min(amount, fixedColumnsLeft - index);
              }
              if (Array.isArray(instance.getSettings().colHeaders)) {
                if (typeof visualColumnIndex === 'undefined') {
                  visualColumnIndex = -1;
                }
                instance.getSettings().colHeaders.splice(visualColumnIndex, amount);
              }
              grid.adjustRowsAndCols();
              selection.refreshBorders();
              break;
            default:
              throw new Error('There is no such action "' + action + '"');
          }
          if (!keepEmptyRows) {
            grid.adjustRowsAndCols();
          }
        },
        adjustRowsAndCols: function adjustRowsAndCols() {
          if (priv.settings.minRows) {
            var rows = instance.countRows();
            if (rows < priv.settings.minRows) {
              for (var r = 0, minRows = priv.settings.minRows; r < minRows - rows; r++) {
                datamap.createRow(instance.countRows(), 1, 'auto');
              }
            }
          }
          if (priv.settings.minSpareRows) {
            var emptyRows = instance.countEmptyRows(true);
            if (emptyRows < priv.settings.minSpareRows) {
              for (; emptyRows < priv.settings.minSpareRows && instance.countSourceRows() < priv.settings.maxRows; emptyRows++) {
                datamap.createRow(instance.countRows(), 1, 'auto');
              }
            }
          } {
            var emptyCols = void 0;
            if (priv.settings.minCols || priv.settings.minSpareCols) {
              emptyCols = instance.countEmptyCols(true);
            }
            if (priv.settings.minCols && !priv.settings.columns && instance.countCols() < priv.settings.minCols) {
              for (; instance.countCols() < priv.settings.minCols; emptyCols++) {
                datamap.createCol(instance.countCols(), 1, 'auto');
              }
            }
            if (priv.settings.minSpareCols && !priv.settings.columns && instance.dataType === 'array' && emptyCols < priv.settings.minSpareCols) {
              for (; emptyCols < priv.settings.minSpareCols && instance.countCols() < priv.settings.maxCols; emptyCols++) {
                datamap.createCol(instance.countCols(), 1, 'auto');
              }
            }
          }
          var rowCount = instance.countRows();
          var colCount = instance.countCols();
          if (rowCount === 0 || colCount === 0) {
            selection.deselect();
          }
          if (selection.isSelected()) {
            var selectionChanged = false;
            var fromRow = priv.selRange.from.row;
            var fromCol = priv.selRange.from.col;
            var toRow = priv.selRange.to.row;
            var toCol = priv.selRange.to.col;
            if (fromRow > rowCount - 1) {
              fromRow = rowCount - 1;
              selectionChanged = true;
              if (toRow > fromRow) {
                toRow = fromRow;
              }
            } else if (toRow > rowCount - 1) {
              toRow = rowCount - 1;
              selectionChanged = true;
              if (fromRow > toRow) {
                fromRow = toRow;
              }
            }
            if (fromCol > colCount - 1) {
              fromCol = colCount - 1;
              selectionChanged = true;
              if (toCol > fromCol) {
                toCol = fromCol;
              }
            } else if (toCol > colCount - 1) {
              toCol = colCount - 1;
              selectionChanged = true;
              if (fromCol > toCol) {
                fromCol = toCol;
              }
            }
            if (selectionChanged) {
              instance.selectCell(fromRow, fromCol, toRow, toCol);
            }
          }
          if (instance.view) {
            instance.view.wt.wtOverlays.adjustElementsSize();
          }
        },
        populateFromArray: function populateFromArray(start, input, end, source, method, direction, deltas) {
          var r, rlen, c, clen, setData = [],
            current = {};
          rlen = input.length;
          if (rlen === 0) {
            return false;
          }
          var repeatCol, repeatRow, cmax, rmax, baseEnd = {
            row: end === null ? null : end.row,
            col: end === null ? null : end.col
          };
          switch (method) {
            case 'shift_down':
              repeatCol = end ? end.col - start.col + 1 : 0;
              repeatRow = end ? end.row - start.row + 1 : 0;
              input = (0, _data.translateRowsToColumns)(input);
              for (c = 0, clen = input.length, cmax = Math.max(clen, repeatCol); c < cmax; c++) {
                if (c < clen) {
                  var _instance;
                  for (r = 0, rlen = input[c].length; r < repeatRow - rlen; r++) {
                    input[c].push(input[c][r % rlen]);
                  }
                  input[c].unshift(start.col + c, start.row, 0);
                  (_instance = instance).spliceCol.apply(_instance, _toConsumableArray(input[c]));
                } else {
                  var _instance2;
                  input[c % clen][0] = start.col + c;
                  (_instance2 = instance).spliceCol.apply(_instance2, _toConsumableArray(input[c % clen]));
                }
              }
              break;
            case 'shift_right':
              repeatCol = end ? end.col - start.col + 1 : 0;
              repeatRow = end ? end.row - start.row + 1 : 0;
              for (r = 0, rlen = input.length, rmax = Math.max(rlen, repeatRow); r < rmax; r++) {
                if (r < rlen) {
                  var _instance3;
                  for (c = 0, clen = input[r].length; c < repeatCol - clen; c++) {
                    input[r].push(input[r][c % clen]);
                  }
                  input[r].unshift(start.row + r, start.col, 0);
                  (_instance3 = instance).spliceRow.apply(_instance3, _toConsumableArray(input[r]));
                } else {
                  var _instance4;
                  input[r % rlen][0] = start.row + r;
                  (_instance4 = instance).spliceRow.apply(_instance4, _toConsumableArray(input[r % rlen]));
                }
              }
              break;
            case 'overwrite':
            default:
              current.row = start.row;
              current.col = start.col;
              var selected = {
                row: end && start ? end.row - start.row + 1 : 1,
                col: end && start ? end.col - start.col + 1 : 1
              };
              var skippedRow = 0;
              var skippedColumn = 0;
              var pushData = true;
              var cellMeta = void 0;
              var getInputValue = function getInputValue(row) {
                var col = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
                var rowValue = input[row % input.length];
                if (col !== null) {
                  return rowValue[col % rowValue.length];
                }
                return rowValue;
              };
              var rowInputLength = input.length;
              var rowSelectionLength = end ? end.row - start.row + 1 : 0;
              if (end) {
                rlen = rowSelectionLength;
              } else {
                rlen = Math.max(rowInputLength, rowSelectionLength);
              }
              for (r = 0; r < rlen; r++) {
                if (end && current.row > end.row && rowSelectionLength > rowInputLength || !priv.settings.allowInsertRow && current.row > instance.countRows() - 1 || current.row >= priv.settings.maxRows) {
                  break;
                }
                var visualRow = r - skippedRow;
                var colInputLength = getInputValue(visualRow).length;
                var colSelectionLength = end ? end.col - start.col + 1 : 0;
                if (end) {
                  clen = colSelectionLength;
                } else {
                  clen = Math.max(colInputLength, colSelectionLength);
                }
                current.col = start.col;
                cellMeta = instance.getCellMeta(current.row, current.col);
                if ((source === 'CopyPaste.paste' || source === 'Autofill.autofill') && cellMeta.skipRowOnPaste) {
                  skippedRow++;
                  current.row++;
                  rlen++;
                  continue;
                }
                skippedColumn = 0;
                for (c = 0; c < clen; c++) {
                  if (end && current.col > end.col && colSelectionLength > colInputLength || !priv.settings.allowInsertColumn && current.col > instance.countCols() - 1 || current.col >= priv.settings.maxCols) {
                    break;
                  }
                  cellMeta = instance.getCellMeta(current.row, current.col);
                  if ((source === 'CopyPaste.paste' || source === 'Autofill.fill') && cellMeta.skipColumnOnPaste) {
                    skippedColumn++;
                    current.col++;
                    clen++;
                    continue;
                  }
                  if (cellMeta.readOnly) {
                    current.col++;
                    continue;
                  }
                  var visualColumn = c - skippedColumn;
                  var value = getInputValue(visualRow, visualColumn);
                  var orgValue = instance.getDataAtCell(current.row, current.col);
                  var index = {
                    row: visualRow,
                    col: visualColumn
                  };
                  if (source === 'Autofill.fill') {
                    var result = instance.runHooks('beforeAutofillInsidePopulate', index, direction, input, deltas, {}, selected);
                    if (result) {
                      value = (0, _mixed.isUndefined)(result.value) ? value : result.value;
                    }
                  }
                  if (value !== null && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
                    if (orgValue === null || (typeof orgValue === 'undefined' ? 'undefined' : _typeof(orgValue)) !== 'object') {
                      pushData = false;
                    } else {
                      var orgValueSchema = (0, _object.duckSchema)(orgValue[0] || orgValue);
                      var valueSchema = (0, _object.duckSchema)(value[0] || value);
                      if ((0, _object.isObjectEquals)(orgValueSchema, valueSchema)) {
                        value = (0, _object.deepClone)(value);
                      } else {
                        pushData = false;
                      }
                    }
                  } else if (orgValue !== null && (typeof orgValue === 'undefined' ? 'undefined' : _typeof(orgValue)) === 'object') {
                    pushData = false;
                  }
                  if (pushData) {
                    setData.push([current.row, current.col, value]);
                  }
                  pushData = true;
                  current.col++;
                }
                current.row++;
              }
              instance.setDataAtCell(setData, null, null, source || 'populateFromArray');
              break;
          }
        }
      };
      this.selection = selection = {
        inProgress: false,
        selectedHeader: {
          cols: false,
          rows: false
        },
        setSelectedHeaders: function setSelectedHeaders() {
          var rows = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
          var cols = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
          var corner = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
          instance.selection.selectedHeader.rows = rows;
          instance.selection.selectedHeader.cols = cols;
          instance.selection.selectedHeader.corner = corner;
        },
        begin: function begin() {
          instance.selection.inProgress = true;
        },
        finish: function finish() {
          var sel = instance.getSelected();
          instance.runHooks('afterSelectionEnd', sel[0], sel[1], sel[2], sel[3]);
          instance.runHooks('afterSelectionEndByProp', sel[0], instance.colToProp(sel[1]), sel[2], instance.colToProp(sel[3]));
          instance.selection.inProgress = false;
        },
        isInProgress: function isInProgress() {
          return instance.selection.inProgress;
        },
        setRangeStart: function setRangeStart(coords, keepEditorOpened) {
          instance.runHooks('beforeSetRangeStart', coords);
          priv.selRange = new _src.CellRange(coords, coords, coords);
          selection.setRangeEnd(coords, null, keepEditorOpened);
        },
        setRangeStartOnly: function setRangeStartOnly(coords) {
          instance.runHooks('beforeSetRangeStartOnly', coords);
          priv.selRange = new _src.CellRange(coords, coords, coords);
        },
        setRangeEnd: function setRangeEnd(coords, scrollToCell, keepEditorOpened) {
          if (priv.selRange === null) {
            return;
          }
          var disableVisualSelection, isHeaderSelected = false,
            areCoordsPositive = true;
          var firstVisibleRow = instance.view.wt.wtTable.getFirstVisibleRow();
          var firstVisibleColumn = instance.view.wt.wtTable.getFirstVisibleColumn();
          var newRangeCoords = {
            row: null,
            col: null
          };
          instance.runHooks('beforeSetRangeEnd', coords);
          instance.selection.begin();
          newRangeCoords.row = coords.row < 0 ? firstVisibleRow : coords.row;
          newRangeCoords.col = coords.col < 0 ? firstVisibleColumn : coords.col;
          priv.selRange.to = new _src.CellCoords(newRangeCoords.row, newRangeCoords.col);
          if (!priv.settings.multiSelect) {
            priv.selRange.from = coords;
          }
          instance.view.wt.selections.current.clear();
          disableVisualSelection = instance.getCellMeta(priv.selRange.highlight.row, priv.selRange.highlight.col).disableVisualSelection;
          if (typeof disableVisualSelection === 'string') {
            disableVisualSelection = [disableVisualSelection];
          }
          if (disableVisualSelection === false || Array.isArray(disableVisualSelection) && disableVisualSelection.indexOf('current') === -1) {
            instance.view.wt.selections.current.add(priv.selRange.highlight);
          }
          instance.view.wt.selections.area.clear();
          if ((disableVisualSelection === false || Array.isArray(disableVisualSelection) && disableVisualSelection.indexOf('area') === -1) && selection.isMultiple()) {
            instance.view.wt.selections.area.add(priv.selRange.from);
            instance.view.wt.selections.area.add(priv.selRange.to);
          }
          if (priv.settings.currentHeaderClassName || priv.settings.currentRowClassName || priv.settings.currentColClassName) {
            instance.view.wt.selections.highlight.clear();
            instance.view.wt.selections.highlight.add(priv.selRange.from);
            instance.view.wt.selections.highlight.add(priv.selRange.to);
          }
          var preventScrolling = (0, _object.createObjectPropListener)('value');
          instance.runHooks('afterSelection', priv.selRange.from.row, priv.selRange.from.col, priv.selRange.to.row, priv.selRange.to.col, preventScrolling);
          instance.runHooks('afterSelectionByProp', priv.selRange.from.row, datamap.colToProp(priv.selRange.from.col), priv.selRange.to.row, datamap.colToProp(priv.selRange.to.col), preventScrolling);
          if (priv.selRange.from.row === 0 && priv.selRange.to.row === instance.countRows() - 1 && instance.countRows() > 1 || priv.selRange.from.col === 0 && priv.selRange.to.col === instance.countCols() - 1 && instance.countCols() > 1) {
            isHeaderSelected = true;
          }
          if (coords.row < 0 || coords.col < 0) {
            areCoordsPositive = false;
          }
          if (preventScrolling.isTouched()) {
            scrollToCell = !preventScrolling.value;
          }
          if (scrollToCell !== false && !isHeaderSelected && areCoordsPositive) {
            if (priv.selRange.from && !selection.isMultiple()) {
              instance.view.scrollViewport(priv.selRange.from);
            } else {
              instance.view.scrollViewport(coords);
            }
          }
          if (selection.selectedHeader.rows && selection.selectedHeader.cols) {
            (0, _element.addClass)(instance.rootElement, ['ht__selection--rows', 'ht__selection--columns']);
          } else if (selection.selectedHeader.rows) {
            (0, _element.removeClass)(instance.rootElement, 'ht__selection--columns');
            (0, _element.addClass)(instance.rootElement, 'ht__selection--rows');
          } else if (selection.selectedHeader.cols) {
            (0, _element.removeClass)(instance.rootElement, 'ht__selection--rows');
            (0, _element.addClass)(instance.rootElement, 'ht__selection--columns');
          } else {
            (0, _element.removeClass)(instance.rootElement, ['ht__selection--rows', 'ht__selection--columns']);
          }
          selection.refreshBorders(null, keepEditorOpened);
        },
        refreshBorders: function refreshBorders(revertOriginal, keepEditor) {
          if (!keepEditor) {
            editorManager.destroyEditor(revertOriginal);
          }
          instance.view.render();
          if (selection.isSelected() && !keepEditor) {
            editorManager.prepareEditor();
          }
        },
        isMultiple: function isMultiple() {
          var isMultiple = !(priv.selRange.to.col === priv.selRange.from.col && priv.selRange.to.row === priv.selRange.from.row),
            modifier = instance.runHooks('afterIsMultipleSelection', isMultiple);
          if (isMultiple) {
            return modifier;
          }
        },
        transformStart: function transformStart(rowDelta, colDelta, force, keepEditorOpened) {
          var delta = new _src.CellCoords(rowDelta, colDelta),
            rowTransformDir = 0,
            colTransformDir = 0,
            totalRows, totalCols, coords, fixedRowsBottom;
          instance.runHooks('modifyTransformStart', delta);
          totalRows = instance.countRows();
          totalCols = instance.countCols();
          fixedRowsBottom = instance.getSettings().fixedRowsBottom;
          if (priv.selRange.highlight.row + rowDelta > totalRows - 1) {
            if (force && priv.settings.minSpareRows > 0 && !(fixedRowsBottom && priv.selRange.highlight.row >= totalRows - fixedRowsBottom - 1)) {
              instance.alter('insert_row', totalRows);
              totalRows = instance.countRows();
            } else if (priv.settings.autoWrapCol) {
              delta.row = 1 - totalRows;
              delta.col = priv.selRange.highlight.col + delta.col == totalCols - 1 ? 1 - totalCols : 1;
            }
          } else if (priv.settings.autoWrapCol && priv.selRange.highlight.row + delta.row < 0 && priv.selRange.highlight.col + delta.col >= 0) {
            delta.row = totalRows - 1;
            delta.col = priv.selRange.highlight.col + delta.col == 0 ? totalCols - 1 : -1;
          }
          if (priv.selRange.highlight.col + delta.col > totalCols - 1) {
            if (force && priv.settings.minSpareCols > 0) {
              instance.alter('insert_col', totalCols);
              totalCols = instance.countCols();
            } else if (priv.settings.autoWrapRow) {
              delta.row = priv.selRange.highlight.row + delta.row == totalRows - 1 ? 1 - totalRows : 1;
              delta.col = 1 - totalCols;
            }
          } else if (priv.settings.autoWrapRow && priv.selRange.highlight.col + delta.col < 0 && priv.selRange.highlight.row + delta.row >= 0) {
            delta.row = priv.selRange.highlight.row + delta.row == 0 ? totalRows - 1 : -1;
            delta.col = totalCols - 1;
          }
          coords = new _src.CellCoords(priv.selRange.highlight.row + delta.row, priv.selRange.highlight.col + delta.col);
          if (coords.row < 0) {
            rowTransformDir = -1;
            coords.row = 0;
          } else if (coords.row > 0 && coords.row >= totalRows) {
            rowTransformDir = 1;
            coords.row = totalRows - 1;
          }
          if (coords.col < 0) {
            colTransformDir = -1;
            coords.col = 0;
          } else if (coords.col > 0 && coords.col >= totalCols) {
            colTransformDir = 1;
            coords.col = totalCols - 1;
          }
          instance.runHooks('afterModifyTransformStart', coords, rowTransformDir, colTransformDir);
          selection.setRangeStart(coords, keepEditorOpened);
        },
        transformEnd: function transformEnd(rowDelta, colDelta) {
          var delta = new _src.CellCoords(rowDelta, colDelta),
            rowTransformDir = 0,
            colTransformDir = 0,
            totalRows, totalCols, coords;
          instance.runHooks('modifyTransformEnd', delta);
          totalRows = instance.countRows();
          totalCols = instance.countCols();
          coords = new _src.CellCoords(priv.selRange.to.row + delta.row, priv.selRange.to.col + delta.col);
          if (coords.row < 0) {
            rowTransformDir = -1;
            coords.row = 0;
          } else if (coords.row > 0 && coords.row >= totalRows) {
            rowTransformDir = 1;
            coords.row = totalRows - 1;
          }
          if (coords.col < 0) {
            colTransformDir = -1;
            coords.col = 0;
          } else if (coords.col > 0 && coords.col >= totalCols) {
            colTransformDir = 1;
            coords.col = totalCols - 1;
          }
          instance.runHooks('afterModifyTransformEnd', coords, rowTransformDir, colTransformDir);
          selection.setRangeEnd(coords, true);
        },
        isSelected: function isSelected() {
          return priv.selRange !== null;
        },
        inInSelection: function inInSelection(coords) {
          if (!selection.isSelected()) {
            return false;
          }
          return priv.selRange.includes(coords);
        },
        deselect: function deselect() {
          if (!selection.isSelected()) {
            return;
          }
          instance.selection.inProgress = false;
          priv.selRange = null;
          instance.view.wt.selections.current.clear();
          instance.view.wt.selections.area.clear();
          if (priv.settings.currentHeaderClassName || priv.settings.currentRowClassName || priv.settings.currentColClassName) {
            instance.view.wt.selections.highlight.clear();
          }
          editorManager.destroyEditor();
          selection.refreshBorders();
          (0, _element.removeClass)(instance.rootElement, ['ht__selection--rows', 'ht__selection--columns']);
          instance.runHooks('afterDeselect');
        },
        selectAll: function selectAll() {
          if (!priv.settings.multiSelect) {
            return;
          }
          selection.setSelectedHeaders(true, true, true);
          selection.setRangeStart(new _src.CellCoords(0, 0));
          selection.setRangeEnd(new _src.CellCoords(instance.countRows() - 1, instance.countCols() - 1), false);
        },
        empty: function empty() {
          if (!selection.isSelected()) {
            return;
          }
          var topLeft = priv.selRange.getTopLeftCorner();
          var bottomRight = priv.selRange.getBottomRightCorner();
          var r, c, changes = [];
          for (r = topLeft.row; r <= bottomRight.row; r++) {
            for (c = topLeft.col; c <= bottomRight.col; c++) {
              if (!instance.getCellMeta(r, c).readOnly) {
                changes.push([r, c, '']);
              }
            }
          }
          instance.setDataAtCell(changes);
        }
      };
      this.init = function () {
        dataSource.setData(priv.settings.data);
        instance.runHooks('beforeInit');
        if ((0, _browser.isMobileBrowser)()) {
          (0, _element.addClass)(instance.rootElement, 'mobile');
        }
        this.updateSettings(priv.settings, true);
        this.view = new _tableView2.default(this);
        editorManager = new _editorManager2.default(instance, priv, selection, datamap);
        this.forceFullRender = true;
        instance.runHooks('init');
        this.view.render();
        if (_typeof(priv.firstRun) === 'object') {
          instance.runHooks('afterChange', priv.firstRun[0], priv.firstRun[1]);
          priv.firstRun = false;
        }
        instance.runHooks('afterInit');
      };

      function ValidatorsQueue() {
        var resolved = false;
        return {
          validatorsInQueue: 0,
          valid: true,
          addValidatorToQueue: function addValidatorToQueue() {
            this.validatorsInQueue++;
            resolved = false;
          },
          removeValidatorFormQueue: function removeValidatorFormQueue() {
            this.validatorsInQueue = this.validatorsInQueue - 1 < 0 ? 0 : this.validatorsInQueue - 1;
            this.checkIfQueueIsEmpty();
          },
          onQueueEmpty: function onQueueEmpty(valid) { },
          checkIfQueueIsEmpty: function checkIfQueueIsEmpty() {
            if (this.validatorsInQueue == 0 && resolved == false) {
              resolved = true;
              this.onQueueEmpty(this.valid);
            }
          }
        };
      }

      function validateChanges(changes, source, callback) {
        var waitingForValidator = new ValidatorsQueue();
        waitingForValidator.onQueueEmpty = resolve;
        for (var i = changes.length - 1; i >= 0; i--) {
          if (changes[i] === null) {
            changes.splice(i, 1);
          } else {
            var row = changes[i][0];
            var col = datamap.propToCol(changes[i][1]);
            var cellProperties = instance.getCellMeta(row, col);
            if (cellProperties.type === 'numeric' && typeof changes[i][3] === 'string') {
              if (changes[i][3].length > 0 && (/^-?[\d\s]*(\.|,)?\d*$/.test(changes[i][3]) || cellProperties.format)) {
                var len = changes[i][3].length;
                if ((0, _mixed.isUndefined)(cellProperties.language)) {
                  _numbro2.default.culture('en-US');
                } else if (changes[i][3].indexOf('.') === len - 3 && changes[i][3].indexOf(',') === -1) {
                  _numbro2.default.culture('en-US');
                } else {
                  _numbro2.default.culture(cellProperties.language);
                }
                var _numbro$cultureData = _numbro2.default.cultureData(_numbro2.default.culture()),
                  delimiters = _numbro$cultureData.delimiters;
                if (_numbro2.default.validate(changes[i][3]) && !isNaN(changes[i][3])) {
                  changes[i][3] = parseFloat(changes[i][3]);
                } else {
                  changes[i][3] = (0, _numbro2.default)().unformat(changes[i][3]) || changes[i][3];
                }
              }
            }
            if (instance.getCellValidator(cellProperties)) {
              waitingForValidator.addValidatorToQueue();
              instance.validateCell(changes[i][3], cellProperties, function (i, cellProperties) {
                return function (result) {
                  if (typeof result !== 'boolean') {
                    throw new Error('Validation error: result is not boolean');
                  }
                  if (result === false && cellProperties.allowInvalid === false) {
                    changes.splice(i, 1);
                    cellProperties.valid = true;
                    var cell = instance.getCell(cellProperties.row, cellProperties.col);
                    (0, _element.removeClass)(cell, instance.getSettings().invalidCellClassName);
                    --i;
                  }
                  waitingForValidator.removeValidatorFormQueue();
                };
              }(i, cellProperties), source);
            }
          }
        }
        waitingForValidator.checkIfQueueIsEmpty();

        function resolve() {
          var beforeChangeResult;
          if (changes.length) {
            beforeChangeResult = instance.runHooks('beforeChange', changes, source);
            if ((0, _function.isFunction)(beforeChangeResult)) {
              console.warn('Your beforeChange callback returns a function. It\'s not supported since Handsontable 0.12.1 (and the returned function will not be executed).');
            } else if (beforeChangeResult === false) {
              changes.splice(0, changes.length);
            }
          }
          callback();
        }
      }

      function applyChanges(changes, source) {
        var i = changes.length - 1;
        if (i < 0) {
          return;
        }
        for (; i >= 0; i--) {
          var skipThisChange = false;
          if (changes[i] === null) {
            changes.splice(i, 1);
            continue;
          }
          if (changes[i][2] == null && changes[i][3] == null) {
            continue;
          }
          if (priv.settings.allowInsertRow) {
            while (changes[i][0] > instance.countRows() - 1) {
              var numberOfCreatedRows = datamap.createRow(void 0, void 0, source);
              if (numberOfCreatedRows === 0) {
                skipThisChange = true;
                break;
              }
            }
          }
          if (skipThisChange) {
            continue;
          }
          if (instance.dataType === 'array' && (!priv.settings.columns || priv.settings.columns.length === 0) && priv.settings.allowInsertColumn) {
            while (datamap.propToCol(changes[i][1]) > instance.countCols() - 1) {
              datamap.createCol(void 0, void 0, source);
            }
          }
          datamap.set(changes[i][0], changes[i][1], changes[i][3]);
        }
        instance.forceFullRender = true;
        grid.adjustRowsAndCols();
        instance.runHooks('beforeChangeRender', changes, source);
        selection.refreshBorders(null, true);
        instance.view.wt.wtOverlays.adjustElementsSize();
        instance.runHooks('afterChange', changes, source || 'edit');
        var activeEditor = instance.getActiveEditor();
        if (activeEditor && (0, _mixed.isDefined)(activeEditor.refreshValue)) {
          activeEditor.refreshValue();
        }
      }
      this.validateCell = function (value, cellProperties, callback, source) {
        var validator = instance.getCellValidator(cellProperties);

        function done(valid) {
          var col = cellProperties.visualCol,
            row = cellProperties.visualRow,
            td = instance.getCell(row, col, true);
          if (td && td.nodeName != 'TH') {
            instance.view.wt.wtSettings.settings.cellRenderer(row, col, td);
          }
          callback(valid);
        }
        if ((0, _mixed.isRegExp)(validator)) {
          validator = function (validator) {
            return function (value, callback) {
              callback(validator.test(value));
            };
          }(validator);
        }
        if ((0, _function.isFunction)(validator)) {
          value = instance.runHooks('beforeValidate', value, cellProperties.visualRow, cellProperties.prop, source);
          instance._registerTimeout(setTimeout(function () {
            validator.call(cellProperties, value, function (valid) {
              valid = instance.runHooks('afterValidate', valid, value, cellProperties.visualRow, cellProperties.prop, source);
              cellProperties.valid = valid;
              done(valid);
              instance.runHooks('postAfterValidate', valid, value, cellProperties.visualRow, cellProperties.prop, source);
            });
          }, 0));
        } else {
          instance._registerTimeout(setTimeout(function () {
            cellProperties.valid = true;
            done(cellProperties.valid);
          }, 0));
        }
      };

      function setDataInputToArray(row, propOrCol, value) {
        if ((typeof row === 'undefined' ? 'undefined' : _typeof(row)) === 'object') {
          return row;
        }
        return [
          [row, propOrCol, value]
        ];
      }
      this.setDataAtCell = function (row, col, value, source) {
        var input = setDataInputToArray(row, col, value),
          i, ilen, changes = [],
          prop;
        for (i = 0, ilen = input.length; i < ilen; i++) {
          if (_typeof(input[i]) !== 'object') {
            throw new Error('Method `setDataAtCell` accepts row number or changes array of arrays as its first parameter');
          }
          if (typeof input[i][1] !== 'number') {
            throw new Error('Method `setDataAtCell` accepts row and column number as its parameters. If you want to use object property name, use method `setDataAtRowProp`');
          }
          prop = datamap.colToProp(input[i][1]);
          changes.push([input[i][0], prop, dataSource.getAtCell(recordTranslator.toPhysicalRow(input[i][0]), input[i][1]), input[i][2]]);
        }
        if (!source && (typeof row === 'undefined' ? 'undefined' : _typeof(row)) === 'object') {
          source = col;
        }
        instance.runHooks('afterSetDataAtCell', changes, source);
        validateChanges(changes, source, function () {
          applyChanges(changes, source);
        });
      };
      this.setDataAtRowProp = function (row, prop, value, source) {
        var input = setDataInputToArray(row, prop, value),
          i, ilen, changes = [];
        for (i = 0, ilen = input.length; i < ilen; i++) {
          changes.push([input[i][0], input[i][1], dataSource.getAtCell(recordTranslator.toPhysicalRow(input[i][0]), input[i][1]), input[i][2]]);
        }
        if (!source && (typeof row === 'undefined' ? 'undefined' : _typeof(row)) === 'object') {
          source = prop;
        }
        instance.runHooks('afterSetDataAtRowProp', changes, source);
        validateChanges(changes, source, function () {
          applyChanges(changes, source);
        });
      };
      this.listen = function () {
        var invalidActiveElement = !document.activeElement || document.activeElement && document.activeElement.nodeName === void 0;
        if (document.activeElement && document.activeElement !== document.body && !invalidActiveElement) {
          document.activeElement.blur();
        } else if (invalidActiveElement) {
          document.body.focus();
        }
        activeGuid = instance.guid;
      };
      this.unlisten = function () {
        if (this.isListening()) {
          activeGuid = null;
        }
      };
      this.isListening = function () {
        return activeGuid === instance.guid;
      };
      this.destroyEditor = function (revertOriginal) {
        selection.refreshBorders(revertOriginal);
      };
      this.populateFromArray = function (row, col, input, endRow, endCol, source, method, direction, deltas) {
        var c;
        if (!((typeof input === 'undefined' ? 'undefined' : _typeof(input)) === 'object' && _typeof(input[0]) === 'object')) {
          throw new Error('populateFromArray parameter `input` must be an array of arrays');
        }
        c = typeof endRow === 'number' ? new _src.CellCoords(endRow, endCol) : null;
        return grid.populateFromArray(new _src.CellCoords(row, col), input, c, source, method, direction, deltas);
      };
      this.spliceCol = function (col, index, amount) {
        var _datamap;
        return (_datamap = datamap).spliceCol.apply(_datamap, arguments);
      };
      this.spliceRow = function (row, index, amount) {
        var _datamap2;
        return (_datamap2 = datamap).spliceRow.apply(_datamap2, arguments);
      };
      this.getSelected = function () {
        if (selection.isSelected()) {
          return [priv.selRange.from.row, priv.selRange.from.col, priv.selRange.to.row, priv.selRange.to.col];
        }
      };
      this.getSelectedRange = function () {
        if (selection.isSelected()) {
          return priv.selRange;
        }
      };
      this.render = function () {
        if (instance.view) {
          instance.renderCall = true;
          instance.forceFullRender = true;
          selection.refreshBorders(null, true);
        }
      };
      this.loadData = function (data) {
        if (Array.isArray(priv.settings.dataSchema)) {
          instance.dataType = 'array';
        } else if ((0, _function.isFunction)(priv.settings.dataSchema)) {
          instance.dataType = 'function';
        } else {
          instance.dataType = 'object';
        }
        if (datamap) {
          datamap.destroy();
        }
        datamap = new _dataMap2.default(instance, priv, GridSettings);
        if ((typeof data === 'undefined' ? 'undefined' : _typeof(data)) === 'object' && data !== null) {
          if (!(data.push && data.splice)) {
            data = [data];
          }
        } else if (data === null) {
          data = [];
          var row;
          var r = 0;
          var rlen = 0;
          var dataSchema = datamap.getSchema();
          for (r = 0, rlen = priv.settings.startRows; r < rlen; r++) {
            if ((instance.dataType === 'object' || instance.dataType === 'function') && priv.settings.dataSchema) {
              row = (0, _object.deepClone)(dataSchema);
              data.push(row);
            } else if (instance.dataType === 'array') {
              row = (0, _object.deepClone)(dataSchema[0]);
              data.push(row);
            } else {
              row = [];
              for (var c = 0, clen = priv.settings.startCols; c < clen; c++) {
                row.push(null);
              }
              data.push(row);
            }
          }
        } else {
          throw new Error('loadData only accepts array of objects or array of arrays (' + (typeof data === 'undefined' ? 'undefined' : _typeof(data)) + ' given)');
        }
        priv.isPopulated = false;
        GridSettings.prototype.data = data;
        if (Array.isArray(data[0])) {
          instance.dataType = 'array';
        }
        datamap.dataSource = data;
        dataSource.data = data;
        dataSource.dataType = instance.dataType;
        dataSource.colToProp = datamap.colToProp.bind(datamap);
        dataSource.propToCol = datamap.propToCol.bind(datamap);
        clearCellSettingCache();
        grid.adjustRowsAndCols();
        instance.runHooks('afterLoadData', priv.firstRun);
        if (priv.firstRun) {
          priv.firstRun = [null, 'loadData'];
        } else {
          instance.runHooks('afterChange', null, 'loadData');
          instance.render();
        }
        priv.isPopulated = true;

        function clearCellSettingCache() {
          priv.cellSettings.length = 0;
        }
      };
      this.getData = function (r, c, r2, c2) {
        if ((0, _mixed.isUndefined)(r)) {
          return datamap.getAll();
        }
        return datamap.getRange(new _src.CellCoords(r, c), new _src.CellCoords(r2, c2), datamap.DESTINATION_RENDERER);
      };
      this.getCopyableText = function (startRow, startCol, endRow, endCol) {
        return datamap.getCopyableText(new _src.CellCoords(startRow, startCol), new _src.CellCoords(endRow, endCol));
      };
      this.getCopyableData = function (row, column) {
        return datamap.getCopyable(row, datamap.colToProp(column));
      };
      this.getSchema = function () {
        return datamap.getSchema();
      };
      this.updateSettings = function (settings, init) {
        var columnsAsFunc = false;
        var i = void 0;
        var j = void 0;
        var clen = void 0;
        if ((0, _mixed.isDefined)(settings.rows)) {
          throw new Error('"rows" setting is no longer supported. do you mean startRows, minRows or maxRows?');
        }
        if ((0, _mixed.isDefined)(settings.cols)) {
          throw new Error('"cols" setting is no longer supported. do you mean startCols, minCols or maxCols?');
        }
        for (i in settings) {
          if (i === 'data') {
            continue;
          } else if (_pluginHooks2.default.getSingleton().getRegistered().indexOf(i) > -1) {
            if ((0, _function.isFunction)(settings[i]) || Array.isArray(settings[i])) {
              settings[i].initialHook = true;
              instance.addHook(i, settings[i]);
            }
          } else if (!init && (0, _object.hasOwnProperty)(settings, i)) {
            GridSettings.prototype[i] = settings[i];
          }
        }
        if (settings.data === void 0 && priv.settings.data === void 0) {
          instance.loadData(null);
        } else if (settings.data !== void 0) {
          instance.loadData(settings.data);
        } else if (settings.columns !== void 0) {
          datamap.createMap();
        }
        clen = instance.countCols();
        var columnSetting = settings.columns || GridSettings.prototype.columns;
        if (columnSetting && (0, _function.isFunction)(columnSetting)) {
          clen = instance.countSourceCols();
          columnsAsFunc = true;
        }
        if (settings.cell !== void 0 || settings.cells !== void 0 || settings.columns !== void 0) {
          priv.cellSettings.length = 0;
        }
        if (clen > 0) {
          var proto = void 0;
          var column = void 0;
          for (i = 0, j = 0; i < clen; i++) {
            if (columnsAsFunc && !columnSetting(i)) {
              continue;
            }
            priv.columnSettings[j] = (0, _setting.columnFactory)(GridSettings, priv.columnsSettingConflicts);
            proto = priv.columnSettings[j].prototype;
            if (columnSetting) {
              if (columnsAsFunc) {
                column = columnSetting(i);
              } else {
                column = columnSetting[j];
              }
              if (column) {
                (0, _object.extend)(proto, column);
                (0, _object.extend)(proto, expandType(column));
              }
            }
            j++;
          }
        }
        if ((0, _mixed.isDefined)(settings.cell)) {
          for (var key in settings.cell) {
            if ((0, _object.hasOwnProperty)(settings.cell, key)) {
              var cell = settings.cell[key];
              instance.setCellMetaObject(cell.row, cell.col, cell);
            }
          }
        }
        instance.runHooks('afterCellMetaReset');
        if ((0, _mixed.isDefined)(settings.className)) {
          if (GridSettings.prototype.className) {
            (0, _element.removeClass)(instance.rootElement, GridSettings.prototype.className);
          }
          if (settings.className) {
            (0, _element.addClass)(instance.rootElement, settings.className);
          }
        }
        var currentHeight = instance.rootElement.style.height;
        if (currentHeight !== '') {
          currentHeight = parseInt(instance.rootElement.style.height, 10);
        }
        var height = settings.height;
        if ((0, _function.isFunction)(height)) {
          height = height();
        }
        if (init) {
          var initialStyle = instance.rootElement.getAttribute('style');
          if (initialStyle) {
            instance.rootElement.setAttribute('data-initialstyle', instance.rootElement.getAttribute('style'));
          }
        }
        if (height === null) {
          var _initialStyle = instance.rootElement.getAttribute('data-initialstyle');
          if (_initialStyle && (_initialStyle.indexOf('height') > -1 || _initialStyle.indexOf('overflow') > -1)) {
            instance.rootElement.setAttribute('style', _initialStyle);
          } else {
            instance.rootElement.style.height = '';
            instance.rootElement.style.overflow = '';
          }
        } else if (height !== void 0) {
          instance.rootElement.style.height = height + 'px';
          instance.rootElement.style.overflow = 'hidden';
        }
        if (typeof settings.width !== 'undefined') {
          var width = settings.width;
          if ((0, _function.isFunction)(width)) {
            width = width();
          }
          instance.rootElement.style.width = width + 'px';
        }
        if (!init) {
          datamap.clearLengthCache();
          if (instance.view) {
            instance.view.wt.wtViewport.resetHasOversizedColumnHeadersMarked();
          }
          instance.runHooks('afterUpdateSettings', settings);
        }
        grid.adjustRowsAndCols();
        if (instance.view && !priv.firstRun) {
          instance.forceFullRender = true;
          selection.refreshBorders(null, true);
        }
        if (!init && instance.view && (currentHeight === '' || height === '' || height === void 0) && currentHeight !== height) {
          instance.view.wt.wtOverlays.updateMainScrollableElements();
        }
      };
      this.getValue = function () {
        var sel = instance.getSelected();
        if (GridSettings.prototype.getValue) {
          if ((0, _function.isFunction)(GridSettings.prototype.getValue)) {
            return GridSettings.prototype.getValue.call(instance);
          } else if (sel) {
            return instance.getData()[sel[0]][GridSettings.prototype.getValue];
          }
        } else if (sel) {
          return instance.getDataAtCell(sel[0], sel[1]);
        }
      };

      function expandType(obj) {
        if (!(0, _object.hasOwnProperty)(obj, 'type')) {
          return;
        }
        var type, expandedType = {};
        if (_typeof(obj.type) === 'object') {
          type = obj.type;
        } else if (typeof obj.type === 'string') {
          type = (0, _cellTypes.getCellType)(obj.type);
        }
        for (var i in type) {
          if ((0, _object.hasOwnProperty)(type, i) && !(0, _object.hasOwnProperty)(obj, i)) {
            expandedType[i] = type[i];
          }
        }
        return expandedType;
      }
      this.getSettings = function () {
        return priv.settings;
      };
      this.clear = function () {
        selection.selectAll();
        selection.empty();
      };
      this.alter = function (action, index, amount, source, keepEmptyRows) {
        grid.alter(action, index, amount, source, keepEmptyRows);
      };
      this.getCell = function (row, col, topmost) {
        return instance.view.getCellAtCoords(new _src.CellCoords(row, col), topmost);
      };
      this.getCoords = function (elem) {
        return this.view.wt.wtTable.getCoords.call(this.view.wt.wtTable, elem);
      };
      this.colToProp = function (col) {
        return datamap.colToProp(col);
      };
      this.propToCol = function (prop) {
        return datamap.propToCol(prop);
      };
      this.toVisualRow = function (row) {
        return recordTranslator.toVisualRow(row);
      };
      this.toVisualColumn = function (column) {
        return recordTranslator.toVisualColumn(column);
      };
      this.toPhysicalRow = function (row) {
        return recordTranslator.toPhysicalRow(row);
      };
      this.toPhysicalColumn = function (column) {
        return recordTranslator.toPhysicalColumn(column);
      };
      this.getDataAtCell = function (row, col) {
        return datamap.get(row, datamap.colToProp(col));
      };
      this.getDataAtRowProp = function (row, prop) {
        return datamap.get(row, prop);
      };
      this.getDataAtCol = function (col) {
        var out = [];
        return out.concat.apply(out, _toConsumableArray(datamap.getRange(new _src.CellCoords(0, col), new _src.CellCoords(priv.settings.data.length - 1, col), datamap.DESTINATION_RENDERER)));
      };
      this.getDataAtProp = function (prop) {
        var out = [],
          range;
        range = datamap.getRange(new _src.CellCoords(0, datamap.propToCol(prop)), new _src.CellCoords(priv.settings.data.length - 1, datamap.propToCol(prop)), datamap.DESTINATION_RENDERER);
        return out.concat.apply(out, _toConsumableArray(range));
      };
      this.getSourceData = function (r, c, r2, c2) {
        var data = void 0;
        if (r === void 0) {
          data = dataSource.getData();
        } else {
          data = dataSource.getByRange(new _src.CellCoords(r, c), new _src.CellCoords(r2, c2));
        }
        return data;
      };
      this.getSourceDataArray = function (r, c, r2, c2) {
        var data = void 0;
        if (r === void 0) {
          data = dataSource.getData(true);
        } else {
          data = dataSource.getByRange(new _src.CellCoords(r, c), new _src.CellCoords(r2, c2), true);
        }
        return data;
      };
      this.getSourceDataAtCol = function (column) {
        return dataSource.getAtColumn(column);
      };
      this.getSourceDataAtRow = function (row) {
        return dataSource.getAtRow(row);
      };
      this.getSourceDataAtCell = function (row, column) {
        return dataSource.getAtCell(row, column);
      };
      this.getDataAtRow = function (row) {
        var data = datamap.getRange(new _src.CellCoords(row, 0), new _src.CellCoords(row, this.countCols() - 1), datamap.DESTINATION_RENDERER);
        return data[0] || [];
      };
      this.getDataType = function (rowFrom, columnFrom, rowTo, columnTo) {
        var _this = this;
        var previousType = null;
        var currentType = null;
        if (rowFrom === void 0) {
          rowFrom = 0;
          rowTo = this.countRows();
          columnFrom = 0;
          columnTo = this.countCols();
        }
        if (rowTo === void 0) {
          rowTo = rowFrom;
        }
        if (columnTo === void 0) {
          columnTo = columnFrom;
        }
        var type = 'mixed';
        (0, _number.rangeEach)(Math.min(rowFrom, rowTo), Math.max(rowFrom, rowTo), function (row) {
          var isTypeEqual = true;
          (0, _number.rangeEach)(Math.min(columnFrom, columnTo), Math.max(columnFrom, columnTo), function (column) {
            var cellType = _this.getCellMeta(row, column);
            currentType = cellType.type;
            if (previousType) {
              isTypeEqual = previousType === currentType;
            } else {
              previousType = currentType;
            }
            return isTypeEqual;
          });
          type = isTypeEqual ? currentType : 'mixed';
          return isTypeEqual;
        });
        return type;
      };
      this.removeCellMeta = function (row, col, key) {
        var _recordTranslator$toP = recordTranslator.toPhysical(row, col),
          _recordTranslator$toP2 = _slicedToArray(_recordTranslator$toP, 2),
          physicalRow = _recordTranslator$toP2[0],
          physicalColumn = _recordTranslator$toP2[1];
        var cachedValue = priv.cellSettings[physicalRow][physicalColumn][key];
        var hookResult = instance.runHooks('beforeRemoveCellMeta', row, col, key, cachedValue);
        if (hookResult !== false) {
          delete priv.cellSettings[physicalRow][physicalColumn][key];
          instance.runHooks('afterRemoveCellMeta', row, col, key, cachedValue);
        }
        cachedValue = null;
      };
      this.spliceCellsMeta = function (index, deleteAmount) {
        var _priv$cellSettings;
        for (var _len2 = arguments.length, items = Array(_len2 > 2 ? _len2 - 2 : 0), _key = 2; _key < _len2; _key++) {
          items[_key - 2] = arguments[_key];
        } (_priv$cellSettings = priv.cellSettings).splice.apply(_priv$cellSettings, [index, deleteAmount].concat(items));
      };
      this.setCellMetaObject = function (row, col, prop) {
        if ((typeof prop === 'undefined' ? 'undefined' : _typeof(prop)) === 'object') {
          for (var key in prop) {
            if ((0, _object.hasOwnProperty)(prop, key)) {
              var value = prop[key];
              this.setCellMeta(row, col, key, value);
            }
          }
        }
      };
      this.setCellMeta = function (row, col, key, val) {
        var _recordTranslator$toP3 = recordTranslator.toPhysical(row, col),
          _recordTranslator$toP4 = _slicedToArray(_recordTranslator$toP3, 2),
          physicalRow = _recordTranslator$toP4[0],
          physicalColumn = _recordTranslator$toP4[1];
        if (!priv.columnSettings[physicalColumn]) {
          priv.columnSettings[physicalColumn] = (0, _setting.columnFactory)(GridSettings, priv.columnsSettingConflicts);
        }
        if (!priv.cellSettings[physicalRow]) {
          priv.cellSettings[physicalRow] = [];
        }
        if (!priv.cellSettings[physicalRow][physicalColumn]) {
          priv.cellSettings[physicalRow][physicalColumn] = new priv.columnSettings[physicalColumn]();
        }
        priv.cellSettings[physicalRow][physicalColumn][key] = val;
        instance.runHooks('afterSetCellMeta', row, col, key, val);
      };
      this.getCellsMeta = function () {
        return (0, _array.arrayFlatten)(priv.cellSettings);
      };
      this.getCellMeta = function (row, col) {
        var prop = datamap.colToProp(col);
        var cellProperties = void 0;
        var _recordTranslator$toP5 = recordTranslator.toPhysical(row, col),
          _recordTranslator$toP6 = _slicedToArray(_recordTranslator$toP5, 2),
          physicalRow = _recordTranslator$toP6[0],
          physicalColumn = _recordTranslator$toP6[1];
        if (!priv.columnSettings[physicalColumn]) {
          priv.columnSettings[physicalColumn] = (0, _setting.columnFactory)(GridSettings, priv.columnsSettingConflicts);
        }
        if (!priv.cellSettings[physicalRow]) {
          priv.cellSettings[physicalRow] = [];
        }
        if (!priv.cellSettings[physicalRow][physicalColumn]) {
          priv.cellSettings[physicalRow][physicalColumn] = new priv.columnSettings[physicalColumn]();
        }
        cellProperties = priv.cellSettings[physicalRow][physicalColumn];
        cellProperties.row = physicalRow;
        cellProperties.col = physicalColumn;
        cellProperties.visualRow = row;
        cellProperties.visualCol = col;
        cellProperties.prop = prop;
        cellProperties.instance = instance;
        instance.runHooks('beforeGetCellMeta', row, col, cellProperties);
        (0, _object.extend)(cellProperties, expandType(cellProperties));
        if (cellProperties.cells) {
          var settings = cellProperties.cells.call(cellProperties, physicalRow, physicalColumn, prop);
          if (settings) {
            (0, _object.extend)(cellProperties, settings);
            (0, _object.extend)(cellProperties, expandType(settings));
          }
        }
        instance.runHooks('afterGetCellMeta', row, col, cellProperties);
        return cellProperties;
      };
      this.getCellMetaAtRow = function (row) {
        return priv.cellSettings[row];
      };
      this.isColumnModificationAllowed = function () {
        return !(instance.dataType === 'object' || instance.getSettings().columns);
      };
      var rendererLookup = (0, _data.cellMethodLookupFactory)('renderer');
      this.getCellRenderer = function (row, col) {
        return (0, _renderers.getRenderer)(rendererLookup.call(this, row, col));
      };
      this.getCellEditor = (0, _data.cellMethodLookupFactory)('editor');
      var validatorLookup = (0, _data.cellMethodLookupFactory)('validator');
      this.getCellValidator = function (row, col) {
        var validator = validatorLookup.call(this, row, col);
        if (typeof validator === 'string') {
          validator = (0, _validators.getValidator)(validator);
        }
        return validator;
      };
      this.validateCells = function (callback) {
        var waitingForValidator = new ValidatorsQueue();
        if (callback) {
          waitingForValidator.onQueueEmpty = callback;
        }
        var i = instance.countRows() - 1;
        while (i >= 0) {
          var j = instance.countCols() - 1;
          while (j >= 0) {
            waitingForValidator.addValidatorToQueue();
            instance.validateCell(instance.getDataAtCell(i, j), instance.getCellMeta(i, j), function (result) {
              if (typeof result !== 'boolean') {
                throw new Error('Validation error: result is not boolean');
              }
              if (result === false) {
                waitingForValidator.valid = false;
              }
              waitingForValidator.removeValidatorFormQueue();
            }, 'validateCells');
            j--;
          }
          i--;
        }
        waitingForValidator.checkIfQueueIsEmpty();
      };
      this.getRowHeader = function (row) {
        var rowHeader = priv.settings.rowHeaders;
        if (row !== void 0) {
          row = instance.runHooks('modifyRowHeader', row);
        }
        if (row === void 0) {
          rowHeader = [];
          (0, _number.rangeEach)(instance.countRows() - 1, function (i) {
            rowHeader.push(instance.getRowHeader(i));
          });
        } else if (Array.isArray(rowHeader) && rowHeader[row] !== void 0) {
          rowHeader = rowHeader[row];
        } else if ((0, _function.isFunction)(rowHeader)) {
          rowHeader = rowHeader(row);
        } else if (rowHeader && typeof rowHeader !== 'string' && typeof rowHeader !== 'number') {
          rowHeader = row + 1;
        }
        return rowHeader;
      };
      this.hasRowHeaders = function () {
        return !!priv.settings.rowHeaders;
      };
      this.hasColHeaders = function () {
        if (priv.settings.colHeaders !== void 0 && priv.settings.colHeaders !== null) {
          return !!priv.settings.colHeaders;
        }
        for (var i = 0, ilen = instance.countCols(); i < ilen; i++) {
          if (instance.getColHeader(i)) {
            return true;
          }
        }
        return false;
      };
      this.getColHeader = function (col) {
        var columnsAsFunc = priv.settings.columns && (0, _function.isFunction)(priv.settings.columns);
        var result = priv.settings.colHeaders;
        col = instance.runHooks('modifyColHeader', col);
        if (col === void 0) {
          var out = [];
          var ilen = columnsAsFunc ? instance.countSourceCols() : instance.countCols();
          for (var i = 0; i < ilen; i++) {
            out.push(instance.getColHeader(i));
          }
          result = out;
        } else {
          var translateVisualIndexToColumns = function translateVisualIndexToColumns(col) {
            var arr = [];
            var columnsLen = instance.countSourceCols();
            var index = 0;
            for (; index < columnsLen; index++) {
              if ((0, _function.isFunction)(instance.getSettings().columns) && instance.getSettings().columns(index)) {
                arr.push(index);
              }
            }
            return arr[col];
          };
          var baseCol = col;
          col = instance.runHooks('modifyCol', col);
          var prop = translateVisualIndexToColumns(col);
          if (priv.settings.columns && (0, _function.isFunction)(priv.settings.columns) && priv.settings.columns(prop) && priv.settings.columns(prop).title) {
            result = priv.settings.columns(prop).title;
          } else if (priv.settings.columns && priv.settings.columns[col] && priv.settings.columns[col].title) {
            result = priv.settings.columns[col].title;
          } else if (Array.isArray(priv.settings.colHeaders) && priv.settings.colHeaders[col] !== void 0) {
            result = priv.settings.colHeaders[col];
          } else if ((0, _function.isFunction)(priv.settings.colHeaders)) {
            result = priv.settings.colHeaders(col);
          } else if (priv.settings.colHeaders && typeof priv.settings.colHeaders !== 'string' && typeof priv.settings.colHeaders !== 'number') {
            result = (0, _data.spreadsheetColumnLabel)(baseCol);
          }
        }
        return result;
      };
      this._getColWidthFromSettings = function (col) {
        var cellProperties = instance.getCellMeta(0, col);
        var width = cellProperties.width;
        if (width === void 0 || width === priv.settings.width) {
          width = cellProperties.colWidths;
        }
        if (width !== void 0 && width !== null) {
          switch (typeof width === 'undefined' ? 'undefined' : _typeof(width)) {
            case 'object':
              width = width[col];
              break;
            case 'function':
              width = width(col);
              break;
            default:
              break;
          }
          if (typeof width === 'string') {
            width = parseInt(width, 10);
          }
        }
        return width;
      };
      this.getColWidth = function (col) {
        var width = instance._getColWidthFromSettings(col);
        width = instance.runHooks('modifyColWidth', width, col);
        if (width === void 0) {
          width = _src.ViewportColumnsCalculator.DEFAULT_WIDTH;
        }
        return width;
      };
      this._getRowHeightFromSettings = function (row) {
        var height = priv.settings.rowHeights;
        if (height !== void 0 && height !== null) {
          switch (typeof height === 'undefined' ? 'undefined' : _typeof(height)) {
            case 'object':
              height = height[row];
              break;
            case 'function':
              height = height(row);
              break;
            default:
              break;
          }
          if (typeof height === 'string') {
            height = parseInt(height, 10);
          }
        }
        return height;
      };
      this.getRowHeight = function (row) {
        var height = instance._getRowHeightFromSettings(row);
        height = instance.runHooks('modifyRowHeight', height, row);
        return height;
      };
      this.countSourceRows = function () {
        var sourceLength = instance.runHooks('modifySourceLength');
        return sourceLength || (instance.getSourceData() ? instance.getSourceData().length : 0);
      };
      this.countSourceCols = function () {
        var len = 0;
        var obj = instance.getSourceData() && instance.getSourceData()[0] ? instance.getSourceData()[0] : [];
        if ((0, _object.isObject)(obj)) {
          len = (0, _object.deepObjectSize)(obj);
        } else {
          len = obj.length || 0;
        }
        return len;
      };
      this.countRows = function () {
        return datamap.getLength();
      };
      this.countCols = function () {
        var maxCols = this.getSettings().maxCols;
        var dataHasLength = false;
        var dataLen = 0;
        if (instance.dataType === 'array') {
          dataHasLength = priv.settings.data && priv.settings.data[0] && priv.settings.data[0].length;
        }
        if (dataHasLength) {
          dataLen = priv.settings.data[0].length;
        }
        if (priv.settings.columns) {
          var columnsIsFunction = (0, _function.isFunction)(priv.settings.columns);
          if (columnsIsFunction) {
            if (instance.dataType === 'array') {
              var columnLen = 0;
              for (var i = 0; i < dataLen; i++) {
                if (priv.settings.columns(i)) {
                  columnLen++;
                }
              }
              dataLen = columnLen;
            } else if (instance.dataType === 'object' || instance.dataType === 'function') {
              dataLen = datamap.colToPropCache.length;
            }
          } else {
            dataLen = priv.settings.columns.length;
          }
        } else if (instance.dataType === 'object' || instance.dataType === 'function') {
          dataLen = datamap.colToPropCache.length;
        }
        return Math.min(maxCols, dataLen);
      };
      this.rowOffset = function () {
        return instance.view.wt.wtTable.getFirstRenderedRow();
      };
      this.colOffset = function () {
        return instance.view.wt.wtTable.getFirstRenderedColumn();
      };
      this.countRenderedRows = function () {
        return instance.view.wt.drawn ? instance.view.wt.wtTable.getRenderedRowsCount() : -1;
      };
      this.countVisibleRows = function () {
        return instance.view.wt.drawn ? instance.view.wt.wtTable.getVisibleRowsCount() : -1;
      };
      this.countRenderedCols = function () {
        return instance.view.wt.drawn ? instance.view.wt.wtTable.getRenderedColumnsCount() : -1;
      };
      this.countVisibleCols = function () {
        return instance.view.wt.drawn ? instance.view.wt.wtTable.getVisibleColumnsCount() : -1;
      };
      this.countEmptyRows = function (ending) {
        var i = instance.countRows() - 1,
          empty = 0,
          row;
        while (i >= 0) {
          row = instance.runHooks('modifyRow', i);
          if (instance.isEmptyRow(row)) {
            empty++;
          } else if (ending) {
            break;
          }
          i--;
        }
        return empty;
      };
      this.countEmptyCols = function (ending) {
        if (instance.countRows() < 1) {
          return 0;
        }
        var i = instance.countCols() - 1,
          empty = 0;
        while (i >= 0) {
          if (instance.isEmptyCol(i)) {
            empty++;
          } else if (ending) {
            break;
          }
          i--;
        }
        return empty;
      };
      this.isEmptyRow = function (row) {
        return priv.settings.isEmptyRow.call(instance, row);
      };
      this.isEmptyCol = function (col) {
        return priv.settings.isEmptyCol.call(instance, col);
      };
      this.selectCell = function (row, col, endRow, endCol, scrollToCell, changeListener) {
        var coords;
        changeListener = (0, _mixed.isUndefined)(changeListener) || changeListener === true;
        if (typeof row !== 'number' || row < 0 || row >= instance.countRows()) {
          return false;
        }
        if (typeof col !== 'number' || col < 0 || col >= instance.countCols()) {
          return false;
        }
        if ((0, _mixed.isDefined)(endRow)) {
          if (typeof endRow !== 'number' || endRow < 0 || endRow >= instance.countRows()) {
            return false;
          }
          if (typeof endCol !== 'number' || endCol < 0 || endCol >= instance.countCols()) {
            return false;
          }
        }
        coords = new _src.CellCoords(row, col);
        priv.selRange = new _src.CellRange(coords, coords, coords);
        if (changeListener) {
          instance.listen();
        }
        if ((0, _mixed.isUndefined)(endRow)) {
          selection.setRangeEnd(priv.selRange.from, scrollToCell);
        } else {
          selection.setRangeEnd(new _src.CellCoords(endRow, endCol), scrollToCell);
        }
        instance.selection.finish();
        return true;
      };
      this.selectCellByProp = function (row, prop, endRow, endProp, scrollToCell) {
        var _instance5;
        arguments[1] = datamap.propToCol(arguments[1]);
        if ((0, _mixed.isDefined)(arguments[3])) {
          arguments[3] = datamap.propToCol(arguments[3]);
        }
        return (_instance5 = instance).selectCell.apply(_instance5, arguments);
      };
      this.deselectCell = function () {
        selection.deselect();
      };
      this.scrollViewportTo = function (row, column) {
        var snapToBottom = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
        var snapToRight = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
        if (row !== void 0 && (row < 0 || row >= instance.countRows())) {
          return false;
        }
        if (column !== void 0 && (column < 0 || column >= instance.countCols())) {
          return false;
        }
        var result = false;
        if (row !== void 0 && column !== void 0) {
          instance.view.wt.wtOverlays.topOverlay.scrollTo(row, snapToBottom);
          instance.view.wt.wtOverlays.leftOverlay.scrollTo(column, snapToRight);
          result = true;
        }
        if (typeof row === 'number' && typeof column !== 'number') {
          instance.view.wt.wtOverlays.topOverlay.scrollTo(row, snapToBottom);
          result = true;
        }
        if (typeof column === 'number' && typeof row !== 'number') {
          instance.view.wt.wtOverlays.leftOverlay.scrollTo(column, snapToRight);
          result = true;
        }
        return result;
      };
      this.destroy = function () {
        instance._clearTimeouts();
        if (instance.view) {
          instance.view.destroy();
        }
        if (dataSource) {
          dataSource.destroy();
        }
        dataSource = null;
        var nextSibling = instance.rootElement.nextSibling;
        if ((0, _rootInstance.isRootInstance)(instance) && nextSibling) {
          instance.rootElement.parentNode.removeChild(nextSibling);
        } (0, _element.empty)(instance.rootElement);
        eventManager.destroy();
        instance.runHooks('afterDestroy');
        _pluginHooks2.default.getSingleton().destroy(instance);
        for (var i in instance) {
          if ((0, _object.hasOwnProperty)(instance, i)) {
            if ((0, _function.isFunction)(instance[i])) {
              instance[i] = postMortem;
            } else if (i !== 'guid') {
              instance[i] = null;
            }
          }
        }
        if (datamap) {
          datamap.destroy();
        }
        datamap = null;
        priv = null;
        grid = null;
        selection = null;
        editorManager = null;
        instance = null;
        GridSettings = null;
      };

      function postMortem() {
        throw new Error('This method cannot be called because this Handsontable instance has been destroyed');
      }
      this.getActiveEditor = function () {
        return editorManager.getActiveEditor();
      };
      this.getPlugin = function (pluginName) {
        return (0, _plugins.getPlugin)(this, pluginName);
      };
      this.getInstance = function () {
        return instance;
      };
      this.addHook = function (key, callback) {
        _pluginHooks2.default.getSingleton().add(key, callback, instance);
      };
      this.hasHook = function (key) {
        return _pluginHooks2.default.getSingleton().has(key, instance);
      };
      this.addHookOnce = function (key, callback) {
        _pluginHooks2.default.getSingleton().once(key, callback, instance);
      };
      this.removeHook = function (key, callback) {
        _pluginHooks2.default.getSingleton().remove(key, callback, instance);
      };
      this.runHooks = function (key, p1, p2, p3, p4, p5, p6) {
        return _pluginHooks2.default.getSingleton().run(instance, key, p1, p2, p3, p4, p5, p6);
      };
      this.timeouts = [];
      this._registerTimeout = function (handle) {
        this.timeouts.push(handle);
      };
      this._clearTimeouts = function () {
        for (var i = 0, ilen = this.timeouts.length; i < ilen; i++) {
          clearTimeout(this.timeouts[i]);
        }
      };
      _pluginHooks2.default.getSingleton().run(instance, 'construct');
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.spreadsheetColumnLabel = spreadsheetColumnLabel;
    exports.spreadsheetColumnIndex = spreadsheetColumnIndex;
    exports.createSpreadsheetData = createSpreadsheetData;
    exports.createSpreadsheetObjectData = createSpreadsheetObjectData;
    exports.createEmptySpreadsheetData = createEmptySpreadsheetData;
    exports.translateRowsToColumns = translateRowsToColumns;
    exports.cellMethodLookupFactory = cellMethodLookupFactory;
    var _cellTypes = __webpack_require__(65);
    var _object = __webpack_require__(3);
    var COLUMN_LABEL_BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
    var COLUMN_LABEL_BASE_LENGTH = COLUMN_LABEL_BASE.length;

    function spreadsheetColumnLabel(index) {
      var dividend = index + 1;
      var columnLabel = '';
      var modulo = void 0;
      while (dividend > 0) {
        modulo = (dividend - 1) % COLUMN_LABEL_BASE_LENGTH;
        columnLabel = String.fromCharCode(65 + modulo) + columnLabel;
        dividend = parseInt((dividend - modulo) / COLUMN_LABEL_BASE_LENGTH, 10);
      }
      return columnLabel;
    }

    function spreadsheetColumnIndex(label) {
      var result = 0;
      if (label) {
        for (var i = 0, j = label.length - 1; i < label.length; i += 1, j -= 1) {
          result += Math.pow(COLUMN_LABEL_BASE_LENGTH, j) * (COLUMN_LABEL_BASE.indexOf(label[i]) + 1);
        }
      } --result;
      return result;
    }

    function createSpreadsheetData() {
      var rows = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 100;
      var columns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 4;
      var _rows = [],
        i, j;
      for (i = 0; i < rows; i++) {
        var row = [];
        for (j = 0; j < columns; j++) {
          row.push(spreadsheetColumnLabel(j) + (i + 1));
        }
        _rows.push(row);
      }
      return _rows;
    }

    function createSpreadsheetObjectData() {
      var rows = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 100;
      var colCount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 4;
      var _rows = [],
        i, j;
      for (i = 0; i < rows; i++) {
        var row = {};
        for (j = 0; j < colCount; j++) {
          row['prop' + j] = spreadsheetColumnLabel(j) + (i + 1);
        }
        _rows.push(row);
      }
      return _rows;
    }

    function createEmptySpreadsheetData(rows, columns) {
      var data = [];
      var row = void 0;
      for (var i = 0; i < rows; i++) {
        row = [];
        for (var j = 0; j < columns; j++) {
          row.push('');
        }
        data.push(row);
      }
      return data;
    }

    function translateRowsToColumns(input) {
      var i, ilen, j, jlen, output = [],
        olen = 0;
      for (i = 0, ilen = input.length; i < ilen; i++) {
        for (j = 0, jlen = input[i].length; j < jlen; j++) {
          if (j == olen) {
            output.push([]);
            olen++;
          }
          output[j].push(input[i][j]);
        }
      }
      return output;
    }

    function cellMethodLookupFactory(methodName, allowUndefined) {
      allowUndefined = typeof allowUndefined == 'undefined' ? true : allowUndefined;
      return function cellMethodLookup(row, col) {
        return function getMethodFromProperties(properties) {
          if (!properties) {
            return;
          } else if ((0, _object.hasOwnProperty)(properties, methodName) && properties[methodName] !== void 0) {
            return properties[methodName];
          } else if ((0, _object.hasOwnProperty)(properties, 'type') && properties.type) {
            var type;
            if (typeof properties.type != 'string') {
              throw new Error('Cell type must be a string ');
            }
            type = (0, _cellTypes.getCellType)(properties.type);
            if ((0, _object.hasOwnProperty)(type, methodName)) {
              return type[methodName];
            } else if (allowUndefined) {
              return;
            }
          }
          return getMethodFromProperties(Object.getPrototypeOf(properties));
        }(typeof row == 'number' ? this.getCellMeta(row, col) : row);
      };
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.columnFactory = columnFactory;
    var _object = __webpack_require__(3);

    function columnFactory(GridSettings, conflictList) {
      function ColumnSettings() { };
      (0, _object.inherit)(ColumnSettings, GridSettings);
      for (var i = 0, len = conflictList.length; i < len; i++) {
        ColumnSettings.prototype[conflictList[i]] = void 0;
      }
      return ColumnSettings;
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _element = __webpack_require__(0);
    var _array = __webpack_require__(2);

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var GhostTable = function () {
      function GhostTable(hotInstance) {
        _classCallCheck(this, GhostTable);
        this.hot = hotInstance;
        this.container = null;
        this.injected = false;
        this.rows = [];
        this.columns = [];
        this.samples = null;
        this.settings = {
          useHeaders: true
        };
      }
      _createClass(GhostTable, [{
        key: 'addRow',
        value: function addRow(row, samples) {
          if (this.columns.length) {
            throw new Error('Doesn\'t support multi-dimensional table');
          }
          if (!this.rows.length) {
            this.container = this.createContainer(this.hot.rootElement.className);
          }
          var rowObject = {
            row: row
          };
          this.rows.push(rowObject);
          this.samples = samples;
          this.table = this.createTable(this.hot.table.className);
          this.table.colGroup.appendChild(this.createColGroupsCol());
          this.table.tr.appendChild(this.createRow(row));
          this.container.container.appendChild(this.table.fragment);
          rowObject.table = this.table.table;
        }
      }, {
        key: 'addColumnHeadersRow',
        value: function addColumnHeadersRow(samples) {
          if (this.hot.getColHeader(0) != null) {
            var rowObject = {
              row: -1
            };
            this.rows.push(rowObject);
            this.container = this.createContainer(this.hot.rootElement.className);
            this.samples = samples;
            this.table = this.createTable(this.hot.table.className);
            this.table.colGroup.appendChild(this.createColGroupsCol());
            this.table.tHead.appendChild(this.createColumnHeadersRow());
            this.container.container.appendChild(this.table.fragment);
            rowObject.table = this.table.table;
          }
        }
      }, {
        key: 'addColumn',
        value: function addColumn(column, samples) {
          if (this.rows.length) {
            throw new Error('Doesn\'t support multi-dimensional table');
          }
          if (!this.columns.length) {
            this.container = this.createContainer(this.hot.rootElement.className);
          }
          var columnObject = {
            col: column
          };
          this.columns.push(columnObject);
          this.samples = samples;
          this.table = this.createTable(this.hot.table.className);
          if (this.getSetting('useHeaders') && this.hot.getColHeader(column) !== null) {
            this.hot.view.appendColHeader(column, this.table.th);
          }
          this.table.tBody.appendChild(this.createCol(column));
          this.container.container.appendChild(this.table.fragment);
          columnObject.table = this.table.table;
        }
      }, {
        key: 'getHeights',
        value: function getHeights(callback) {
          if (!this.injected) {
            this.injectTable();
          } (0, _array.arrayEach)(this.rows, function (row) {
            callback(row.row, (0, _element.outerHeight)(row.table) - 1);
          });
        }
      }, {
        key: 'getWidths',
        value: function getWidths(callback) {
          if (!this.injected) {
            this.injectTable();
          } (0, _array.arrayEach)(this.columns, function (column) {
            callback(column.col, (0, _element.outerWidth)(column.table));
          });
        }
      }, {
        key: 'setSettings',
        value: function setSettings(settings) {
          this.settings = settings;
        }
      }, {
        key: 'setSetting',
        value: function setSetting(name, value) {
          if (!this.settings) {
            this.settings = {};
          }
          this.settings[name] = value;
        }
      }, {
        key: 'getSettings',
        value: function getSettings() {
          return this.settings;
        }
      }, {
        key: 'getSetting',
        value: function getSetting(name) {
          if (this.settings) {
            return this.settings[name];
          }
          return null;
        }
      }, {
        key: 'createColGroupsCol',
        value: function createColGroupsCol() {
          var _this = this;
          var d = document;
          var fragment = d.createDocumentFragment();
          if (this.hot.hasRowHeaders()) {
            fragment.appendChild(this.createColElement(-1));
          }
          this.samples.forEach(function (sample) {
            (0, _array.arrayEach)(sample.strings, function (string) {
              fragment.appendChild(_this.createColElement(string.col));
            });
          });
          return fragment;
        }
      }, {
        key: 'createRow',
        value: function createRow(row) {
          var _this2 = this;
          var d = document;
          var fragment = d.createDocumentFragment();
          var th = d.createElement('th');
          if (this.hot.hasRowHeaders()) {
            this.hot.view.appendRowHeader(row, th);
            fragment.appendChild(th);
          }
          this.samples.forEach(function (sample) {
            (0, _array.arrayEach)(sample.strings, function (string) {
              var column = string.col;
              var cellProperties = _this2.hot.getCellMeta(row, column);
              cellProperties.col = column;
              cellProperties.row = row;
              var renderer = _this2.hot.getCellRenderer(cellProperties);
              var td = d.createElement('td');
              renderer(_this2.hot, td, row, column, _this2.hot.colToProp(column), string.value, cellProperties);
              fragment.appendChild(td);
            });
          });
          return fragment;
        }
      }, {
        key: 'createColumnHeadersRow',
        value: function createColumnHeadersRow() {
          var _this3 = this;
          var d = document;
          var fragment = d.createDocumentFragment();
          if (this.hot.hasRowHeaders()) {
            var th = d.createElement('th');
            this.hot.view.appendColHeader(-1, th);
            fragment.appendChild(th);
          }
          this.samples.forEach(function (sample) {
            (0, _array.arrayEach)(sample.strings, function (string) {
              var column = string.col;
              var th = d.createElement('th');
              _this3.hot.view.appendColHeader(column, th);
              fragment.appendChild(th);
            });
          });
          return fragment;
        }
      }, {
        key: 'createCol',
        value: function createCol(column) {
          var _this4 = this;
          var d = document;
          var fragment = d.createDocumentFragment();
          this.samples.forEach(function (sample) {
            (0, _array.arrayEach)(sample.strings, function (string) {
              var row = string.row;
              var cellProperties = _this4.hot.getCellMeta(row, column);
              cellProperties.col = column;
              cellProperties.row = row;
              var renderer = _this4.hot.getCellRenderer(cellProperties);
              var td = d.createElement('td');
              var tr = d.createElement('tr');
              renderer(_this4.hot, td, row, column, _this4.hot.colToProp(column), string.value, cellProperties);
              tr.appendChild(td);
              fragment.appendChild(tr);
            });
          });
          return fragment;
        }
      }, {
        key: 'clean',
        value: function clean() {
          this.rows.length = 0;
          this.rows[-1] = void 0;
          this.columns.length = 0;
          if (this.samples) {
            this.samples.clear();
          }
          this.samples = null;
          this.removeTable();
        }
      }, {
        key: 'injectTable',
        value: function injectTable() {
          var parent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
          if (!this.injected) {
            (parent || this.hot.rootElement).appendChild(this.container.fragment);
            this.injected = true;
          }
        }
      }, {
        key: 'removeTable',
        value: function removeTable() {
          if (this.injected && this.container.container.parentNode) {
            this.container.container.parentNode.removeChild(this.container.container);
            this.container = null;
            this.injected = false;
          }
        }
      }, {
        key: 'createColElement',
        value: function createColElement(column) {
          var d = document;
          var col = d.createElement('col');
          col.style.width = this.hot.view.wt.wtTable.getStretchedColumnWidth(column) + 'px';
          return col;
        }
      }, {
        key: 'createTable',
        value: function createTable() {
          var className = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
          var d = document;
          var fragment = d.createDocumentFragment();
          var table = d.createElement('table');
          var tHead = d.createElement('thead');
          var tBody = d.createElement('tbody');
          var colGroup = d.createElement('colgroup');
          var tr = d.createElement('tr');
          var th = d.createElement('th');
          if (this.isVertical()) {
            table.appendChild(colGroup);
          }
          if (this.isHorizontal()) {
            tr.appendChild(th);
            tHead.appendChild(tr);
            table.style.tableLayout = 'auto';
            table.style.width = 'auto';
          }
          table.appendChild(tHead);
          if (this.isVertical()) {
            tBody.appendChild(tr);
          }
          table.appendChild(tBody);
          (0, _element.addClass)(table, className);
          fragment.appendChild(table);
          return {
            fragment: fragment,
            table: table,
            tHead: tHead,
            tBody: tBody,
            colGroup: colGroup,
            tr: tr,
            th: th
          };
        }
      }, {
        key: 'createContainer',
        value: function createContainer() {
          var className = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
          var d = document;
          var fragment = d.createDocumentFragment();
          var container = d.createElement('div');
          className = 'htGhostTable htAutoSize ' + className.trim();
          (0, _element.addClass)(container, className);
          fragment.appendChild(container);
          return {
            fragment: fragment,
            container: container
          };
        }
      }, {
        key: 'isVertical',
        value: function isVertical() {
          return !!(this.rows.length && !this.columns.length);
        }
      }, {
        key: 'isHorizontal',
        value: function isHorizontal() {
          return !!(this.columns.length && !this.rows.length);
        }
      }]);
      return GhostTable;
    }();
    exports.default = GhostTable;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var addToUnscopables = __webpack_require__(37);
    var step = __webpack_require__(282);
    var Iterators = __webpack_require__(46);
    var toIObject = __webpack_require__(27);
    module.exports = __webpack_require__(281)(Array, 'Array', function (iterated, kind) {
      this._t = toIObject(iterated);
      this._i = 0;
      this._k = kind;
    }, function () {
      var O = this._t;
      var kind = this._k;
      var index = this._i++;
      if (!O || index >= O.length) {
        this._t = undefined;
        return step(1);
      }
      if (kind == 'keys') return step(0, index);
      if (kind == 'values') return step(0, O[index]);
      return step(0, [index, O[index]]);
    }, 'values');
    Iterators.Arguments = Iterators.Array;
    addToUnscopables('keys');
    addToUnscopables('values');
    addToUnscopables('entries');
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _coords = __webpack_require__(43);
    var _coords2 = _interopRequireDefault(_coords);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var CellRange = function () {
      function CellRange(highlight, from, to) {
        _classCallCheck(this, CellRange);
        this.highlight = highlight;
        this.from = from;
        this.to = to;
      }
      _createClass(CellRange, [{
        key: 'isValid',
        value: function isValid(wotInstance) {
          return this.from.isValid(wotInstance) && this.to.isValid(wotInstance);
        }
      }, {
        key: 'isSingle',
        value: function isSingle() {
          return this.from.row === this.to.row && this.from.col === this.to.col;
        }
      }, {
        key: 'getHeight',
        value: function getHeight() {
          return Math.max(this.from.row, this.to.row) - Math.min(this.from.row, this.to.row) + 1;
        }
      }, {
        key: 'getWidth',
        value: function getWidth() {
          return Math.max(this.from.col, this.to.col) - Math.min(this.from.col, this.to.col) + 1;
        }
      }, {
        key: 'includes',
        value: function includes(cellCoords) {
          var row = cellCoords.row,
            col = cellCoords.col;
          var topLeft = this.getTopLeftCorner();
          var bottomRight = this.getBottomRightCorner();
          return topLeft.row <= row && bottomRight.row >= row && topLeft.col <= col && bottomRight.col >= col;
        }
      }, {
        key: 'includesRange',
        value: function includesRange(testedRange) {
          return this.includes(testedRange.getTopLeftCorner()) && this.includes(testedRange.getBottomRightCorner());
        }
      }, {
        key: 'isEqual',
        value: function isEqual(testedRange) {
          return Math.min(this.from.row, this.to.row) == Math.min(testedRange.from.row, testedRange.to.row) && Math.max(this.from.row, this.to.row) == Math.max(testedRange.from.row, testedRange.to.row) && Math.min(this.from.col, this.to.col) == Math.min(testedRange.from.col, testedRange.to.col) && Math.max(this.from.col, this.to.col) == Math.max(testedRange.from.col, testedRange.to.col);
        }
      }, {
        key: 'overlaps',
        value: function overlaps(testedRange) {
          return testedRange.isSouthEastOf(this.getTopLeftCorner()) && testedRange.isNorthWestOf(this.getBottomRightCorner());
        }
      }, {
        key: 'isSouthEastOf',
        value: function isSouthEastOf(testedCoords) {
          return this.getTopLeftCorner().isSouthEastOf(testedCoords) || this.getBottomRightCorner().isSouthEastOf(testedCoords);
        }
      }, {
        key: 'isNorthWestOf',
        value: function isNorthWestOf(testedCoords) {
          return this.getTopLeftCorner().isNorthWestOf(testedCoords) || this.getBottomRightCorner().isNorthWestOf(testedCoords);
        }
      }, {
        key: 'expand',
        value: function expand(cellCoords) {
          var topLeft = this.getTopLeftCorner();
          var bottomRight = this.getBottomRightCorner();
          if (cellCoords.row < topLeft.row || cellCoords.col < topLeft.col || cellCoords.row > bottomRight.row || cellCoords.col > bottomRight.col) {
            this.from = new _coords2.default(Math.min(topLeft.row, cellCoords.row), Math.min(topLeft.col, cellCoords.col));
            this.to = new _coords2.default(Math.max(bottomRight.row, cellCoords.row), Math.max(bottomRight.col, cellCoords.col));
            return true;
          }
          return false;
        }
      }, {
        key: 'expandByRange',
        value: function expandByRange(expandingRange) {
          if (this.includesRange(expandingRange) || !this.overlaps(expandingRange)) {
            return false;
          }
          var topLeft = this.getTopLeftCorner();
          var bottomRight = this.getBottomRightCorner();
          var topRight = this.getTopRightCorner();
          var bottomLeft = this.getBottomLeftCorner();
          var expandingTopLeft = expandingRange.getTopLeftCorner();
          var expandingBottomRight = expandingRange.getBottomRightCorner();
          var resultTopRow = Math.min(topLeft.row, expandingTopLeft.row);
          var resultTopCol = Math.min(topLeft.col, expandingTopLeft.col);
          var resultBottomRow = Math.max(bottomRight.row, expandingBottomRight.row);
          var resultBottomCol = Math.max(bottomRight.col, expandingBottomRight.col);
          var finalFrom = new _coords2.default(resultTopRow, resultTopCol),
            finalTo = new _coords2.default(resultBottomRow, resultBottomCol);
          var isCorner = new CellRange(finalFrom, finalFrom, finalTo).isCorner(this.from, expandingRange),
            onlyMerge = expandingRange.isEqual(new CellRange(finalFrom, finalFrom, finalTo));
          if (isCorner && !onlyMerge) {
            if (this.from.col > finalFrom.col) {
              finalFrom.col = resultBottomCol;
              finalTo.col = resultTopCol;
            }
            if (this.from.row > finalFrom.row) {
              finalFrom.row = resultBottomRow;
              finalTo.row = resultTopRow;
            }
          }
          this.from = finalFrom;
          this.to = finalTo;
          return true;
        }
      }, {
        key: 'getDirection',
        value: function getDirection() {
          if (this.from.isNorthWestOf(this.to)) {
            return 'NW-SE';
          } else if (this.from.isNorthEastOf(this.to)) {
            return 'NE-SW';
          } else if (this.from.isSouthEastOf(this.to)) {
            return 'SE-NW';
          } else if (this.from.isSouthWestOf(this.to)) {
            return 'SW-NE';
          }
        }
      }, {
        key: 'setDirection',
        value: function setDirection(direction) {
          switch (direction) {
            case 'NW-SE':
              var _ref = [this.getTopLeftCorner(), this.getBottomRightCorner()];
              this.from = _ref[0];
              this.to = _ref[1];
              break;
            case 'NE-SW':
              var _ref2 = [this.getTopRightCorner(), this.getBottomLeftCorner()];
              this.from = _ref2[0];
              this.to = _ref2[1];
              break;
            case 'SE-NW':
              var _ref3 = [this.getBottomRightCorner(), this.getTopLeftCorner()];
              this.from = _ref3[0];
              this.to = _ref3[1];
              break;
            case 'SW-NE':
              var _ref4 = [this.getBottomLeftCorner(), this.getTopRightCorner()];
              this.from = _ref4[0];
              this.to = _ref4[1];
              break;
            default:
              break;
          }
        }
      }, {
        key: 'getTopLeftCorner',
        value: function getTopLeftCorner() {
          return new _coords2.default(Math.min(this.from.row, this.to.row), Math.min(this.from.col, this.to.col));
        }
      }, {
        key: 'getBottomRightCorner',
        value: function getBottomRightCorner() {
          return new _coords2.default(Math.max(this.from.row, this.to.row), Math.max(this.from.col, this.to.col));
        }
      }, {
        key: 'getTopRightCorner',
        value: function getTopRightCorner() {
          return new _coords2.default(Math.min(this.from.row, this.to.row), Math.max(this.from.col, this.to.col));
        }
      }, {
        key: 'getBottomLeftCorner',
        value: function getBottomLeftCorner() {
          return new _coords2.default(Math.max(this.from.row, this.to.row), Math.min(this.from.col, this.to.col));
        }
      }, {
        key: 'isCorner',
        value: function isCorner(coords, expandedRange) {
          if (expandedRange) {
            if (expandedRange.includes(coords)) {
              if (this.getTopLeftCorner().isEqual(new _coords2.default(expandedRange.from.row, expandedRange.from.col)) || this.getTopRightCorner().isEqual(new _coords2.default(expandedRange.from.row, expandedRange.to.col)) || this.getBottomLeftCorner().isEqual(new _coords2.default(expandedRange.to.row, expandedRange.from.col)) || this.getBottomRightCorner().isEqual(new _coords2.default(expandedRange.to.row, expandedRange.to.col))) {
                return true;
              }
            }
          }
          return coords.isEqual(this.getTopLeftCorner()) || coords.isEqual(this.getTopRightCorner()) || coords.isEqual(this.getBottomLeftCorner()) || coords.isEqual(this.getBottomRightCorner());
        }
      }, {
        key: 'getOppositeCorner',
        value: function getOppositeCorner(coords, expandedRange) {
          if (!(coords instanceof _coords2.default)) {
            return false;
          }
          if (expandedRange) {
            if (expandedRange.includes(coords)) {
              if (this.getTopLeftCorner().isEqual(new _coords2.default(expandedRange.from.row, expandedRange.from.col))) {
                return this.getBottomRightCorner();
              }
              if (this.getTopRightCorner().isEqual(new _coords2.default(expandedRange.from.row, expandedRange.to.col))) {
                return this.getBottomLeftCorner();
              }
              if (this.getBottomLeftCorner().isEqual(new _coords2.default(expandedRange.to.row, expandedRange.from.col))) {
                return this.getTopRightCorner();
              }
              if (this.getBottomRightCorner().isEqual(new _coords2.default(expandedRange.to.row, expandedRange.to.col))) {
                return this.getTopLeftCorner();
              }
            }
          }
          if (coords.isEqual(this.getBottomRightCorner())) {
            return this.getTopLeftCorner();
          } else if (coords.isEqual(this.getTopLeftCorner())) {
            return this.getBottomRightCorner();
          } else if (coords.isEqual(this.getTopRightCorner())) {
            return this.getBottomLeftCorner();
          } else if (coords.isEqual(this.getBottomLeftCorner())) {
            return this.getTopRightCorner();
          }
        }
      }, {
        key: 'getBordersSharedWith',
        value: function getBordersSharedWith(range) {
          if (!this.includesRange(range)) {
            return [];
          }
          var thisBorders = {
            top: Math.min(this.from.row, this.to.row),
            bottom: Math.max(this.from.row, this.to.row),
            left: Math.min(this.from.col, this.to.col),
            right: Math.max(this.from.col, this.to.col)
          };
          var rangeBorders = {
            top: Math.min(range.from.row, range.to.row),
            bottom: Math.max(range.from.row, range.to.row),
            left: Math.min(range.from.col, range.to.col),
            right: Math.max(range.from.col, range.to.col)
          };
          var result = [];
          if (thisBorders.top == rangeBorders.top) {
            result.push('top');
          }
          if (thisBorders.right == rangeBorders.right) {
            result.push('right');
          }
          if (thisBorders.bottom == rangeBorders.bottom) {
            result.push('bottom');
          }
          if (thisBorders.left == rangeBorders.left) {
            result.push('left');
          }
          return result;
        }
      }, {
        key: 'getInner',
        value: function getInner() {
          var topLeft = this.getTopLeftCorner();
          var bottomRight = this.getBottomRightCorner();
          var out = [];
          for (var r = topLeft.row; r <= bottomRight.row; r++) {
            for (var c = topLeft.col; c <= bottomRight.col; c++) {
              if (!(this.from.row === r && this.from.col === c) && !(this.to.row === r && this.to.col === c)) {
                out.push(new _coords2.default(r, c));
              }
            }
          }
          return out;
        }
      }, {
        key: 'getAll',
        value: function getAll() {
          var topLeft = this.getTopLeftCorner();
          var bottomRight = this.getBottomRightCorner();
          var out = [];
          for (var r = topLeft.row; r <= bottomRight.row; r++) {
            for (var c = topLeft.col; c <= bottomRight.col; c++) {
              if (topLeft.row === r && topLeft.col === c) {
                out.push(topLeft);
              } else if (bottomRight.row === r && bottomRight.col === c) {
                out.push(bottomRight);
              } else {
                out.push(new _coords2.default(r, c));
              }
            }
          }
          return out;
        }
      }, {
        key: 'forAll',
        value: function forAll(callback) {
          var topLeft = this.getTopLeftCorner();
          var bottomRight = this.getBottomRightCorner();
          for (var r = topLeft.row; r <= bottomRight.row; r++) {
            for (var c = topLeft.col; c <= bottomRight.col; c++) {
              var breakIteration = callback(r, c);
              if (breakIteration === false) {
                return;
              }
            }
          }
        }
      }]);
      return CellRange;
    }();
    exports.default = CellRange;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.ITEMS = exports.UNDO = exports.SEPARATOR = exports.ROW_BELOW = exports.ROW_ABOVE = exports.REMOVE_ROW = exports.REMOVE_COLUMN = exports.REDO = exports.READ_ONLY = exports.COLUMN_RIGHT = exports.COLUMN_LEFT = exports.CLEAR_COLUMN = exports.ALIGNMENT = undefined;
    var _predefinedItems2;
    var _alignment = __webpack_require__(344);
    Object.defineProperty(exports, 'ALIGNMENT', {
      enumerable: true,
      get: function get() {
        return _alignment.KEY;
      }
    });
    var _clearColumn = __webpack_require__(345);
    Object.defineProperty(exports, 'CLEAR_COLUMN', {
      enumerable: true,
      get: function get() {
        return _clearColumn.KEY;
      }
    });
    var _columnLeft = __webpack_require__(346);
    Object.defineProperty(exports, 'COLUMN_LEFT', {
      enumerable: true,
      get: function get() {
        return _columnLeft.KEY;
      }
    });
    var _columnRight = __webpack_require__(347);
    Object.defineProperty(exports, 'COLUMN_RIGHT', {
      enumerable: true,
      get: function get() {
        return _columnRight.KEY;
      }
    });
    var _readOnly = __webpack_require__(348);
    Object.defineProperty(exports, 'READ_ONLY', {
      enumerable: true,
      get: function get() {
        return _readOnly.KEY;
      }
    });
    var _redo = __webpack_require__(349);
    Object.defineProperty(exports, 'REDO', {
      enumerable: true,
      get: function get() {
        return _redo.KEY;
      }
    });
    var _removeColumn = __webpack_require__(350);
    Object.defineProperty(exports, 'REMOVE_COLUMN', {
      enumerable: true,
      get: function get() {
        return _removeColumn.KEY;
      }
    });
    var _removeRow = __webpack_require__(351);
    Object.defineProperty(exports, 'REMOVE_ROW', {
      enumerable: true,
      get: function get() {
        return _removeRow.KEY;
      }
    });
    var _rowAbove = __webpack_require__(352);
    Object.defineProperty(exports, 'ROW_ABOVE', {
      enumerable: true,
      get: function get() {
        return _rowAbove.KEY;
      }
    });
    var _rowBelow = __webpack_require__(353);
    Object.defineProperty(exports, 'ROW_BELOW', {
      enumerable: true,
      get: function get() {
        return _rowBelow.KEY;
      }
    });
    var _separator = __webpack_require__(73);
    Object.defineProperty(exports, 'SEPARATOR', {
      enumerable: true,
      get: function get() {
        return _separator.KEY;
      }
    });
    var _undo = __webpack_require__(354);
    Object.defineProperty(exports, 'UNDO', {
      enumerable: true,
      get: function get() {
        return _undo.KEY;
      }
    });
    exports.predefinedItems = predefinedItems;
    exports.addItem = addItem;
    var _object = __webpack_require__(3);
    var _alignment2 = _interopRequireDefault(_alignment);
    var _clearColumn2 = _interopRequireDefault(_clearColumn);
    var _columnLeft2 = _interopRequireDefault(_columnLeft);
    var _columnRight2 = _interopRequireDefault(_columnRight);
    var _readOnly2 = _interopRequireDefault(_readOnly);
    var _redo2 = _interopRequireDefault(_redo);
    var _removeColumn2 = _interopRequireDefault(_removeColumn);
    var _removeRow2 = _interopRequireDefault(_removeRow);
    var _rowAbove2 = _interopRequireDefault(_rowAbove);
    var _rowBelow2 = _interopRequireDefault(_rowBelow);
    var _separator2 = _interopRequireDefault(_separator);
    var _undo2 = _interopRequireDefault(_undo);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _defineProperty(obj, key, value) {
      if (key in obj) {
        Object.defineProperty(obj, key, {
          value: value,
          enumerable: true,
          configurable: true,
          writable: true
        });
      } else {
        obj[key] = value;
      }
      return obj;
    }
    var ITEMS = exports.ITEMS = [_rowAbove.KEY, _rowBelow.KEY, _columnLeft.KEY, _columnRight.KEY, _clearColumn.KEY, _removeRow.KEY, _removeColumn.KEY, _undo.KEY, _redo.KEY, _readOnly.KEY, _alignment.KEY, _separator.KEY];
    var _predefinedItems = (_predefinedItems2 = {}, _defineProperty(_predefinedItems2, _separator.KEY, _separator2.default), _defineProperty(_predefinedItems2, _rowAbove.KEY, _rowAbove2.default), _defineProperty(_predefinedItems2, _rowBelow.KEY, _rowBelow2.default), _defineProperty(_predefinedItems2, _columnLeft.KEY, _columnLeft2.default), _defineProperty(_predefinedItems2, _columnRight.KEY, _columnRight2.default), _defineProperty(_predefinedItems2, _clearColumn.KEY, _clearColumn2.default), _defineProperty(_predefinedItems2, _removeRow.KEY, _removeRow2.default), _defineProperty(_predefinedItems2, _removeColumn.KEY, _removeColumn2.default), _defineProperty(_predefinedItems2, _undo.KEY, _undo2.default), _defineProperty(_predefinedItems2, _redo.KEY, _redo2.default), _defineProperty(_predefinedItems2, _readOnly.KEY, _readOnly2.default), _defineProperty(_predefinedItems2, _alignment.KEY, _alignment2.default), _predefinedItems2);

    function predefinedItems() {
      var items = {};
      (0, _object.objectEach)(_predefinedItems, function (itemFactory, key) {
        items[key] = itemFactory();
      });
      return items;
    }

    function addItem(key, item) {
      if (ITEMS.indexOf(key) === -1) {
        _predefinedItems[key] = item;
      }
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.default = separatorItem;
    var KEY = exports.KEY = '---------';

    function separatorItem() {
      return {
        name: KEY
      };
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var $defineProperty = __webpack_require__(18);
    var createDesc = __webpack_require__(49);
    module.exports = function (object, index, value) {
      if (index in object) $defineProperty.f(object, index, createDesc(0, value));
      else object[index] = value;
    };
  }), (function (module, exports, __webpack_require__) {
    var isObject = __webpack_require__(12);
    var document = __webpack_require__(10).document;
    var is = isObject(document) && isObject(document.createElement);
    module.exports = function (it) {
      return is ? document.createElement(it) : {};
    };
  }), (function (module, exports) {
    module.exports = ('constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf').split(',');
  }), (function (module, exports, __webpack_require__) {
    var MATCH = __webpack_require__(8)('match');
    module.exports = function (KEY) {
      var re = /./;
      try {
        '/./'[KEY](re);
      } catch (e) {
        try {
          re[MATCH] = false;
          return !'/./'[KEY](re);
        } catch (f) { }
      }
      return true;
    };
  }), (function (module, exports, __webpack_require__) {
    var cof = __webpack_require__(38);
    module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
      return cof(it) == 'String' ? it.split('') : Object(it);
    };
  }), (function (module, exports, __webpack_require__) {
    var ITERATOR = __webpack_require__(8)('iterator');
    var SAFE_CLOSING = false;
    try {
      var riter = [7][ITERATOR]();
      riter['return'] = function () {
        SAFE_CLOSING = true;
      };
      Array.from(riter, function () {
        throw 2;
      });
    } catch (e) { }
    module.exports = function (exec, skipClosing) {
      if (!skipClosing && !SAFE_CLOSING) return false;
      var safe = false;
      try {
        var arr = [7];
        var iter = arr[ITERATOR]();
        iter.next = function () {
          return {
            done: safe = true
          };
        };
        arr[ITERATOR] = function () {
          return iter;
        };
        exec(arr);
      } catch (e) { }
      return safe;
    };
  }), (function (module, exports, __webpack_require__) {
    var anObject = __webpack_require__(17);
    var dPs = __webpack_require__(399);
    var enumBugKeys = __webpack_require__(76);
    var IE_PROTO = __webpack_require__(83)('IE_PROTO');
    var Empty = function () { };
    var PROTOTYPE = 'prototype';
    var createDict = function () {
      var iframe = __webpack_require__(75)('iframe');
      var i = enumBugKeys.length;
      var lt = '<';
      var gt = '>';
      var iframeDocument;
      iframe.style.display = 'none';
      __webpack_require__(274).appendChild(iframe);
      iframe.src = 'javascript:';
      iframeDocument = iframe.contentWindow.document;
      iframeDocument.open();
      iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
      iframeDocument.close();
      createDict = iframeDocument.F;
      while (i--) delete createDict[PROTOTYPE][enumBugKeys[i]];
      return createDict();
    };
    module.exports = Object.create || function create(O, Properties) {
      var result;
      if (O !== null) {
        Empty[PROTOTYPE] = anObject(O);
        result = new Empty();
        Empty[PROTOTYPE] = null;
        result[IE_PROTO] = O;
      } else result = createDict();
      return Properties === undefined ? result : dPs(result, Properties);
    };
  }), (function (module, exports, __webpack_require__) {
    var pIE = __webpack_require__(48);
    var createDesc = __webpack_require__(49);
    var toIObject = __webpack_require__(27);
    var toPrimitive = __webpack_require__(87);
    var has = __webpack_require__(26);
    var IE8_DOM_DEFINE = __webpack_require__(275);
    var gOPD = Object.getOwnPropertyDescriptor;
    exports.f = __webpack_require__(20) ? gOPD : function getOwnPropertyDescriptor(O, P) {
      O = toIObject(O);
      P = toPrimitive(P, true);
      if (IE8_DOM_DEFINE) try {
        return gOPD(O, P);
      } catch (e) { }
      if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]);
    };
  }), (function (module, exports, __webpack_require__) {
    var $keys = __webpack_require__(285);
    var hiddenKeys = __webpack_require__(76).concat('length', 'prototype');
    exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
      return $keys(O, hiddenKeys);
    };
  }), (function (module, exports, __webpack_require__) {
    var shared = __webpack_require__(84)('keys');
    var uid = __webpack_require__(51);
    module.exports = function (key) {
      return shared[key] || (shared[key] = uid(key));
    };
  }), (function (module, exports, __webpack_require__) {
    var global = __webpack_require__(10);
    var SHARED = '__core-js_shared__';
    var store = global[SHARED] || (global[SHARED] = {});
    module.exports = function (key) {
      return store[key] || (store[key] = {});
    };
  }), (function (module, exports, __webpack_require__) {
    var isRegExp = __webpack_require__(279);
    var defined = __webpack_require__(33);
    module.exports = function (that, searchString, NAME) {
      if (isRegExp(searchString)) throw TypeError('String#' + NAME + " doesn't accept regex!");
      return String(defined(that));
    };
  }), (function (module, exports, __webpack_require__) {
    var ctx = __webpack_require__(30);
    var invoke = __webpack_require__(396);
    var html = __webpack_require__(274);
    var cel = __webpack_require__(75);
    var global = __webpack_require__(10);
    var process = global.process;
    var setTask = global.setImmediate;
    var clearTask = global.clearImmediate;
    var MessageChannel = global.MessageChannel;
    var Dispatch = global.Dispatch;
    var counter = 0;
    var queue = {};
    var ONREADYSTATECHANGE = 'onreadystatechange';
    var defer, channel, port;
    var run = function () {
      var id = +this;
      if (queue.hasOwnProperty(id)) {
        var fn = queue[id];
        delete queue[id];
        fn();
      }
    };
    var listener = function (event) {
      run.call(event.data);
    };
    if (!setTask || !clearTask) {
      setTask = function setImmediate(fn) {
        var args = [];
        var i = 1;
        while (arguments.length > i) args.push(arguments[i++]);
        queue[++counter] = function () {
          invoke(typeof fn == 'function' ? fn : Function(fn), args);
        };
        defer(counter);
        return counter;
      };
      clearTask = function clearImmediate(id) {
        delete queue[id];
      };
      if (__webpack_require__(38)(process) == 'process') {
        defer = function (id) {
          process.nextTick(ctx(run, id, 1));
        };
      } else if (Dispatch && Dispatch.now) {
        defer = function (id) {
          Dispatch.now(ctx(run, id, 1));
        };
      } else if (MessageChannel) {
        channel = new MessageChannel();
        port = channel.port2;
        channel.port1.onmessage = listener;
        defer = ctx(port.postMessage, port, 1);
      } else if (global.addEventListener && typeof postMessage == 'function' && !global.importScripts) {
        defer = function (id) {
          global.postMessage(id + '', '*');
        };
        global.addEventListener('message', listener, false);
      } else if (ONREADYSTATECHANGE in cel('script')) {
        defer = function (id) {
          html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function () {
            html.removeChild(this);
            run.call(id);
          };
        };
      } else {
        defer = function (id) {
          setTimeout(ctx(run, id, 1), 0);
        };
      }
    }
    module.exports = {
      set: setTask,
      clear: clearTask
    };
  }), (function (module, exports, __webpack_require__) {
    var isObject = __webpack_require__(12);
    module.exports = function (it, S) {
      if (!isObject(it)) return it;
      var fn, val;
      if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
      if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;
      if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
      throw TypeError("Can't convert object to primitive value");
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
      return typeof obj;
    } : function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
    var _mixed = __webpack_require__(23);
    var _object = __webpack_require__(3);

    function DefaultSettings() { };
    DefaultSettings.prototype = {
      licenseKey: 'trial',
      data: void 0,
      dataSchema: void 0,
      width: void 0,
      height: void 0,
      startRows: 5,
      startCols: 5,
      rowHeaders: void 0,
      colHeaders: null,
      colWidths: void 0,
      rowHeights: void 0,
      columns: void 0,
      cells: void 0,
      cell: [],
      comments: false,
      customBorders: false,
      minRows: 0,
      minCols: 0,
      maxRows: Infinity,
      maxCols: Infinity,
      minSpareRows: 0,
      minSpareCols: 0,
      allowInsertRow: true,
      allowInsertColumn: true,
      allowRemoveRow: true,
      allowRemoveColumn: true,
      multiSelect: true,
      fillHandle: true,
      fixedRowsTop: 0,
      fixedRowsBottom: 0,
      fixedColumnsLeft: 0,
      outsideClickDeselects: true,
      enterBeginsEditing: true,
      enterMoves: {
        row: 1,
        col: 0
      },
      tabMoves: {
        row: 0,
        col: 1
      },
      autoWrapRow: false,
      autoWrapCol: false,
      persistentState: void 0,
      currentRowClassName: void 0,
      currentColClassName: void 0,
      currentHeaderClassName: 'ht__highlight',
      className: void 0,
      tableClassName: void 0,
      stretchH: 'none',
      isEmptyRow: function isEmptyRow(row) {
        var col, colLen, value, meta;
        for (col = 0, colLen = this.countCols(); col < colLen; col++) {
          value = this.getDataAtCell(row, col);
          if (value !== '' && value !== null && (0, _mixed.isDefined)(value)) {
            if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
              meta = this.getCellMeta(row, col);
              return (0, _object.isObjectEquals)(this.getSchema()[meta.prop], value);
            }
            return false;
          }
        }
        return true;
      },
      isEmptyCol: function isEmptyCol(col) {
        var row, rowLen, value;
        for (row = 0, rowLen = this.countRows(); row < rowLen; row++) {
          value = this.getDataAtCell(row, col);
          if (value !== '' && value !== null && (0, _mixed.isDefined)(value)) {
            return false;
          }
        }
        return true;
      },
      observeDOMVisibility: true,
      allowInvalid: true,
      allowEmpty: true,
      invalidCellClassName: 'htInvalid',
      placeholder: false,
      placeholderCellClassName: 'htPlaceholder',
      readOnlyCellClassName: 'htDimmed',
      renderer: void 0,
      commentedCellClassName: 'htCommentCell',
      fragmentSelection: false,
      readOnly: false,
      skipColumnOnPaste: false,
      search: false,
      type: 'text',
      copyable: true,
      editor: void 0,
      autoComplete: void 0,
      visibleRows: 10,
      trimDropdown: true,
      debug: false,
      wordWrap: true,
      noWordWrapClassName: 'htNoWrap',
      contextMenu: void 0,
      copyPaste: true,
      undo: void 0,
      columnSorting: void 0,
      manualColumnMove: void 0,
      manualColumnResize: void 0,
      manualRowMove: void 0,
      manualRowResize: void 0,
      mergeCells: false,
      viewportRowRenderingOffset: 'auto',
      viewportColumnRenderingOffset: 'auto',
      validator: void 0,
      disableVisualSelection: false,
      sortIndicator: void 0,
      manualColumnFreeze: void 0,
      trimWhitespace: true,
      settings: void 0,
      source: void 0,
      title: void 0,
      checkedTemplate: void 0,
      uncheckedTemplate: void 0,
      label: void 0,
      format: void 0,
      language: void 0,
      selectOptions: void 0,
      autoColumnSize: void 0,
      autoRowSize: void 0,
      dateFormat: void 0,
      correctFormat: false,
      defaultDate: void 0,
      strict: void 0,
      allowHtml: false,
      renderAllRows: void 0,
      preventOverflow: false,
      bindRowsWithHeaders: void 0,
      collapsibleColumns: void 0,
      columnSummary: void 0,
      dropdownMenu: void 0,
      filters: void 0,
      formulas: void 0,
      ganttChart: void 0,
      headerTooltips: void 0,
      hiddenColumns: void 0,
      hiddenRows: void 0,
      nestedHeaders: void 0,
      trimRows: void 0,
      rowHeaderWidth: void 0,
      columnHeaderHeight: void 0,
      observeChanges: void 0,
      sortFunction: void 0,
      sortByRelevance: true,
      filter: true,
      filteringCaseSensitive: false
    };
    exports.default = DefaultSettings;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.getNormalizedDate = getNormalizedDate;

    function getNormalizedDate(dateString) {
      var nativeDate = new Date(dateString);
      if (!isNaN(new Date(dateString + "T00:00").getDate())) {
        return new Date(nativeDate.getTime() + nativeDate.getTimezoneOffset() * 60000);
      }
      return nativeDate;
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.registerAsRootInstance = registerAsRootInstance;
    exports.hasValidParameter = hasValidParameter;
    exports.isRootInstance = isRootInstance;
    var holder = exports.holder = new WeakMap();
    var rootInstanceSymbol = exports.rootInstanceSymbol = Symbol('rootInstance');

    function registerAsRootInstance(object) {
      holder.set(object, true);
    }

    function hasValidParameter(rootSymbol) {
      return rootSymbol === rootInstanceSymbol;
    }

    function isRootInstance(object) {
      return holder.has(object);
    }
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    $export($export.P, 'Array', {
      copyWithin: __webpack_require__(389)
    });
    __webpack_require__(37)('copyWithin');
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    $export($export.P, 'Array', {
      fill: __webpack_require__(390)
    });
    __webpack_require__(37)('fill');
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var $export = __webpack_require__(1);
    var $find = __webpack_require__(56)(6);
    var KEY = 'findIndex';
    var forced = true;
    if (KEY in []) Array(1)[KEY](function () {
      forced = false;
    });
    $export($export.P + $export.F * forced, 'Array', {
      findIndex: function findIndex(callbackfn) {
        return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
      }
    });
    __webpack_require__(37)(KEY);
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var $export = __webpack_require__(1);
    var $find = __webpack_require__(56)(5);
    var KEY = 'find';
    var forced = true;
    if (KEY in []) Array(1)[KEY](function () {
      forced = false;
    });
    $export($export.P + $export.F * forced, 'Array', {
      find: function find(callbackfn) {
        return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
      }
    });
    __webpack_require__(37)(KEY);
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var ctx = __webpack_require__(30);
    var $export = __webpack_require__(1);
    var toObject = __webpack_require__(40);
    var call = __webpack_require__(280);
    var isArrayIter = __webpack_require__(276);
    var toLength = __webpack_require__(21);
    var createProperty = __webpack_require__(74);
    var getIterFn = __webpack_require__(292);
    $export($export.S + $export.F * !__webpack_require__(79)(function (iter) {
      Array.from(iter);
    }), 'Array', {
      from: function from(arrayLike) {
        var O = toObject(arrayLike);
        var C = typeof this == 'function' ? this : Array;
        var aLen = arguments.length;
        var mapfn = aLen > 1 ? arguments[1] : undefined;
        var mapping = mapfn !== undefined;
        var index = 0;
        var iterFn = getIterFn(O);
        var length, result, step, iterator;
        if (mapping) mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);
        if (iterFn != undefined && !(C == Array && isArrayIter(iterFn))) {
          for (iterator = iterFn.call(O), result = new C(); !(step = iterator.next()).done; index++) {
            createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);
          }
        } else {
          length = toLength(O.length);
          for (result = new C(length); length > index; index++) {
            createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);
          }
        }
        result.length = index;
        return result;
      }
    });
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var $export = __webpack_require__(1);
    var createProperty = __webpack_require__(74);
    $export($export.S + $export.F * __webpack_require__(25)(function () {
      function F() { }
      return !(Array.of.call(F) instanceof F);
    }), 'Array', {
      of: function of() {
        var index = 0;
        var aLen = arguments.length;
        var result = new (typeof this == 'function' ? this : Array)(aLen);
        while (aLen > index) createProperty(result, index, arguments[index++]);
        result.length = aLen;
        return result;
      }
    });
  }), (function (module, exports, __webpack_require__) {
    var dP = __webpack_require__(18).f;
    var FProto = Function.prototype;
    var nameRE = /^\s*function ([^ (]*)/;
    var NAME = 'name';
    NAME in FProto || __webpack_require__(20) && dP(FProto, NAME, {
      configurable: true,
      get: function () {
        try {
          return ('' + this).match(nameRE)[1];
        } catch (e) {
          return '';
        }
      }
    });
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var strong = __webpack_require__(272);
    var validate = __webpack_require__(41);
    var MAP = 'Map';
    module.exports = __webpack_require__(57)(MAP, function (get) {
      return function Map() {
        return get(this, arguments.length > 0 ? arguments[0] : undefined);
      };
    }, {
      get: function get(key) {
        var entry = strong.getEntry(validate(this, MAP), key);
        return entry && entry.v;
      },
      set: function set(key, value) {
        return strong.def(validate(this, MAP), key === 0 ? 0 : key, value);
      }
    }, strong, true);
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    $export($export.S, 'Number', {
      EPSILON: Math.pow(2, -52)
    });
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    var _isFinite = __webpack_require__(10).isFinite;
    $export($export.S, 'Number', {
      isFinite: function isFinite(it) {
        return typeof it == 'number' && _isFinite(it);
      }
    });
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    $export($export.S, 'Number', {
      isInteger: __webpack_require__(278)
    });
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    $export($export.S, 'Number', {
      isNaN: function isNaN(number) {
        return number != number;
      }
    });
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    var isInteger = __webpack_require__(278);
    var abs = Math.abs;
    $export($export.S, 'Number', {
      isSafeInteger: function isSafeInteger(number) {
        return isInteger(number) && abs(number) <= 0x1fffffffffffff;
      }
    });
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    $export($export.S, 'Number', {
      MAX_SAFE_INTEGER: 0x1fffffffffffff
    });
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    $export($export.S, 'Number', {
      MIN_SAFE_INTEGER: -0x1fffffffffffff
    });
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    $export($export.S + $export.F, 'Object', {
      assign: __webpack_require__(284)
    });
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    $export($export.S, 'Object', {
      is: __webpack_require__(405)
    });
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    $export($export.S, 'Object', {
      setPrototypeOf: __webpack_require__(287).set
    });
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var LIBRARY = __webpack_require__(60);
    var global = __webpack_require__(10);
    var ctx = __webpack_require__(30);
    var classof = __webpack_require__(271);
    var $export = __webpack_require__(1);
    var isObject = __webpack_require__(12);
    var aFunction = __webpack_require__(54);
    var anInstance = __webpack_require__(55);
    var forOf = __webpack_require__(59);
    var speciesConstructor = __webpack_require__(406);
    var task = __webpack_require__(86).set;
    var microtask = __webpack_require__(398)();
    var newPromiseCapabilityModule = __webpack_require__(283);
    var perform = __webpack_require__(403);
    var promiseResolve = __webpack_require__(404);
    var PROMISE = 'Promise';
    var TypeError = global.TypeError;
    var process = global.process;
    var $Promise = global[PROMISE];
    var isNode = classof(process) == 'process';
    var empty = function () { };
    var Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper;
    var newPromiseCapability = newGenericPromiseCapability = newPromiseCapabilityModule.f;
    var USE_NATIVE = !! function () {
      try {
        var promise = $Promise.resolve(1);
        var FakePromise = (promise.constructor = {})[__webpack_require__(8)('species')] = function (exec) {
          exec(empty, empty);
        };
        return (isNode || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise;
      } catch (e) { }
    }();
    var isThenable = function (it) {
      var then;
      return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
    };
    var notify = function (promise, isReject) {
      if (promise._n) return;
      promise._n = true;
      var chain = promise._c;
      microtask(function () {
        var value = promise._v;
        var ok = promise._s == 1;
        var i = 0;
        var run = function (reaction) {
          var handler = ok ? reaction.ok : reaction.fail;
          var resolve = reaction.resolve;
          var reject = reaction.reject;
          var domain = reaction.domain;
          var result, then;
          try {
            if (handler) {
              if (!ok) {
                if (promise._h == 2) onHandleUnhandled(promise);
                promise._h = 1;
              }
              if (handler === true) result = value;
              else {
                if (domain) domain.enter();
                result = handler(value);
                if (domain) domain.exit();
              }
              if (result === reaction.promise) {
                reject(TypeError('Promise-chain cycle'));
              } else if (then = isThenable(result)) {
                then.call(result, resolve, reject);
              } else resolve(result);
            } else reject(value);
          } catch (e) {
            reject(e);
          }
        };
        while (chain.length > i) run(chain[i++]);
        promise._c = [];
        promise._n = false;
        if (isReject && !promise._h) onUnhandled(promise);
      });
    };
    var onUnhandled = function (promise) {
      task.call(global, function () {
        var value = promise._v;
        var unhandled = isUnhandled(promise);
        var result, handler, console;
        if (unhandled) {
          result = perform(function () {
            if (isNode) {
              process.emit('unhandledRejection', value, promise);
            } else if (handler = global.onunhandledrejection) {
              handler({
                promise: promise,
                reason: value
              });
            } else if ((console = global.console) && console.error) {
              console.error('Unhandled promise rejection', value);
            }
          });
          promise._h = isNode || isUnhandled(promise) ? 2 : 1;
        }
        promise._a = undefined;
        if (unhandled && result.e) throw result.v;
      });
    };
    var isUnhandled = function (promise) {
      if (promise._h == 1) return false;
      var chain = promise._a || promise._c;
      var i = 0;
      var reaction;
      while (chain.length > i) {
        reaction = chain[i++];
        if (reaction.fail || !isUnhandled(reaction.promise)) return false;
      }
      return true;
    };
    var onHandleUnhandled = function (promise) {
      task.call(global, function () {
        var handler;
        if (isNode) {
          process.emit('rejectionHandled', promise);
        } else if (handler = global.onrejectionhandled) {
          handler({
            promise: promise,
            reason: promise._v
          });
        }
      });
    };
    var $reject = function (value) {
      var promise = this;
      if (promise._d) return;
      promise._d = true;
      promise = promise._w || promise;
      promise._v = value;
      promise._s = 2;
      if (!promise._a) promise._a = promise._c.slice();
      notify(promise, true);
    };
    var $resolve = function (value) {
      var promise = this;
      var then;
      if (promise._d) return;
      promise._d = true;
      promise = promise._w || promise;
      try {
        if (promise === value) throw TypeError("Promise can't be resolved itself");
        if (then = isThenable(value)) {
          microtask(function () {
            var wrapper = {
              _w: promise,
              _d: false
            };
            try {
              then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
            } catch (e) {
              $reject.call(wrapper, e);
            }
          });
        } else {
          promise._v = value;
          promise._s = 1;
          notify(promise, false);
        }
      } catch (e) {
        $reject.call({
          _w: promise,
          _d: false
        }, e);
      }
    };
    if (!USE_NATIVE) {
      $Promise = function Promise(executor) {
        anInstance(this, $Promise, PROMISE, '_h');
        aFunction(executor);
        Internal.call(this);
        try {
          executor(ctx($resolve, this, 1), ctx($reject, this, 1));
        } catch (err) {
          $reject.call(this, err);
        }
      };
      Internal = function Promise(executor) {
        this._c = [];
        this._a = undefined;
        this._s = 0;
        this._d = false;
        this._v = undefined;
        this._h = 0;
        this._n = false;
      };
      Internal.prototype = __webpack_require__(62)($Promise.prototype, {
        then: function then(onFulfilled, onRejected) {
          var reaction = newPromiseCapability(speciesConstructor(this, $Promise));
          reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
          reaction.fail = typeof onRejected == 'function' && onRejected;
          reaction.domain = isNode ? process.domain : undefined;
          this._c.push(reaction);
          if (this._a) this._a.push(reaction);
          if (this._s) notify(this, false);
          return reaction.promise;
        },
        'catch': function (onRejected) {
          return this.then(undefined, onRejected);
        }
      });
      OwnPromiseCapability = function () {
        var promise = new Internal();
        this.promise = promise;
        this.resolve = ctx($resolve, promise, 1);
        this.reject = ctx($reject, promise, 1);
      };
      newPromiseCapabilityModule.f = newPromiseCapability = function (C) {
        return C === $Promise || C === Wrapper ? new OwnPromiseCapability(C) : newGenericPromiseCapability(C);
      };
    }
    $export($export.G + $export.W + $export.F * !USE_NATIVE, {
      Promise: $Promise
    });
    __webpack_require__(50)($Promise, PROMISE);
    __webpack_require__(288)(PROMISE);
    Wrapper = __webpack_require__(45)[PROMISE];
    $export($export.S + $export.F * !USE_NATIVE, PROMISE, {
      reject: function reject(r) {
        var capability = newPromiseCapability(this);
        var $$reject = capability.reject;
        $$reject(r);
        return capability.promise;
      }
    });
    $export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {
      resolve: function resolve(x) {
        return promiseResolve(LIBRARY && this === Wrapper ? $Promise : this, x);
      }
    });
    $export($export.S + $export.F * !(USE_NATIVE && __webpack_require__(79)(function (iter) {
      $Promise.all(iter)['catch'](empty);
    })), PROMISE, {
      all: function all(iterable) {
        var C = this;
        var capability = newPromiseCapability(C);
        var resolve = capability.resolve;
        var reject = capability.reject;
        var result = perform(function () {
          var values = [];
          var index = 0;
          var remaining = 1;
          forOf(iterable, false, function (promise) {
            var $index = index++;
            var alreadyCalled = false;
            values.push(undefined);
            remaining++;
            C.resolve(promise).then(function (value) {
              if (alreadyCalled) return;
              alreadyCalled = true;
              values[$index] = value;
              --remaining || resolve(values);
            }, reject);
          });
          --remaining || resolve(values);
        });
        if (result.e) reject(result.v);
        return capability.promise;
      },
      race: function race(iterable) {
        var C = this;
        var capability = newPromiseCapability(C);
        var reject = capability.reject;
        var result = perform(function () {
          forOf(iterable, false, function (promise) {
            C.resolve(promise).then(capability.resolve, reject);
          });
        });
        if (result.e) reject(result.v);
        return capability.promise;
      }
    });
  }), (function (module, exports, __webpack_require__) {
    if (__webpack_require__(20) && /./g.flags != 'g') __webpack_require__(18).f(RegExp.prototype, 'flags', {
      configurable: true,
      get: __webpack_require__(394)
    });
  }), (function (module, exports, __webpack_require__) {
    __webpack_require__(58)('match', 1, function (defined, MATCH, $match) {
      return [function match(regexp) {
        'use strict';
        var O = defined(this);
        var fn = regexp == undefined ? undefined : regexp[MATCH];
        return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[MATCH](String(O));
      }, $match];
    });
  }), (function (module, exports, __webpack_require__) {
    __webpack_require__(58)('replace', 2, function (defined, REPLACE, $replace) {
      return [function replace(searchValue, replaceValue) {
        'use strict';
        var O = defined(this);
        var fn = searchValue == undefined ? undefined : searchValue[REPLACE];
        return fn !== undefined ? fn.call(searchValue, O, replaceValue) : $replace.call(String(O), searchValue, replaceValue);
      }, $replace];
    });
  }), (function (module, exports, __webpack_require__) {
    __webpack_require__(58)('search', 1, function (defined, SEARCH, $search) {
      return [function search(regexp) {
        'use strict';
        var O = defined(this);
        var fn = regexp == undefined ? undefined : regexp[SEARCH];
        return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[SEARCH](String(O));
      }, $search];
    });
  }), (function (module, exports, __webpack_require__) {
    __webpack_require__(58)('split', 2, function (defined, SPLIT, $split) {
      'use strict';
      var isRegExp = __webpack_require__(279);
      var _split = $split;
      var $push = [].push;
      var $SPLIT = 'split';
      var LENGTH = 'length';
      var LAST_INDEX = 'lastIndex';
      if ('abbc'[$SPLIT](/(b)*/)[1] == 'c' || 'test'[$SPLIT](/(?:)/, -1)[LENGTH] != 4 || 'ab'[$SPLIT](/(?:ab)*/)[LENGTH] != 2 || '.'[$SPLIT](/(.?)(.?)/)[LENGTH] != 4 || '.'[$SPLIT](/()()/)[LENGTH] > 1 || ''[$SPLIT](/.?/)[LENGTH]) {
        var NPCG = /()??/.exec('')[1] === undefined;
        $split = function (separator, limit) {
          var string = String(this);
          if (separator === undefined && limit === 0) return [];
          if (!isRegExp(separator)) return _split.call(string, separator, limit);
          var output = [];
          var flags = (separator.ignoreCase ? 'i' : '') + (separator.multiline ? 'm' : '') + (separator.unicode ? 'u' : '') + (separator.sticky ? 'y' : '');
          var lastLastIndex = 0;
          var splitLimit = limit === undefined ? 4294967295 : limit >>> 0;
          var separatorCopy = new RegExp(separator.source, flags + 'g');
          var separator2, match, lastIndex, lastLength, i;
          if (!NPCG) separator2 = new RegExp('^' + separatorCopy.source + '$(?!\\s)', flags);
          while (match = separatorCopy.exec(string)) {
            lastIndex = match.index + match[0][LENGTH];
            if (lastIndex > lastLastIndex) {
              output.push(string.slice(lastLastIndex, match.index));
              if (!NPCG && match[LENGTH] > 1) match[0].replace(separator2, function () {
                for (i = 1; i < arguments[LENGTH] - 2; i++)
                  if (arguments[i] === undefined) match[i] = undefined;
              });
              if (match[LENGTH] > 1 && match.index < string[LENGTH]) $push.apply(output, match.slice(1));
              lastLength = match[0][LENGTH];
              lastLastIndex = lastIndex;
              if (output[LENGTH] >= splitLimit) break;
            }
            if (separatorCopy[LAST_INDEX] === match.index) separatorCopy[LAST_INDEX]++;
          }
          if (lastLastIndex === string[LENGTH]) {
            if (lastLength || !separatorCopy.test('')) output.push('');
          } else output.push(string.slice(lastLastIndex));
          return output[LENGTH] > splitLimit ? output.slice(0, splitLimit) : output;
        };
      } else if ('0'[$SPLIT](undefined, 0)[LENGTH]) {
        $split = function (separator, limit) {
          return separator === undefined && limit === 0 ? [] : _split.call(this, separator, limit);
        };
      }
      return [function split(separator, limit) {
        var O = defined(this);
        var fn = separator == undefined ? undefined : separator[SPLIT];
        return fn !== undefined ? fn.call(separator, O, limit) : $split.call(String(O), separator, limit);
      }, $split];
    });
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var strong = __webpack_require__(272);
    var validate = __webpack_require__(41);
    var SET = 'Set';
    module.exports = __webpack_require__(57)(SET, function (get) {
      return function Set() {
        return get(this, arguments.length > 0 ? arguments[0] : undefined);
      };
    }, {
      add: function add(value) {
        return strong.def(validate(this, SET), value = value === 0 ? 0 : value, value);
      }
    }, strong);
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var $export = __webpack_require__(1);
    var $at = __webpack_require__(407)(false);
    $export($export.P, 'String', {
      codePointAt: function codePointAt(pos) {
        return $at(this, pos);
      }
    });
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var $export = __webpack_require__(1);
    var toLength = __webpack_require__(21);
    var context = __webpack_require__(85);
    var ENDS_WITH = 'endsWith';
    var $endsWith = ''[ENDS_WITH];
    $export($export.P + $export.F * __webpack_require__(77)(ENDS_WITH), 'String', {
      endsWith: function endsWith(searchString) {
        var that = context(this, searchString, ENDS_WITH);
        var endPosition = arguments.length > 1 ? arguments[1] : undefined;
        var len = toLength(that.length);
        var end = endPosition === undefined ? len : Math.min(toLength(endPosition), len);
        var search = String(searchString);
        return $endsWith ? $endsWith.call(that, search, end) : that.slice(end - search.length, end) === search;
      }
    });
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    var toAbsoluteIndex = __webpack_require__(63);
    var fromCharCode = String.fromCharCode;
    var $fromCodePoint = String.fromCodePoint;
    $export($export.S + $export.F * (!!$fromCodePoint && $fromCodePoint.length != 1), 'String', {
      fromCodePoint: function fromCodePoint(x) {
        var res = [];
        var aLen = arguments.length;
        var i = 0;
        var code;
        while (aLen > i) {
          code = +arguments[i++];
          if (toAbsoluteIndex(code, 0x10ffff) !== code) throw RangeError(code + ' is not a valid code point');
          res.push(code < 0x10000 ? fromCharCode(code) : fromCharCode(((code -= 0x10000) >> 10) + 0xd800, code % 0x400 + 0xdc00));
        }
        return res.join('');
      }
    });
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var $export = __webpack_require__(1);
    var context = __webpack_require__(85);
    var INCLUDES = 'includes';
    $export($export.P + $export.F * __webpack_require__(77)(INCLUDES), 'String', {
      includes: function includes(searchString) {
        return !!~context(this, searchString, INCLUDES).indexOf(searchString, arguments.length > 1 ? arguments[1] : undefined);
      }
    });
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    var toIObject = __webpack_require__(27);
    var toLength = __webpack_require__(21);
    $export($export.S, 'String', {
      raw: function raw(callSite) {
        var tpl = toIObject(callSite.raw);
        var len = toLength(tpl.length);
        var aLen = arguments.length;
        var res = [];
        var i = 0;
        while (len > i) {
          res.push(String(tpl[i++]));
          if (i < aLen) res.push(String(arguments[i]));
        }
        return res.join('');
      }
    });
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    $export($export.P, 'String', {
      repeat: __webpack_require__(290)
    });
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var $export = __webpack_require__(1);
    var toLength = __webpack_require__(21);
    var context = __webpack_require__(85);
    var STARTS_WITH = 'startsWith';
    var $startsWith = ''[STARTS_WITH];
    $export($export.P + $export.F * __webpack_require__(77)(STARTS_WITH), 'String', {
      startsWith: function startsWith(searchString) {
        var that = context(this, searchString, STARTS_WITH);
        var index = toLength(Math.min(arguments.length > 1 ? arguments[1] : undefined, that.length));
        var search = String(searchString);
        return $startsWith ? $startsWith.call(that, search, index) : that.slice(index, index + search.length) === search;
      }
    });
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var global = __webpack_require__(10);
    var has = __webpack_require__(26);
    var DESCRIPTORS = __webpack_require__(20);
    var $export = __webpack_require__(1);
    var redefine = __webpack_require__(32);
    var META = __webpack_require__(47).KEY;
    var $fails = __webpack_require__(25);
    var shared = __webpack_require__(84);
    var setToStringTag = __webpack_require__(50);
    var uid = __webpack_require__(51);
    var wks = __webpack_require__(8);
    var wksExt = __webpack_require__(291);
    var wksDefine = __webpack_require__(408);
    var enumKeys = __webpack_require__(393);
    var isArray = __webpack_require__(277);
    var anObject = __webpack_require__(17);
    var toIObject = __webpack_require__(27);
    var toPrimitive = __webpack_require__(87);
    var createDesc = __webpack_require__(49);
    var _create = __webpack_require__(80);
    var gOPNExt = __webpack_require__(400);
    var $GOPD = __webpack_require__(81);
    var $DP = __webpack_require__(18);
    var $keys = __webpack_require__(39);
    var gOPD = $GOPD.f;
    var dP = $DP.f;
    var gOPN = gOPNExt.f;
    var $Symbol = global.Symbol;
    var $JSON = global.JSON;
    var _stringify = $JSON && $JSON.stringify;
    var PROTOTYPE = 'prototype';
    var HIDDEN = wks('_hidden');
    var TO_PRIMITIVE = wks('toPrimitive');
    var isEnum = {}.propertyIsEnumerable;
    var SymbolRegistry = shared('symbol-registry');
    var AllSymbols = shared('symbols');
    var OPSymbols = shared('op-symbols');
    var ObjectProto = Object[PROTOTYPE];
    var USE_NATIVE = typeof $Symbol == 'function';
    var QObject = global.QObject;
    var setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;
    var setSymbolDesc = DESCRIPTORS && $fails(function () {
      return _create(dP({}, 'a', {
        get: function () {
          return dP(this, 'a', {
            value: 7
          }).a;
        }
      })).a != 7;
    }) ? function (it, key, D) {
      var protoDesc = gOPD(ObjectProto, key);
      if (protoDesc) delete ObjectProto[key];
      dP(it, key, D);
      if (protoDesc && it !== ObjectProto) dP(ObjectProto, key, protoDesc);
    } : dP;
    var wrap = function (tag) {
      var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);
      sym._k = tag;
      return sym;
    };
    var isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function (it) {
      return typeof it == 'symbol';
    } : function (it) {
      return it instanceof $Symbol;
    };
    var $defineProperty = function defineProperty(it, key, D) {
      if (it === ObjectProto) $defineProperty(OPSymbols, key, D);
      anObject(it);
      key = toPrimitive(key, true);
      anObject(D);
      if (has(AllSymbols, key)) {
        if (!D.enumerable) {
          if (!has(it, HIDDEN)) dP(it, HIDDEN, createDesc(1, {}));
          it[HIDDEN][key] = true;
        } else {
          if (has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false;
          D = _create(D, {
            enumerable: createDesc(0, false)
          });
        }
        return setSymbolDesc(it, key, D);
      }
      return dP(it, key, D);
    };
    var $defineProperties = function defineProperties(it, P) {
      anObject(it);
      var keys = enumKeys(P = toIObject(P));
      var i = 0;
      var l = keys.length;
      var key;
      while (l > i) $defineProperty(it, key = keys[i++], P[key]);
      return it;
    };
    var $create = function create(it, P) {
      return P === undefined ? _create(it) : $defineProperties(_create(it), P);
    };
    var $propertyIsEnumerable = function propertyIsEnumerable(key) {
      var E = isEnum.call(this, key = toPrimitive(key, true));
      if (this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return false;
      return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;
    };
    var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) {
      it = toIObject(it);
      key = toPrimitive(key, true);
      if (it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return;
      var D = gOPD(it, key);
      if (D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) D.enumerable = true;
      return D;
    };
    var $getOwnPropertyNames = function getOwnPropertyNames(it) {
      var names = gOPN(toIObject(it));
      var result = [];
      var i = 0;
      var key;
      while (names.length > i) {
        if (!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META) result.push(key);
      }
      return result;
    };
    var $getOwnPropertySymbols = function getOwnPropertySymbols(it) {
      var IS_OP = it === ObjectProto;
      var names = gOPN(IS_OP ? OPSymbols : toIObject(it));
      var result = [];
      var i = 0;
      var key;
      while (names.length > i) {
        if (has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true)) result.push(AllSymbols[key]);
      }
      return result;
    };
    if (!USE_NATIVE) {
      $Symbol = function Symbol() {
        if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor!');
        var tag = uid(arguments.length > 0 ? arguments[0] : undefined);
        var $set = function (value) {
          if (this === ObjectProto) $set.call(OPSymbols, value);
          if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false;
          setSymbolDesc(this, tag, createDesc(1, value));
        };
        if (DESCRIPTORS && setter) setSymbolDesc(ObjectProto, tag, {
          configurable: true,
          set: $set
        });
        return wrap(tag);
      };
      redefine($Symbol[PROTOTYPE], 'toString', function toString() {
        return this._k;
      });
      $GOPD.f = $getOwnPropertyDescriptor;
      $DP.f = $defineProperty;
      __webpack_require__(82).f = gOPNExt.f = $getOwnPropertyNames;
      __webpack_require__(48).f = $propertyIsEnumerable;
      __webpack_require__(61).f = $getOwnPropertySymbols;
      if (DESCRIPTORS && !__webpack_require__(60)) {
        redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
      }
      wksExt.f = function (name) {
        return wrap(wks(name));
      };
    }
    $export($export.G + $export.W + $export.F * !USE_NATIVE, {
      Symbol: $Symbol
    });
    for (var es6Symbols = ('hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables').split(','), j = 0; es6Symbols.length > j;) wks(es6Symbols[j++]);
    for (var wellKnownSymbols = $keys(wks.store), k = 0; wellKnownSymbols.length > k;) wksDefine(wellKnownSymbols[k++]);
    $export($export.S + $export.F * !USE_NATIVE, 'Symbol', {
      'for': function (key) {
        return has(SymbolRegistry, key += '') ? SymbolRegistry[key] : SymbolRegistry[key] = $Symbol(key);
      },
      keyFor: function keyFor(sym) {
        if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol!');
        for (var key in SymbolRegistry)
          if (SymbolRegistry[key] === sym) return key;
      },
      useSetter: function () {
        setter = true;
      },
      useSimple: function () {
        setter = false;
      }
    });
    $export($export.S + $export.F * !USE_NATIVE, 'Object', {
      create: $create,
      defineProperty: $defineProperty,
      defineProperties: $defineProperties,
      getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
      getOwnPropertyNames: $getOwnPropertyNames,
      getOwnPropertySymbols: $getOwnPropertySymbols
    });
    $JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function () {
      var S = $Symbol();
      return _stringify([S]) != '[null]' || _stringify({
        a: S
      }) != '{}' || _stringify(Object(S)) != '{}';
    })), 'JSON', {
      stringify: function stringify(it) {
        if (it === undefined || isSymbol(it)) return;
        var args = [it];
        var i = 1;
        var replacer, $replacer;
        while (arguments.length > i) args.push(arguments[i++]);
        replacer = args[1];
        if (typeof replacer == 'function') $replacer = replacer;
        if ($replacer || !isArray(replacer)) replacer = function (key, value) {
          if ($replacer) value = $replacer.call(this, key, value);
          if (!isSymbol(value)) return value;
        };
        args[1] = replacer;
        return _stringify.apply($JSON, args);
      }
    });
    $Symbol[PROTOTYPE][TO_PRIMITIVE] || __webpack_require__(31)($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);
    setToStringTag($Symbol, 'Symbol');
    setToStringTag(Math, 'Math', true);
    setToStringTag(global.JSON, 'JSON', true);
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var each = __webpack_require__(56)(0);
    var redefine = __webpack_require__(32);
    var meta = __webpack_require__(47);
    var assign = __webpack_require__(284);
    var weak = __webpack_require__(273);
    var isObject = __webpack_require__(12);
    var fails = __webpack_require__(25);
    var validate = __webpack_require__(41);
    var WEAK_MAP = 'WeakMap';
    var getWeak = meta.getWeak;
    var isExtensible = Object.isExtensible;
    var uncaughtFrozenStore = weak.ufstore;
    var tmp = {};
    var InternalMap;
    var wrapper = function (get) {
      return function WeakMap() {
        return get(this, arguments.length > 0 ? arguments[0] : undefined);
      };
    };
    var methods = {
      get: function get(key) {
        if (isObject(key)) {
          var data = getWeak(key);
          if (data === true) return uncaughtFrozenStore(validate(this, WEAK_MAP)).get(key);
          return data ? data[this._i] : undefined;
        }
      },
      set: function set(key, value) {
        return weak.def(validate(this, WEAK_MAP), key, value);
      }
    };
    var $WeakMap = module.exports = __webpack_require__(57)(WEAK_MAP, wrapper, methods, weak, true, true);
    if (fails(function () {
      return new $WeakMap().set((Object.freeze || Object)(tmp), 7).get(tmp) != 7;
    })) {
      InternalMap = weak.getConstructor(wrapper, WEAK_MAP);
      assign(InternalMap.prototype, methods);
      meta.NEED = true;
      each(['delete', 'has', 'get', 'set'], function (key) {
        var proto = $WeakMap.prototype;
        var method = proto[key];
        redefine(proto, key, function (a, b) {
          if (isObject(a) && !isExtensible(a)) {
            if (!this._f) this._f = new InternalMap();
            var result = this._f[key](a, b);
            return key == 'set' ? this : result;
          }
          return method.call(this, a, b);
        });
      });
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var weak = __webpack_require__(273);
    var validate = __webpack_require__(41);
    var WEAK_SET = 'WeakSet';
    __webpack_require__(57)(WEAK_SET, function (get) {
      return function WeakSet() {
        return get(this, arguments.length > 0 ? arguments[0] : undefined);
      };
    }, {
      add: function add(value) {
        return weak.def(validate(this, WEAK_SET), value, true);
      }
    }, weak, false, true);
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var $export = __webpack_require__(1);
    var $includes = __webpack_require__(270)(true);
    $export($export.P, 'Array', {
      includes: function includes(el) {
        return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
      }
    });
    __webpack_require__(37)('includes');
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    var $entries = __webpack_require__(286)(true);
    $export($export.S, 'Object', {
      entries: function entries(it) {
        return $entries(it);
      }
    });
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    var ownKeys = __webpack_require__(402);
    var toIObject = __webpack_require__(27);
    var gOPD = __webpack_require__(81);
    var createProperty = __webpack_require__(74);
    $export($export.S, 'Object', {
      getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object) {
        var O = toIObject(object);
        var getDesc = gOPD.f;
        var keys = ownKeys(O);
        var result = {};
        var i = 0;
        var key, desc;
        while (keys.length > i) {
          desc = getDesc(O, key = keys[i++]);
          if (desc !== undefined) createProperty(result, key, desc);
        }
        return result;
      }
    });
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    var $values = __webpack_require__(286)(false);
    $export($export.S, 'Object', {
      values: function values(it) {
        return $values(it);
      }
    });
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var $export = __webpack_require__(1);
    var $pad = __webpack_require__(289);
    $export($export.P, 'String', {
      padEnd: function padEnd(maxLength) {
        return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, false);
      }
    });
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var $export = __webpack_require__(1);
    var $pad = __webpack_require__(289);
    $export($export.P, 'String', {
      padStart: function padStart(maxLength) {
        return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, true);
      }
    });
  }), (function (module, exports, __webpack_require__) {
    var $iterators = __webpack_require__(70);
    var getKeys = __webpack_require__(39);
    var redefine = __webpack_require__(32);
    var global = __webpack_require__(10);
    var hide = __webpack_require__(31);
    var Iterators = __webpack_require__(46);
    var wks = __webpack_require__(8);
    var ITERATOR = wks('iterator');
    var TO_STRING_TAG = wks('toStringTag');
    var ArrayValues = Iterators.Array;
    var DOMIterables = {
      CSSRuleList: true,
      CSSStyleDeclaration: false,
      CSSValueList: false,
      ClientRectList: false,
      DOMRectList: false,
      DOMStringList: false,
      DOMTokenList: true,
      DataTransferItemList: false,
      FileList: false,
      HTMLAllCollection: false,
      HTMLCollection: false,
      HTMLFormElement: false,
      HTMLSelectElement: false,
      MediaList: true,
      MimeTypeArray: false,
      NamedNodeMap: false,
      NodeList: true,
      PaintRequestList: false,
      Plugin: false,
      PluginArray: false,
      SVGLengthList: false,
      SVGNumberList: false,
      SVGPathSegList: false,
      SVGPointList: false,
      SVGStringList: false,
      SVGTransformList: false,
      SourceBufferList: false,
      StyleSheetList: true,
      TextTrackCueList: false,
      TextTrackList: false,
      TouchList: false
    };
    for (var collections = getKeys(DOMIterables), i = 0; i < collections.length; i++) {
      var NAME = collections[i];
      var explicit = DOMIterables[NAME];
      var Collection = global[NAME];
      var proto = Collection && Collection.prototype;
      var key;
      if (proto) {
        if (!proto[ITERATOR]) hide(proto, ITERATOR, ArrayValues);
        if (!proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME);
        Iterators[NAME] = ArrayValues;
        if (explicit)
          for (key in $iterators)
            if (!proto[key]) redefine(proto, key, $iterators[key], true);
      }
    }
  }), (function (module, exports, __webpack_require__) {
    var $export = __webpack_require__(1);
    var $task = __webpack_require__(86);
    $export($export.G + $export.B, {
      setImmediate: $task.set,
      clearImmediate: $task.clear
    });
  }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports, __webpack_require__) {
    "use strict";
    (function (global) {
      "use strict";

      function countQuotes(str) {
        return str.split('"').length - 1;
      }
      var SheetClip = {
        parse: function parse(str) {
          var r, rLen, rows, arr = [],
            a = 0,
            c, cLen, multiline, last;
          rows = str.split('\n');
          if (rows.length > 1 && rows[rows.length - 1] === '') {
            rows.pop();
          }
          for (r = 0, rLen = rows.length; r < rLen; r += 1) {
            rows[r] = rows[r].split('\t');
            for (c = 0, cLen = rows[r].length; c < cLen; c += 1) {
              if (!arr[a]) {
                arr[a] = [];
              }
              if (multiline && c === 0) {
                last = arr[a].length - 1;
                arr[a][last] = arr[a][last] + '\n' + rows[r][0];
                if (multiline && countQuotes(rows[r][0]) & 1) {
                  multiline = false;
                  arr[a][last] = arr[a][last].substring(0, arr[a][last].length - 1).replace(/""/g, '"');
                }
              } else {
                if (c === cLen - 1 && rows[r][c].indexOf('"') === 0 && countQuotes(rows[r][c]) & 1) {
                  arr[a].push(rows[r][c].substring(1).replace(/""/g, '"'));
                  multiline = true;
                } else {
                  arr[a].push(rows[r][c].replace(/""/g, '"'));
                  multiline = false;
                }
              }
            }
            if (!multiline) {
              a += 1;
            }
          }
          return arr;
        },
        stringify: function stringify(arr) {
          var r, rLen, c, cLen, str = '',
            val;
          for (r = 0, rLen = arr.length; r < rLen; r += 1) {
            cLen = arr[r].length;
            for (c = 0; c < cLen; c += 1) {
              if (c > 0) {
                str += '\t';
              }
              val = arr[r][c];
              if (typeof val === 'string') {
                if (val.indexOf('\n') > -1) {
                  str += '"' + val.replace(/"/g, '""') + '"';
                } else {
                  str += val;
                }
              } else if (val === null || val === void 0) {
                str += '';
              } else {
                str += val;
              }
            }
            if (r !== rLen - 1) {
              str += '\n';
            }
          }
          return str;
        }
      };
      if (true) {
        exports.parse = SheetClip.parse;
        exports.stringify = SheetClip.stringify;
      } else {
        global.SheetClip = SheetClip;
      }
    })(window);
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _element = __webpack_require__(0);
    var _event = __webpack_require__(7);
    var _object = __webpack_require__(3);
    var _browser = __webpack_require__(22);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _coords = __webpack_require__(43);
    var _coords2 = _interopRequireDefault(_coords);
    var _base = __webpack_require__(29);
    var _base2 = _interopRequireDefault(_base);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var Border = function () {
      function Border(wotInstance, settings) {
        _classCallCheck(this, Border);
        if (!settings) {
          return;
        }
        this.eventManager = new _eventManager2.default(wotInstance);
        this.instance = wotInstance;
        this.wot = wotInstance;
        this.settings = settings;
        this.mouseDown = false;
        this.main = null;
        this.top = null;
        this.left = null;
        this.bottom = null;
        this.right = null;
        this.topStyle = null;
        this.leftStyle = null;
        this.bottomStyle = null;
        this.rightStyle = null;
        this.cornerDefaultStyle = {
          width: '5px',
          height: '5px',
          borderWidth: '2px',
          borderStyle: 'solid',
          borderColor: '#FFF'
        };
        this.corner = null;
        this.cornerStyle = null;
        this.createBorders(settings);
        this.registerListeners();
      }
      _createClass(Border, [{
        key: 'registerListeners',
        value: function registerListeners() {
          var _this2 = this;
          this.eventManager.addEventListener(document.body, 'mousedown', function () {
            return _this2.onMouseDown();
          });
          this.eventManager.addEventListener(document.body, 'mouseup', function () {
            return _this2.onMouseUp();
          });
          var _loop = function _loop(c, len) {
            _this2.eventManager.addEventListener(_this2.main.childNodes[c], 'mouseenter', function (event) {
              return _this2.onMouseEnter(event, _this2.main.childNodes[c]);
            });
          };
          for (var c = 0, len = this.main.childNodes.length; c < len; c++) {
            _loop(c, len);
          }
        }
      }, {
        key: 'onMouseDown',
        value: function onMouseDown() {
          this.mouseDown = true;
        }
      }, {
        key: 'onMouseUp',
        value: function onMouseUp() {
          this.mouseDown = false;
        }
      }, {
        key: 'onMouseEnter',
        value: function onMouseEnter(event, parentElement) {
          if (!this.mouseDown || !this.wot.getSetting('hideBorderOnMouseDownOver')) {
            return;
          }
          event.preventDefault();
          (0, _event.stopImmediatePropagation)(event);
          var _this = this;
          var bounds = parentElement.getBoundingClientRect();
          parentElement.style.display = 'none';

          function isOutside(event) {
            if (event.clientY < Math.floor(bounds.top)) {
              return true;
            }
            if (event.clientY > Math.ceil(bounds.top + bounds.height)) {
              return true;
            }
            if (event.clientX < Math.floor(bounds.left)) {
              return true;
            }
            if (event.clientX > Math.ceil(bounds.left + bounds.width)) {
              return true;
            }
          }

          function handler(event) {
            if (isOutside(event)) {
              _this.eventManager.removeEventListener(document.body, 'mousemove', handler);
              parentElement.style.display = 'block';
            }
          }
          this.eventManager.addEventListener(document.body, 'mousemove', handler);
        }
      }, {
        key: 'createBorders',
        value: function createBorders(settings) {
          this.main = document.createElement('div');
          var borderDivs = ['top', 'left', 'bottom', 'right', 'corner'];
          var style = this.main.style;
          style.position = 'absolute';
          style.top = 0;
          style.left = 0;
          for (var i = 0; i < 5; i++) {
            var position = borderDivs[i];
            var div = document.createElement('div');
            div.className = 'wtBorder ' + (this.settings.className || '');
            if (this.settings[position] && this.settings[position].hide) {
              div.className += ' hidden';
            }
            style = div.style;
            style.backgroundColor = this.settings[position] && this.settings[position].color ? this.settings[position].color : settings.border.color;
            style.height = this.settings[position] && this.settings[position].width ? this.settings[position].width + 'px' : settings.border.width + 'px';
            style.width = this.settings[position] && this.settings[position].width ? this.settings[position].width + 'px' : settings.border.width + 'px';
            this.main.appendChild(div);
          }
          this.top = this.main.childNodes[0];
          this.left = this.main.childNodes[1];
          this.bottom = this.main.childNodes[2];
          this.right = this.main.childNodes[3];
          this.topStyle = this.top.style;
          this.leftStyle = this.left.style;
          this.bottomStyle = this.bottom.style;
          this.rightStyle = this.right.style;
          this.corner = this.main.childNodes[4];
          this.corner.className += ' corner';
          this.cornerStyle = this.corner.style;
          this.cornerStyle.width = this.cornerDefaultStyle.width;
          this.cornerStyle.height = this.cornerDefaultStyle.height;
          this.cornerStyle.border = [this.cornerDefaultStyle.borderWidth, this.cornerDefaultStyle.borderStyle, this.cornerDefaultStyle.borderColor].join(' ');
          if ((0, _browser.isMobileBrowser)()) {
            this.createMultipleSelectorHandles();
          }
          this.disappear();
          if (!this.wot.wtTable.bordersHolder) {
            this.wot.wtTable.bordersHolder = document.createElement('div');
            this.wot.wtTable.bordersHolder.className = 'htBorders';
            this.wot.wtTable.spreader.appendChild(this.wot.wtTable.bordersHolder);
          }
          this.wot.wtTable.bordersHolder.insertBefore(this.main, this.wot.wtTable.bordersHolder.firstChild);
        }
      }, {
        key: 'createMultipleSelectorHandles',
        value: function createMultipleSelectorHandles() {
          this.selectionHandles = {
            topLeft: document.createElement('DIV'),
            topLeftHitArea: document.createElement('DIV'),
            bottomRight: document.createElement('DIV'),
            bottomRightHitArea: document.createElement('DIV')
          };
          var width = 10;
          var hitAreaWidth = 40;
          this.selectionHandles.topLeft.className = 'topLeftSelectionHandle';
          this.selectionHandles.topLeftHitArea.className = 'topLeftSelectionHandle-HitArea';
          this.selectionHandles.bottomRight.className = 'bottomRightSelectionHandle';
          this.selectionHandles.bottomRightHitArea.className = 'bottomRightSelectionHandle-HitArea';
          this.selectionHandles.styles = {
            topLeft: this.selectionHandles.topLeft.style,
            topLeftHitArea: this.selectionHandles.topLeftHitArea.style,
            bottomRight: this.selectionHandles.bottomRight.style,
            bottomRightHitArea: this.selectionHandles.bottomRightHitArea.style
          };
          var hitAreaStyle = {
            position: 'absolute',
            height: hitAreaWidth + 'px',
            width: hitAreaWidth + 'px',
            'border-radius': parseInt(hitAreaWidth / 1.5, 10) + 'px'
          };
          for (var prop in hitAreaStyle) {
            if ((0, _object.hasOwnProperty)(hitAreaStyle, prop)) {
              this.selectionHandles.styles.bottomRightHitArea[prop] = hitAreaStyle[prop];
              this.selectionHandles.styles.topLeftHitArea[prop] = hitAreaStyle[prop];
            }
          }
          var handleStyle = {
            position: 'absolute',
            height: width + 'px',
            width: width + 'px',
            'border-radius': parseInt(width / 1.5, 10) + 'px',
            background: '#F5F5FF',
            border: '1px solid #4285c8'
          };
          for (var _prop in handleStyle) {
            if ((0, _object.hasOwnProperty)(handleStyle, _prop)) {
              this.selectionHandles.styles.bottomRight[_prop] = handleStyle[_prop];
              this.selectionHandles.styles.topLeft[_prop] = handleStyle[_prop];
            }
          }
          this.main.appendChild(this.selectionHandles.topLeft);
          this.main.appendChild(this.selectionHandles.bottomRight);
          this.main.appendChild(this.selectionHandles.topLeftHitArea);
          this.main.appendChild(this.selectionHandles.bottomRightHitArea);
        }
      }, {
        key: 'isPartRange',
        value: function isPartRange(row, col) {
          if (this.wot.selections.area.cellRange) {
            if (row != this.wot.selections.area.cellRange.to.row || col != this.wot.selections.area.cellRange.to.col) {
              return true;
            }
          }
          return false;
        }
      }, {
        key: 'updateMultipleSelectionHandlesPosition',
        value: function updateMultipleSelectionHandlesPosition(row, col, top, left, width, height) {
          var handleWidth = parseInt(this.selectionHandles.styles.topLeft.width, 10);
          var hitAreaWidth = parseInt(this.selectionHandles.styles.topLeftHitArea.width, 10);
          this.selectionHandles.styles.topLeft.top = parseInt(top - handleWidth, 10) + 'px';
          this.selectionHandles.styles.topLeft.left = parseInt(left - handleWidth, 10) + 'px';
          this.selectionHandles.styles.topLeftHitArea.top = parseInt(top - hitAreaWidth / 4 * 3, 10) + 'px';
          this.selectionHandles.styles.topLeftHitArea.left = parseInt(left - hitAreaWidth / 4 * 3, 10) + 'px';
          this.selectionHandles.styles.bottomRight.top = parseInt(top + height, 10) + 'px';
          this.selectionHandles.styles.bottomRight.left = parseInt(left + width, 10) + 'px';
          this.selectionHandles.styles.bottomRightHitArea.top = parseInt(top + height - hitAreaWidth / 4, 10) + 'px';
          this.selectionHandles.styles.bottomRightHitArea.left = parseInt(left + width - hitAreaWidth / 4, 10) + 'px';
          if (this.settings.border.multipleSelectionHandlesVisible && this.settings.border.multipleSelectionHandlesVisible()) {
            this.selectionHandles.styles.topLeft.display = 'block';
            this.selectionHandles.styles.topLeftHitArea.display = 'block';
            if (this.isPartRange(row, col)) {
              this.selectionHandles.styles.bottomRight.display = 'none';
              this.selectionHandles.styles.bottomRightHitArea.display = 'none';
            } else {
              this.selectionHandles.styles.bottomRight.display = 'block';
              this.selectionHandles.styles.bottomRightHitArea.display = 'block';
            }
          } else {
            this.selectionHandles.styles.topLeft.display = 'none';
            this.selectionHandles.styles.bottomRight.display = 'none';
            this.selectionHandles.styles.topLeftHitArea.display = 'none';
            this.selectionHandles.styles.bottomRightHitArea.display = 'none';
          }
          if (row == this.wot.wtSettings.getSetting('fixedRowsTop') || col == this.wot.wtSettings.getSetting('fixedColumnsLeft')) {
            this.selectionHandles.styles.topLeft.zIndex = '9999';
            this.selectionHandles.styles.topLeftHitArea.zIndex = '9999';
          } else {
            this.selectionHandles.styles.topLeft.zIndex = '';
            this.selectionHandles.styles.topLeftHitArea.zIndex = '';
          }
        }
      }, {
        key: 'appear',
        value: function appear(corners) {
          if (this.disabled) {
            return;
          }
          var isMultiple, fromTD, toTD, fromOffset, toOffset, containerOffset, top, minTop, left, minLeft, height, width, fromRow, fromColumn, toRow, toColumn, trimmingContainer, cornerOverlappingContainer, ilen;
          ilen = this.wot.wtTable.getRenderedRowsCount();
          for (var i = 0; i < ilen; i++) {
            var s = this.wot.wtTable.rowFilter.renderedToSource(i);
            if (s >= corners[0] && s <= corners[2]) {
              fromRow = s;
              break;
            }
          }
          for (var _i = ilen - 1; _i >= 0; _i--) {
            var _s = this.wot.wtTable.rowFilter.renderedToSource(_i);
            if (_s >= corners[0] && _s <= corners[2]) {
              toRow = _s;
              break;
            }
          }
          ilen = this.wot.wtTable.getRenderedColumnsCount();
          for (var _i2 = 0; _i2 < ilen; _i2++) {
            var _s2 = this.wot.wtTable.columnFilter.renderedToSource(_i2);
            if (_s2 >= corners[1] && _s2 <= corners[3]) {
              fromColumn = _s2;
              break;
            }
          }
          for (var _i3 = ilen - 1; _i3 >= 0; _i3--) {
            var _s3 = this.wot.wtTable.columnFilter.renderedToSource(_i3);
            if (_s3 >= corners[1] && _s3 <= corners[3]) {
              toColumn = _s3;
              break;
            }
          }
          if (fromRow === void 0 || fromColumn === void 0) {
            this.disappear();
            return;
          }
          isMultiple = fromRow !== toRow || fromColumn !== toColumn;
          fromTD = this.wot.wtTable.getCell(new _coords2.default(fromRow, fromColumn));
          toTD = isMultiple ? this.wot.wtTable.getCell(new _coords2.default(toRow, toColumn)) : fromTD;
          fromOffset = (0, _element.offset)(fromTD);
          toOffset = isMultiple ? (0, _element.offset)(toTD) : fromOffset;
          containerOffset = (0, _element.offset)(this.wot.wtTable.TABLE);
          minTop = fromOffset.top;
          height = toOffset.top + (0, _element.outerHeight)(toTD) - minTop;
          minLeft = fromOffset.left;
          width = toOffset.left + (0, _element.outerWidth)(toTD) - minLeft;
          top = minTop - containerOffset.top - 1;
          left = minLeft - containerOffset.left - 1;
          var style = (0, _element.getComputedStyle)(fromTD);
          if (parseInt(style.borderTopWidth, 10) > 0) {
            top += 1;
            height = height > 0 ? height - 1 : 0;
          }
          if (parseInt(style.borderLeftWidth, 10) > 0) {
            left += 1;
            width = width > 0 ? width - 1 : 0;
          }
          this.topStyle.top = top + 'px';
          this.topStyle.left = left + 'px';
          this.topStyle.width = width + 'px';
          this.topStyle.display = 'block';
          this.leftStyle.top = top + 'px';
          this.leftStyle.left = left + 'px';
          this.leftStyle.height = height + 'px';
          this.leftStyle.display = 'block';
          var delta = Math.floor(this.settings.border.width / 2);
          this.bottomStyle.top = top + height - delta + 'px';
          this.bottomStyle.left = left + 'px';
          this.bottomStyle.width = width + 'px';
          this.bottomStyle.display = 'block';
          this.rightStyle.top = top + 'px';
          this.rightStyle.left = left + width - delta + 'px';
          this.rightStyle.height = height + 1 + 'px';
          this.rightStyle.display = 'block';
          if ((0, _browser.isMobileBrowser)() || !this.hasSetting(this.settings.border.cornerVisible) || this.isPartRange(toRow, toColumn)) {
            this.cornerStyle.display = 'none';
          } else {
            this.cornerStyle.top = top + height - 4 + 'px';
            this.cornerStyle.left = left + width - 4 + 'px';
            this.cornerStyle.borderRightWidth = this.cornerDefaultStyle.borderWidth;
            this.cornerStyle.width = this.cornerDefaultStyle.width;
            this.cornerStyle.display = 'none';
            trimmingContainer = (0, _element.getTrimmingContainer)(this.wot.wtTable.TABLE);
            if (toColumn === this.wot.getSetting('totalColumns') - 1) {
              cornerOverlappingContainer = toTD.offsetLeft + (0, _element.outerWidth)(toTD) + parseInt(this.cornerDefaultStyle.width, 10) / 2 >= (0, _element.innerWidth)(trimmingContainer);
              if (cornerOverlappingContainer) {
                this.cornerStyle.left = Math.floor(left + width - 3 - parseInt(this.cornerDefaultStyle.width, 10) / 2) + 'px';
                this.cornerStyle.borderRightWidth = 0;
              }
            }
            if (toRow === this.wot.getSetting('totalRows') - 1) {
              cornerOverlappingContainer = toTD.offsetTop + (0, _element.outerHeight)(toTD) + parseInt(this.cornerDefaultStyle.height, 10) / 2 >= (0, _element.innerHeight)(trimmingContainer);
              if (cornerOverlappingContainer) {
                this.cornerStyle.top = Math.floor(top + height - 3 - parseInt(this.cornerDefaultStyle.height, 10) / 2) + 'px';
                this.cornerStyle.borderBottomWidth = 0;
              }
            }
            this.cornerStyle.display = 'block';
          }
          if ((0, _browser.isMobileBrowser)()) {
            this.updateMultipleSelectionHandlesPosition(fromRow, fromColumn, top, left, width, height);
          }
        }
      }, {
        key: 'disappear',
        value: function disappear() {
          this.topStyle.display = 'none';
          this.leftStyle.display = 'none';
          this.bottomStyle.display = 'none';
          this.rightStyle.display = 'none';
          this.cornerStyle.display = 'none';
          if ((0, _browser.isMobileBrowser)()) {
            this.selectionHandles.styles.topLeft.display = 'none';
            this.selectionHandles.styles.bottomRight.display = 'none';
          }
        }
      }, {
        key: 'hasSetting',
        value: function hasSetting(setting) {
          if (typeof setting === 'function') {
            return setting();
          }
          return !!setting;
        }
      }]);
      return Border;
    }();
    exports.default = Border;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var privatePool = new WeakMap();
    var ViewportColumnsCalculator = function () {
      _createClass(ViewportColumnsCalculator, null, [{
        key: 'DEFAULT_WIDTH',
        get: function get() {
          return 50;
        }
      }]);

      function ViewportColumnsCalculator(viewportWidth, scrollOffset, totalColumns, columnWidthFn, overrideFn, onlyFullyVisible, stretchH) {
        var stretchingColumnWidthFn = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : function (width) {
          return width;
        };
        _classCallCheck(this, ViewportColumnsCalculator);
        privatePool.set(this, {
          viewportWidth: viewportWidth,
          scrollOffset: scrollOffset,
          totalColumns: totalColumns,
          columnWidthFn: columnWidthFn,
          overrideFn: overrideFn,
          onlyFullyVisible: onlyFullyVisible,
          stretchingColumnWidthFn: stretchingColumnWidthFn
        });
        this.count = 0;
        this.startColumn = null;
        this.endColumn = null;
        this.startPosition = null;
        this.stretchAllRatio = 0;
        this.stretchLastWidth = 0;
        this.stretch = stretchH;
        this.totalTargetWidth = 0;
        this.needVerifyLastColumnWidth = true;
        this.stretchAllColumnsWidth = [];
        this.calculate();
      }
      _createClass(ViewportColumnsCalculator, [{
        key: 'calculate',
        value: function calculate() {
          var sum = 0;
          var needReverse = true;
          var startPositions = [];
          var columnWidth = void 0;
          var priv = privatePool.get(this);
          var onlyFullyVisible = priv.onlyFullyVisible;
          var overrideFn = priv.overrideFn;
          var scrollOffset = priv.scrollOffset;
          var totalColumns = priv.totalColumns;
          var viewportWidth = priv.viewportWidth;
          for (var i = 0; i < totalColumns; i++) {
            columnWidth = this._getColumnWidth(i);
            if (sum <= scrollOffset && !onlyFullyVisible) {
              this.startColumn = i;
            }
            var compensatedViewportWidth = scrollOffset > 0 ? viewportWidth + 1 : viewportWidth;
            if (sum >= scrollOffset && sum + columnWidth <= scrollOffset + compensatedViewportWidth) {
              if (this.startColumn == null) {
                this.startColumn = i;
              }
              this.endColumn = i;
            }
            startPositions.push(sum);
            sum += columnWidth;
            if (!onlyFullyVisible) {
              this.endColumn = i;
            }
            if (sum >= scrollOffset + viewportWidth) {
              needReverse = false;
              break;
            }
          }
          if (this.endColumn === totalColumns - 1 && needReverse) {
            this.startColumn = this.endColumn;
            while (this.startColumn > 0) {
              var viewportSum = startPositions[this.endColumn] + columnWidth - startPositions[this.startColumn - 1];
              if (viewportSum <= viewportWidth || !onlyFullyVisible) {
                this.startColumn--;
              }
              if (viewportSum > viewportWidth) {
                break;
              }
            }
          }
          if (this.startColumn !== null && overrideFn) {
            overrideFn(this);
          }
          this.startPosition = startPositions[this.startColumn];
          if (this.startPosition == void 0) {
            this.startPosition = null;
          }
          if (this.startColumn !== null) {
            this.count = this.endColumn - this.startColumn + 1;
          }
        }
      }, {
        key: 'refreshStretching',
        value: function refreshStretching(totalWidth) {
          if (this.stretch === 'none') {
            return;
          }
          this.totalTargetWidth = totalWidth;
          var priv = privatePool.get(this);
          var totalColumns = priv.totalColumns;
          var sumAll = 0;
          for (var i = 0; i < totalColumns; i++) {
            var columnWidth = this._getColumnWidth(i);
            var permanentColumnWidth = priv.stretchingColumnWidthFn(void 0, i);
            if (typeof permanentColumnWidth === 'number') {
              totalWidth -= permanentColumnWidth;
            } else {
              sumAll += columnWidth;
            }
          }
          var remainingSize = totalWidth - sumAll;
          if (this.stretch === 'all' && remainingSize > 0) {
            this.stretchAllRatio = totalWidth / sumAll;
            this.stretchAllColumnsWidth = [];
            this.needVerifyLastColumnWidth = true;
          } else if (this.stretch === 'last' && totalWidth !== Infinity) {
            var _columnWidth = this._getColumnWidth(totalColumns - 1);
            var lastColumnWidth = remainingSize + _columnWidth;
            this.stretchLastWidth = lastColumnWidth >= 0 ? lastColumnWidth : _columnWidth;
          }
        }
      }, {
        key: 'getStretchedColumnWidth',
        value: function getStretchedColumnWidth(column, baseWidth) {
          var result = null;
          if (this.stretch === 'all' && this.stretchAllRatio !== 0) {
            result = this._getStretchedAllColumnWidth(column, baseWidth);
          } else if (this.stretch === 'last' && this.stretchLastWidth !== 0) {
            result = this._getStretchedLastColumnWidth(column);
          }
          return result;
        }
      }, {
        key: '_getStretchedAllColumnWidth',
        value: function _getStretchedAllColumnWidth(column, baseWidth) {
          var sumRatioWidth = 0;
          var priv = privatePool.get(this);
          var totalColumns = priv.totalColumns;
          if (!this.stretchAllColumnsWidth[column]) {
            var stretchedWidth = Math.round(baseWidth * this.stretchAllRatio);
            var newStretchedWidth = priv.stretchingColumnWidthFn(stretchedWidth, column);
            if (newStretchedWidth === void 0) {
              this.stretchAllColumnsWidth[column] = stretchedWidth;
            } else {
              this.stretchAllColumnsWidth[column] = isNaN(newStretchedWidth) ? this._getColumnWidth(column) : newStretchedWidth;
            }
          }
          if (this.stretchAllColumnsWidth.length === totalColumns && this.needVerifyLastColumnWidth) {
            this.needVerifyLastColumnWidth = false;
            for (var i = 0; i < this.stretchAllColumnsWidth.length; i++) {
              sumRatioWidth += this.stretchAllColumnsWidth[i];
            }
            if (sumRatioWidth !== this.totalTargetWidth) {
              this.stretchAllColumnsWidth[this.stretchAllColumnsWidth.length - 1] += this.totalTargetWidth - sumRatioWidth;
            }
          }
          return this.stretchAllColumnsWidth[column];
        }
      }, {
        key: '_getStretchedLastColumnWidth',
        value: function _getStretchedLastColumnWidth(column) {
          var priv = privatePool.get(this);
          var totalColumns = priv.totalColumns;
          if (column === totalColumns - 1) {
            return this.stretchLastWidth;
          }
          return null;
        }
      }, {
        key: '_getColumnWidth',
        value: function _getColumnWidth(column) {
          var width = privatePool.get(this).columnWidthFn(column);
          if (width === void 0) {
            width = ViewportColumnsCalculator.DEFAULT_WIDTH;
          }
          return width;
        }
      }]);
      return ViewportColumnsCalculator;
    }();
    exports.default = ViewportColumnsCalculator;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var privatePool = new WeakMap();
    var ViewportRowsCalculator = function () {
      _createClass(ViewportRowsCalculator, null, [{
        key: "DEFAULT_HEIGHT",
        get: function get() {
          return 23;
        }
      }]);

      function ViewportRowsCalculator(viewportHeight, scrollOffset, totalRows, rowHeightFn, overrideFn, onlyFullyVisible, horizontalScrollbarHeight) {
        _classCallCheck(this, ViewportRowsCalculator);
        privatePool.set(this, {
          viewportHeight: viewportHeight,
          scrollOffset: scrollOffset,
          totalRows: totalRows,
          rowHeightFn: rowHeightFn,
          overrideFn: overrideFn,
          onlyFullyVisible: onlyFullyVisible,
          horizontalScrollbarHeight: horizontalScrollbarHeight
        });
        this.count = 0;
        this.startRow = null;
        this.endRow = null;
        this.startPosition = null;
        this.calculate();
      }
      _createClass(ViewportRowsCalculator, [{
        key: "calculate",
        value: function calculate() {
          var sum = 0;
          var needReverse = true;
          var startPositions = [];
          var priv = privatePool.get(this);
          var onlyFullyVisible = priv.onlyFullyVisible;
          var overrideFn = priv.overrideFn;
          var rowHeightFn = priv.rowHeightFn;
          var scrollOffset = priv.scrollOffset;
          var totalRows = priv.totalRows;
          var viewportHeight = priv.viewportHeight;
          var horizontalScrollbarHeight = priv.horizontalScrollbarHeight || 0;
          var rowHeight = void 0;
          for (var i = 0; i < totalRows; i++) {
            rowHeight = rowHeightFn(i);
            if (rowHeight === undefined) {
              rowHeight = ViewportRowsCalculator.DEFAULT_HEIGHT;
            }
            if (sum <= scrollOffset && !onlyFullyVisible) {
              this.startRow = i;
            }
            if (sum >= scrollOffset && sum + rowHeight <= scrollOffset + viewportHeight - horizontalScrollbarHeight) {
              if (this.startRow === null) {
                this.startRow = i;
              }
              this.endRow = i;
            }
            startPositions.push(sum);
            sum += rowHeight;
            if (!onlyFullyVisible) {
              this.endRow = i;
            }
            if (sum >= scrollOffset + viewportHeight - horizontalScrollbarHeight) {
              needReverse = false;
              break;
            }
          }
          if (this.endRow === totalRows - 1 && needReverse) {
            this.startRow = this.endRow;
            while (this.startRow > 0) {
              var viewportSum = startPositions[this.endRow] + rowHeight - startPositions[this.startRow - 1];
              if (viewportSum <= viewportHeight - horizontalScrollbarHeight || !onlyFullyVisible) {
                this.startRow--;
              }
              if (viewportSum >= viewportHeight - horizontalScrollbarHeight) {
                break;
              }
            }
          }
          if (this.startRow !== null && overrideFn) {
            overrideFn(this);
          }
          this.startPosition = startPositions[this.startRow];
          if (this.startPosition == void 0) {
            this.startPosition = null;
          }
          if (this.startRow !== null) {
            this.count = this.endRow - this.startRow + 1;
          }
        }
      }]);
      return ViewportRowsCalculator;
    }();
    exports.default = ViewportRowsCalculator;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _element = __webpack_require__(0);
    var _object = __webpack_require__(3);
    var _string = __webpack_require__(28);
    var _event = __webpack_require__(254);
    var _event2 = _interopRequireDefault(_event);
    var _overlays = __webpack_require__(257);
    var _overlays2 = _interopRequireDefault(_overlays);
    var _scroll = __webpack_require__(258);
    var _scroll2 = _interopRequireDefault(_scroll);
    var _settings = __webpack_require__(259);
    var _settings2 = _interopRequireDefault(_settings);
    var _table = __webpack_require__(260);
    var _table2 = _interopRequireDefault(_table);
    var _viewport = __webpack_require__(262);
    var _viewport2 = _interopRequireDefault(_viewport);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var Walkontable = function () {
      function Walkontable(settings) {
        _classCallCheck(this, Walkontable);
        var originalHeaders = [];
        this.guid = 'wt_' + (0, _string.randomString)();
        if (settings.cloneSource) {
          this.cloneSource = settings.cloneSource;
          this.cloneOverlay = settings.cloneOverlay;
          this.wtSettings = settings.cloneSource.wtSettings;
          this.wtTable = new _table2.default(this, settings.table, settings.wtRootElement);
          this.wtScroll = new _scroll2.default(this);
          this.wtViewport = settings.cloneSource.wtViewport;
          this.wtEvent = new _event2.default(this);
          this.selections = this.cloneSource.selections;
        } else {
          this.wtSettings = new _settings2.default(this, settings);
          this.wtTable = new _table2.default(this, settings.table);
          this.wtScroll = new _scroll2.default(this);
          this.wtViewport = new _viewport2.default(this);
          this.wtEvent = new _event2.default(this);
          this.selections = this.getSetting('selections');
          this.wtOverlays = new _overlays2.default(this);
          this.exportSettingsAsClassNames();
        }
        if (this.wtTable.THEAD.childNodes.length && this.wtTable.THEAD.childNodes[0].childNodes.length) {
          for (var c = 0, clen = this.wtTable.THEAD.childNodes[0].childNodes.length; c < clen; c++) {
            originalHeaders.push(this.wtTable.THEAD.childNodes[0].childNodes[c].innerHTML);
          }
          if (!this.getSetting('columnHeaders').length) {
            this.update('columnHeaders', [function (column, TH) {
              (0, _element.fastInnerText)(TH, originalHeaders[column]);
            }]);
          }
        }
        this.drawn = false;
        this.drawInterrupted = false;
      }
      _createClass(Walkontable, [{
        key: 'draw',
        value: function draw() {
          var fastDraw = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
          this.drawInterrupted = false;
          if (!fastDraw && !(0, _element.isVisible)(this.wtTable.TABLE)) {
            this.drawInterrupted = true;
          } else {
            this.wtTable.draw(fastDraw);
          }
          return this;
        }
      }, {
        key: 'getCell',
        value: function getCell(coords) {
          var topmost = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
          if (!topmost) {
            return this.wtTable.getCell(coords);
          }
          var totalRows = this.wtSettings.getSetting('totalRows');
          var fixedRowsTop = this.wtSettings.getSetting('fixedRowsTop');
          var fixedRowsBottom = this.wtSettings.getSetting('fixedRowsBottom');
          var fixedColumns = this.wtSettings.getSetting('fixedColumnsLeft');
          if (coords.row < fixedRowsTop && coords.col < fixedColumns) {
            return this.wtOverlays.topLeftCornerOverlay.clone.wtTable.getCell(coords);
          } else if (coords.row < fixedRowsTop) {
            return this.wtOverlays.topOverlay.clone.wtTable.getCell(coords);
          } else if (coords.col < fixedColumns && coords.row >= totalRows - fixedRowsBottom) {
            if (this.wtOverlays.bottomLeftCornerOverlay && this.wtOverlays.bottomLeftCornerOverlay.clone) {
              return this.wtOverlays.bottomLeftCornerOverlay.clone.wtTable.getCell(coords);
            }
          } else if (coords.col < fixedColumns) {
            return this.wtOverlays.leftOverlay.clone.wtTable.getCell(coords);
          } else if (coords.row < totalRows && coords.row > totalRows - fixedRowsBottom) {
            if (this.wtOverlays.bottomOverlay && this.wtOverlays.bottomOverlay.clone) {
              return this.wtOverlays.bottomOverlay.clone.wtTable.getCell(coords);
            }
          }
          return this.wtTable.getCell(coords);
        }
      }, {
        key: 'update',
        value: function update(settings, value) {
          return this.wtSettings.update(settings, value);
        }
      }, {
        key: 'scrollVertical',
        value: function scrollVertical(row) {
          this.wtOverlays.topOverlay.scrollTo(row);
          this.getSetting('onScrollVertically');
          return this;
        }
      }, {
        key: 'scrollHorizontal',
        value: function scrollHorizontal(column) {
          this.wtOverlays.leftOverlay.scrollTo(column);
          this.getSetting('onScrollHorizontally');
          return this;
        }
      }, {
        key: 'scrollViewport',
        value: function scrollViewport(coords) {
          this.wtScroll.scrollViewport(coords);
          return this;
        }
      }, {
        key: 'getViewport',
        value: function getViewport() {
          return [this.wtTable.getFirstVisibleRow(), this.wtTable.getFirstVisibleColumn(), this.wtTable.getLastVisibleRow(), this.wtTable.getLastVisibleColumn()];
        }
      }, {
        key: 'getOverlayName',
        value: function getOverlayName() {
          return this.cloneOverlay ? this.cloneOverlay.type : 'master';
        }
      }, {
        key: 'isOverlayName',
        value: function isOverlayName(name) {
          if (this.cloneOverlay) {
            return this.cloneOverlay.type === name;
          }
          return false;
        }
      }, {
        key: 'exportSettingsAsClassNames',
        value: function exportSettingsAsClassNames() {
          var _this = this;
          var toExport = {
            rowHeaders: ['array'],
            columnHeaders: ['array']
          };
          var allClassNames = [];
          var newClassNames = [];
          (0, _object.objectEach)(toExport, function (optionType, key) {
            if (optionType.indexOf('array') > -1 && _this.getSetting(key).length) {
              newClassNames.push('ht' + (0, _string.toUpperCaseFirst)(key));
            }
            allClassNames.push('ht' + (0, _string.toUpperCaseFirst)(key));
          });
          (0, _element.removeClass)(this.wtTable.wtRootElement.parentNode, allClassNames);
          (0, _element.addClass)(this.wtTable.wtRootElement.parentNode, newClassNames);
        }
      }, {
        key: 'getSetting',
        value: function getSetting(key, param1, param2, param3, param4) {
          return this.wtSettings.getSetting(key, param1, param2, param3, param4);
        }
      }, {
        key: 'hasSetting',
        value: function hasSetting(key) {
          return this.wtSettings.has(key);
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          this.wtOverlays.destroy();
          this.wtEvent.destroy();
        }
      }]);
      return Walkontable;
    }();
    exports.default = Walkontable;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _element = __webpack_require__(0);
    var _function = __webpack_require__(35);
    var _browser = __webpack_require__(22);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function Event(instance) {
      var that = this;
      var eventManager = new _eventManager2.default(instance);
      this.instance = instance;
      var dblClickOrigin = [null, null];
      this.dblClickTimeout = [null, null];
      var onMouseDown = function onMouseDown(event) {
        var activeElement = document.activeElement;
        var getParentNode = (0, _function.partial)(_element.getParent, event.realTarget);
        var realTarget = event.realTarget;
        if (realTarget === activeElement || getParentNode(0) === activeElement || getParentNode(1) === activeElement) {
          return;
        }
        var cell = that.parentCell(realTarget);
        if ((0, _element.hasClass)(realTarget, 'corner')) {
          that.instance.getSetting('onCellCornerMouseDown', event, realTarget);
        } else if (cell.TD) {
          if (that.instance.hasSetting('onCellMouseDown')) {
            that.instance.getSetting('onCellMouseDown', event, cell.coords, cell.TD, that.instance);
          }
        }
        if (event.button !== 2) {
          if (cell.TD) {
            dblClickOrigin[0] = cell.TD;
            clearTimeout(that.dblClickTimeout[0]);
            that.dblClickTimeout[0] = setTimeout(function () {
              dblClickOrigin[0] = null;
            }, 1000);
          }
        }
      };
      var onTouchMove = function onTouchMove(event) {
        that.instance.touchMoving = true;
      };
      var longTouchTimeout;
      var onTouchStart = function onTouchStart(event) {
        var container = this;
        eventManager.addEventListener(this, 'touchmove', onTouchMove);
        that.checkIfTouchMove = setTimeout(function () {
          if (that.instance.touchMoving === true) {
            that.instance.touchMoving = void 0;
            eventManager.removeEventListener('touchmove', onTouchMove, false);
          }
          onMouseDown(event);
        }, 30);
      };
      var onMouseOver = function onMouseOver(event) {
        var table, td, mainWOT;
        if (that.instance.hasSetting('onCellMouseOver')) {
          table = that.instance.wtTable.TABLE;
          td = (0, _element.closestDown)(event.realTarget, ['TD', 'TH'], table);
          mainWOT = that.instance.cloneSource || that.instance;
          if (td && td !== mainWOT.lastMouseOver && (0, _element.isChildOf)(td, table)) {
            mainWOT.lastMouseOver = td;
            that.instance.getSetting('onCellMouseOver', event, that.instance.wtTable.getCoords(td), td, that.instance);
          }
        }
      };
      var onMouseOut = function onMouseOut(event) {
        var table = void 0;
        var lastTD = void 0;
        var nextTD = void 0;
        if (that.instance.hasSetting('onCellMouseOut')) {
          table = that.instance.wtTable.TABLE;
          lastTD = (0, _element.closestDown)(event.realTarget, ['TD', 'TH'], table);
          nextTD = (0, _element.closestDown)(event.relatedTarget, ['TD', 'TH'], table);
          if (lastTD && lastTD !== nextTD && (0, _element.isChildOf)(lastTD, table)) {
            that.instance.getSetting('onCellMouseOut', event, that.instance.wtTable.getCoords(lastTD), lastTD, that.instance);
          }
        }
      };
      var onMouseUp = function onMouseUp(event) {
        if (event.button !== 2) {
          var cell = that.parentCell(event.realTarget);
          if (cell.TD === dblClickOrigin[0] && cell.TD === dblClickOrigin[1]) {
            if ((0, _element.hasClass)(event.realTarget, 'corner')) {
              that.instance.getSetting('onCellCornerDblClick', event, cell.coords, cell.TD, that.instance);
            } else {
              that.instance.getSetting('onCellDblClick', event, cell.coords, cell.TD, that.instance);
            }
            dblClickOrigin[0] = null;
            dblClickOrigin[1] = null;
          } else if (cell.TD === dblClickOrigin[0]) {
            that.instance.getSetting('onCellMouseUp', event, cell.coords, cell.TD, that.instance);
            dblClickOrigin[1] = cell.TD;
            clearTimeout(that.dblClickTimeout[1]);
            that.dblClickTimeout[1] = setTimeout(function () {
              dblClickOrigin[1] = null;
            }, 500);
          } else if (cell.TD && that.instance.hasSetting('onCellMouseUp')) {
            that.instance.getSetting('onCellMouseUp', event, cell.coords, cell.TD, that.instance);
          }
        }
      };
      var onTouchEnd = function onTouchEnd(event) {
        clearTimeout(longTouchTimeout);
        event.preventDefault();
        onMouseUp(event);
      };
      eventManager.addEventListener(this.instance.wtTable.holder, 'mousedown', onMouseDown);
      eventManager.addEventListener(this.instance.wtTable.TABLE, 'mouseover', onMouseOver);
      eventManager.addEventListener(this.instance.wtTable.TABLE, 'mouseout', onMouseOut);
      eventManager.addEventListener(this.instance.wtTable.holder, 'mouseup', onMouseUp);
      if (this.instance.wtTable.holder.parentNode.parentNode && (0, _browser.isMobileBrowser)() && !that.instance.wtTable.isWorkingOnClone()) {
        var classSelector = '.' + this.instance.wtTable.holder.parentNode.className.split(' ').join('.');
        eventManager.addEventListener(this.instance.wtTable.holder, 'touchstart', function (event) {
          that.instance.touchApplied = true;
          if ((0, _element.isChildOf)(event.target, classSelector)) {
            onTouchStart.call(event.target, event);
          }
        });
        eventManager.addEventListener(this.instance.wtTable.holder, 'touchend', function (event) {
          that.instance.touchApplied = false;
          if ((0, _element.isChildOf)(event.target, classSelector)) {
            onTouchEnd.call(event.target, event);
          }
        });
        if (!that.instance.momentumScrolling) {
          that.instance.momentumScrolling = {};
        }
        eventManager.addEventListener(this.instance.wtTable.holder, 'scroll', function (event) {
          clearTimeout(that.instance.momentumScrolling._timeout);
          if (!that.instance.momentumScrolling.ongoing) {
            that.instance.getSetting('onBeforeTouchScroll');
          }
          that.instance.momentumScrolling.ongoing = true;
          that.instance.momentumScrolling._timeout = setTimeout(function () {
            if (!that.instance.touchApplied) {
              that.instance.momentumScrolling.ongoing = false;
              that.instance.getSetting('onAfterMomentumScroll');
            }
          }, 200);
        });
      }
      eventManager.addEventListener(window, 'resize', function () {
        if (that.instance.getSetting('stretchH') !== 'none') {
          that.instance.draw();
        }
      });
      this.destroy = function () {
        clearTimeout(this.dblClickTimeout[0]);
        clearTimeout(this.dblClickTimeout[1]);
        eventManager.destroy();
      };
    }
    Event.prototype.parentCell = function (elem) {
      var cell = {};
      var TABLE = this.instance.wtTable.TABLE;
      var TD = (0, _element.closestDown)(elem, ['TD', 'TH'], TABLE);
      if (TD) {
        cell.coords = this.instance.wtTable.getCoords(TD);
        cell.TD = TD;
      } else if ((0, _element.hasClass)(elem, 'wtBorder') && (0, _element.hasClass)(elem, 'current')) {
        cell.coords = this.instance.selections.current.cellRange.highlight;
        cell.TD = this.instance.wtTable.getCell(cell.coords);
      } else if ((0, _element.hasClass)(elem, 'wtBorder') && (0, _element.hasClass)(elem, 'area')) {
        if (this.instance.selections.area.cellRange) {
          cell.coords = this.instance.selections.area.cellRange.to;
          cell.TD = this.instance.wtTable.getCell(cell.coords);
        }
      }
      return cell;
    };
    exports.default = Event;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var ColumnFilter = function () {
      function ColumnFilter(offset, total, countTH) {
        _classCallCheck(this, ColumnFilter);
        this.offset = offset;
        this.total = total;
        this.countTH = countTH;
      }
      _createClass(ColumnFilter, [{
        key: "offsetted",
        value: function offsetted(index) {
          return index + this.offset;
        }
      }, {
        key: "unOffsetted",
        value: function unOffsetted(index) {
          return index - this.offset;
        }
      }, {
        key: "renderedToSource",
        value: function renderedToSource(index) {
          return this.offsetted(index);
        }
      }, {
        key: "sourceToRendered",
        value: function sourceToRendered(index) {
          return this.unOffsetted(index);
        }
      }, {
        key: "offsettedTH",
        value: function offsettedTH(index) {
          return index - this.countTH;
        }
      }, {
        key: "unOffsettedTH",
        value: function unOffsettedTH(index) {
          return index + this.countTH;
        }
      }, {
        key: "visibleRowHeadedColumnToSourceColumn",
        value: function visibleRowHeadedColumnToSourceColumn(index) {
          return this.renderedToSource(this.offsettedTH(index));
        }
      }, {
        key: "sourceColumnToVisibleRowHeadedColumn",
        value: function sourceColumnToVisibleRowHeadedColumn(index) {
          return this.unOffsettedTH(this.sourceToRendered(index));
        }
      }]);
      return ColumnFilter;
    }();
    exports.default = ColumnFilter;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var RowFilter = function () {
      function RowFilter(offset, total, countTH) {
        _classCallCheck(this, RowFilter);
        this.offset = offset;
        this.total = total;
        this.countTH = countTH;
      }
      _createClass(RowFilter, [{
        key: "offsetted",
        value: function offsetted(index) {
          return index + this.offset;
        }
      }, {
        key: "unOffsetted",
        value: function unOffsetted(index) {
          return index - this.offset;
        }
      }, {
        key: "renderedToSource",
        value: function renderedToSource(index) {
          return this.offsetted(index);
        }
      }, {
        key: "sourceToRendered",
        value: function sourceToRendered(index) {
          return this.unOffsetted(index);
        }
      }, {
        key: "offsettedTH",
        value: function offsettedTH(index) {
          return index - this.countTH;
        }
      }, {
        key: "unOffsettedTH",
        value: function unOffsettedTH(index) {
          return index + this.countTH;
        }
      }, {
        key: "visibleColHeadedRowToSourceRow",
        value: function visibleColHeadedRowToSourceRow(index) {
          return this.renderedToSource(this.offsettedTH(index));
        }
      }, {
        key: "sourceRowToVisibleColHeadedRow",
        value: function sourceRowToVisibleColHeadedRow(index) {
          return this.unOffsettedTH(this.sourceToRendered(index));
        }
      }]);
      return RowFilter;
    }();
    exports.default = RowFilter;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _element = __webpack_require__(0);
    var _array = __webpack_require__(2);
    var _unicode = __webpack_require__(15);
    var _browser = __webpack_require__(22);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _base = __webpack_require__(29);
    var _base2 = _interopRequireDefault(_base);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var Overlays = function () {
      function Overlays(wotInstance) {
        _classCallCheck(this, Overlays);
        this.wot = wotInstance;
        this.instance = this.wot;
        this.eventManager = new _eventManager2.default(this.wot);
        this.wot.update('scrollbarWidth', (0, _element.getScrollbarWidth)());
        this.wot.update('scrollbarHeight', (0, _element.getScrollbarWidth)());
        this.scrollableElement = (0, _element.getScrollableElement)(this.wot.wtTable.TABLE);
        this.prepareOverlays();
        this.destroyed = false;
        this.keyPressed = false;
        this.spreaderLastSize = {
          width: null,
          height: null
        };
        this.overlayScrollPositions = {
          master: {
            top: 0,
            left: 0
          },
          top: {
            top: null,
            left: 0
          },
          bottom: {
            top: null,
            left: 0
          },
          left: {
            top: 0,
            left: null
          }
        };
        this.pendingScrollCallbacks = {
          master: {
            top: 0,
            left: 0
          },
          top: {
            left: 0
          },
          bottom: {
            left: 0
          },
          left: {
            top: 0
          }
        };
        this.verticalScrolling = false;
        this.horizontalScrolling = false;
        this.delegatedScrollCallback = false;
        this.registeredListeners = [];
        this.registerListeners();
      }
      _createClass(Overlays, [{
        key: 'prepareOverlays',
        value: function prepareOverlays() {
          var syncScroll = false;
          if (this.topOverlay) {
            syncScroll = this.topOverlay.updateStateOfRendering() || syncScroll;
          } else {
            this.topOverlay = _base2.default.createOverlay(_base2.default.CLONE_TOP, this.wot);
          }
          if (!_base2.default.hasOverlay(_base2.default.CLONE_BOTTOM)) {
            this.bottomOverlay = {
              needFullRender: false,
              updateStateOfRendering: function updateStateOfRendering() {
                return false;
              }
            };
          }
          if (!_base2.default.hasOverlay(_base2.default.CLONE_BOTTOM_LEFT_CORNER)) {
            this.bottomLeftCornerOverlay = {
              needFullRender: false,
              updateStateOfRendering: function updateStateOfRendering() {
                return false;
              }
            };
          }
          if (this.bottomOverlay) {
            syncScroll = this.bottomOverlay.updateStateOfRendering() || syncScroll;
          } else {
            this.bottomOverlay = _base2.default.createOverlay(_base2.default.CLONE_BOTTOM, this.wot);
          }
          if (this.leftOverlay) {
            syncScroll = this.leftOverlay.updateStateOfRendering() || syncScroll;
          } else {
            this.leftOverlay = _base2.default.createOverlay(_base2.default.CLONE_LEFT, this.wot);
          }
          if (this.topOverlay.needFullRender && this.leftOverlay.needFullRender) {
            if (this.topLeftCornerOverlay) {
              syncScroll = this.topLeftCornerOverlay.updateStateOfRendering() || syncScroll;
            } else {
              this.topLeftCornerOverlay = _base2.default.createOverlay(_base2.default.CLONE_TOP_LEFT_CORNER, this.wot);
            }
          }
          if (this.bottomOverlay.needFullRender && this.leftOverlay.needFullRender) {
            if (this.bottomLeftCornerOverlay) {
              syncScroll = this.bottomLeftCornerOverlay.updateStateOfRendering() || syncScroll;
            } else {
              this.bottomLeftCornerOverlay = _base2.default.createOverlay(_base2.default.CLONE_BOTTOM_LEFT_CORNER, this.wot);
            }
          }
          if (this.wot.getSetting('debug') && !this.debug) {
            this.debug = _base2.default.createOverlay(_base2.default.CLONE_DEBUG, this.wot);
          }
          return syncScroll;
        }
      }, {
        key: 'refreshAll',
        value: function refreshAll() {
          if (!this.wot.drawn) {
            return;
          }
          if (!this.wot.wtTable.holder.parentNode) {
            this.destroy();
            return;
          }
          this.wot.draw(true);
          if (this.verticalScrolling) {
            this.leftOverlay.onScroll();
          }
          if (this.horizontalScrolling) {
            this.topOverlay.onScroll();
          }
          this.verticalScrolling = false;
          this.horizontalScrolling = false;
        }
      }, {
        key: 'registerListeners',
        value: function registerListeners() {
          var _this = this;
          var topOverlayScrollable = this.topOverlay.mainTableScrollableElement;
          var leftOverlayScrollable = this.leftOverlay.mainTableScrollableElement;
          var listenersToRegister = [];
          listenersToRegister.push([document.documentElement, 'keydown', function (event) {
            return _this.onKeyDown(event);
          }]);
          listenersToRegister.push([document.documentElement, 'keyup', function () {
            return _this.onKeyUp();
          }]);
          listenersToRegister.push([document, 'visibilitychange', function () {
            return _this.onKeyUp();
          }]);
          listenersToRegister.push([topOverlayScrollable, 'scroll', function (event) {
            return _this.onTableScroll(event);
          }]);
          if (topOverlayScrollable !== leftOverlayScrollable) {
            listenersToRegister.push([leftOverlayScrollable, 'scroll', function (event) {
              return _this.onTableScroll(event);
            }]);
          }
          if (this.topOverlay.needFullRender) {
            listenersToRegister.push([this.topOverlay.clone.wtTable.holder, 'scroll', function (event) {
              return _this.onTableScroll(event);
            }]);
            listenersToRegister.push([this.topOverlay.clone.wtTable.holder, 'wheel', function (event) {
              return _this.onTableScroll(event);
            }]);
          }
          if (this.bottomOverlay.needFullRender) {
            listenersToRegister.push([this.bottomOverlay.clone.wtTable.holder, 'scroll', function (event) {
              return _this.onTableScroll(event);
            }]);
            listenersToRegister.push([this.bottomOverlay.clone.wtTable.holder, 'wheel', function (event) {
              return _this.onTableScroll(event);
            }]);
          }
          if (this.leftOverlay.needFullRender) {
            listenersToRegister.push([this.leftOverlay.clone.wtTable.holder, 'scroll', function (event) {
              return _this.onTableScroll(event);
            }]);
            listenersToRegister.push([this.leftOverlay.clone.wtTable.holder, 'wheel', function (event) {
              return _this.onTableScroll(event);
            }]);
          }
          if (this.topLeftCornerOverlay && this.topLeftCornerOverlay.needFullRender) {
            listenersToRegister.push([this.topLeftCornerOverlay.clone.wtTable.holder, 'wheel', function (event) {
              return _this.onTableScroll(event);
            }]);
          }
          if (this.bottomLeftCornerOverlay && this.bottomLeftCornerOverlay.needFullRender) {
            listenersToRegister.push([this.bottomLeftCornerOverlay.clone.wtTable.holder, 'wheel', function (event) {
              return _this.onTableScroll(event);
            }]);
          }
          if (this.topOverlay.trimmingContainer !== window && this.leftOverlay.trimmingContainer !== window) {
            listenersToRegister.push([window, 'wheel', function (event) {
              var overlay = void 0;
              var deltaY = event.wheelDeltaY || event.deltaY;
              var deltaX = event.wheelDeltaX || event.deltaX;
              if (_this.topOverlay.clone.wtTable.holder.contains(event.realTarget)) {
                overlay = 'top';
              } else if (_this.bottomOverlay.clone && _this.bottomOverlay.clone.wtTable.holder.contains(event.realTarget)) {
                overlay = 'bottom';
              } else if (_this.leftOverlay.clone.wtTable.holder.contains(event.realTarget)) {
                overlay = 'left';
              } else if (_this.topLeftCornerOverlay && _this.topLeftCornerOverlay.clone && _this.topLeftCornerOverlay.clone.wtTable.holder.contains(event.realTarget)) {
                overlay = 'topLeft';
              } else if (_this.bottomLeftCornerOverlay && _this.bottomLeftCornerOverlay.clone && _this.bottomLeftCornerOverlay.clone.wtTable.holder.contains(event.realTarget)) {
                overlay = 'bottomLeft';
              }
              if (overlay == 'top' && deltaY !== 0 || overlay == 'left' && deltaX !== 0 || overlay == 'bottom' && deltaY !== 0 || (overlay === 'topLeft' || overlay === 'bottomLeft') && (deltaY !== 0 || deltaX !== 0)) {
                event.preventDefault();
              }
            }]);
          }
          while (listenersToRegister.length) {
            var listener = listenersToRegister.pop();
            this.eventManager.addEventListener(listener[0], listener[1], listener[2]);
            this.registeredListeners.push(listener);
          }
        }
      }, {
        key: 'deregisterListeners',
        value: function deregisterListeners() {
          while (this.registeredListeners.length) {
            var listener = this.registeredListeners.pop();
            this.eventManager.removeEventListener(listener[0], listener[1], listener[2]);
          }
        }
      }, {
        key: 'onTableScroll',
        value: function onTableScroll(event) {
          if ((0, _browser.isMobileBrowser)()) {
            return;
          }
          var masterHorizontal = this.leftOverlay.mainTableScrollableElement;
          var masterVertical = this.topOverlay.mainTableScrollableElement;
          var target = event.target;
          if (this.keyPressed) {
            if (masterVertical !== window && target !== window && !event.target.contains(masterVertical) || masterHorizontal !== window && target !== window && !event.target.contains(masterHorizontal)) {
              return;
            }
          }
          if (event.type === 'scroll') {
            this.syncScrollPositions(event);
          } else {
            this.translateMouseWheelToScroll(event);
          }
        }
      }, {
        key: 'onKeyDown',
        value: function onKeyDown(event) {
          this.keyPressed = (0, _unicode.isKey)(event.keyCode, 'ARROW_UP|ARROW_RIGHT|ARROW_DOWN|ARROW_LEFT');
        }
      }, {
        key: 'onKeyUp',
        value: function onKeyUp() {
          this.keyPressed = false;
        }
      }, {
        key: 'translateMouseWheelToScroll',
        value: function translateMouseWheelToScroll(event) {
          var topOverlay = this.topOverlay.clone.wtTable.holder;
          var bottomOverlay = this.bottomOverlay.clone ? this.bottomOverlay.clone.wtTable.holder : null;
          var leftOverlay = this.leftOverlay.clone.wtTable.holder;
          var topLeftCornerOverlay = this.topLeftCornerOverlay && this.topLeftCornerOverlay.clone ? this.topLeftCornerOverlay.clone.wtTable.holder : null;
          var bottomLeftCornerOverlay = this.bottomLeftCornerOverlay && this.bottomLeftCornerOverlay.clone ? this.bottomLeftCornerOverlay.clone.wtTable.holder : null;
          var mouseWheelSpeedRatio = -0.2;
          var deltaY = event.wheelDeltaY || -1 * event.deltaY;
          var deltaX = event.wheelDeltaX || -1 * event.deltaX;
          var parentHolder = null;
          var eventMockup = {
            type: 'wheel'
          };
          var tempElem = event.target;
          var delta = null;
          if (event.deltaMode === 1) {
            deltaY *= 120;
            deltaX *= 120;
          }
          while (tempElem != document && tempElem != null) {
            if (tempElem.className.indexOf('wtHolder') > -1) {
              parentHolder = tempElem;
              break;
            }
            tempElem = tempElem.parentNode;
          }
          eventMockup.target = parentHolder;
          if (parentHolder === topLeftCornerOverlay || parentHolder === bottomLeftCornerOverlay) {
            this.syncScrollPositions(eventMockup, mouseWheelSpeedRatio * deltaX, 'x');
            this.syncScrollPositions(eventMockup, mouseWheelSpeedRatio * deltaY, 'y');
          } else {
            if (parentHolder === topOverlay || parentHolder === bottomOverlay) {
              delta = deltaY;
            } else if (parentHolder === leftOverlay) {
              delta = deltaX;
            }
            this.syncScrollPositions(eventMockup, mouseWheelSpeedRatio * delta);
          }
          return false;
        }
      }, {
        key: 'syncScrollPositions',
        value: function syncScrollPositions(event) {
          var fakeScrollValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
          var fakeScrollDirection = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
          if (this.destroyed) {
            return;
          }
          if (arguments.length === 0) {
            this.syncScrollWithMaster();
            return;
          }
          var masterHorizontal = this.leftOverlay.mainTableScrollableElement;
          var masterVertical = this.topOverlay.mainTableScrollableElement;
          var target = event.target;
          var tempScrollValue = 0;
          var scrollValueChanged = false;
          var topOverlay = void 0;
          var leftOverlay = void 0;
          var topLeftCornerOverlay = void 0;
          var bottomLeftCornerOverlay = void 0;
          var bottomOverlay = void 0;
          var delegatedScroll = false;
          var preventOverflow = this.wot.getSetting('preventOverflow');
          if (this.topOverlay.needFullRender) {
            topOverlay = this.topOverlay.clone.wtTable.holder;
          }
          if (this.bottomOverlay.needFullRender) {
            bottomOverlay = this.bottomOverlay.clone.wtTable.holder;
          }
          if (this.leftOverlay.needFullRender) {
            leftOverlay = this.leftOverlay.clone.wtTable.holder;
          }
          if (this.leftOverlay.needFullRender && this.topOverlay.needFullRender) {
            topLeftCornerOverlay = this.topLeftCornerOverlay.clone.wtTable.holder;
          }
          if (this.leftOverlay.needFullRender && this.bottomOverlay.needFullRender) {
            bottomLeftCornerOverlay = this.bottomLeftCornerOverlay.clone.wtTable.holder;
          }
          if (target === document) {
            target = window;
          }
          if (target === masterHorizontal || target === masterVertical) {
            if (preventOverflow) {
              tempScrollValue = (0, _element.getScrollLeft)(this.scrollableElement);
            } else {
              tempScrollValue = (0, _element.getScrollLeft)(target);
            }
            this.horizontalScrolling = true;
            this.overlayScrollPositions.master.left = tempScrollValue;
            scrollValueChanged = true;
            if (this.pendingScrollCallbacks.master.left > 0) {
              this.pendingScrollCallbacks.master.left--;
            } else {
              if (topOverlay && topOverlay.scrollLeft !== tempScrollValue) {
                if (fakeScrollValue == null) {
                  this.pendingScrollCallbacks.top.left++;
                }
                topOverlay.scrollLeft = tempScrollValue;
                delegatedScroll = masterHorizontal !== window;
              }
              if (bottomOverlay && bottomOverlay.scrollLeft !== tempScrollValue) {
                if (fakeScrollValue == null) {
                  this.pendingScrollCallbacks.bottom.left++;
                }
                bottomOverlay.scrollLeft = tempScrollValue;
                delegatedScroll = masterHorizontal !== window;
              }
            }
            tempScrollValue = (0, _element.getScrollTop)(target);
            this.verticalScrolling = true;
            this.overlayScrollPositions.master.top = tempScrollValue;
            scrollValueChanged = true;
            if (this.pendingScrollCallbacks.master.top > 0) {
              this.pendingScrollCallbacks.master.top--;
            } else if (leftOverlay && leftOverlay.scrollTop !== tempScrollValue) {
              if (fakeScrollValue == null) {
                this.pendingScrollCallbacks.left.top++;
              }
              leftOverlay.scrollTop = tempScrollValue;
              delegatedScroll = masterVertical !== window;
            }
          } else if (target === bottomOverlay) {
            tempScrollValue = (0, _element.getScrollLeft)(target);
            this.horizontalScrolling = true;
            this.overlayScrollPositions.bottom.left = tempScrollValue;
            scrollValueChanged = true;
            if (this.pendingScrollCallbacks.bottom.left > 0) {
              this.pendingScrollCallbacks.bottom.left--;
            } else {
              if (fakeScrollValue == null) {
                this.pendingScrollCallbacks.master.left++;
              }
              masterHorizontal.scrollLeft = tempScrollValue;
              if (topOverlay && topOverlay.scrollLeft !== tempScrollValue) {
                if (fakeScrollValue == null) {
                  this.pendingScrollCallbacks.top.left++;
                }
                topOverlay.scrollLeft = tempScrollValue;
                delegatedScroll = masterVertical !== window;
              }
            }
            if (fakeScrollValue !== null) {
              scrollValueChanged = true;
              masterVertical.scrollTop += fakeScrollValue;
            }
          } else if (target === topOverlay) {
            tempScrollValue = (0, _element.getScrollLeft)(target);
            this.horizontalScrolling = true;
            this.overlayScrollPositions.top.left = tempScrollValue;
            scrollValueChanged = true;
            if (this.pendingScrollCallbacks.top.left > 0) {
              this.pendingScrollCallbacks.top.left--;
            } else {
              if (fakeScrollValue == null) {
                this.pendingScrollCallbacks.master.left++;
              }
              masterHorizontal.scrollLeft = tempScrollValue;
            }
            if (fakeScrollValue !== null) {
              scrollValueChanged = true;
              masterVertical.scrollTop += fakeScrollValue;
            }
            if (bottomOverlay && bottomOverlay.scrollLeft !== tempScrollValue) {
              if (fakeScrollValue == null) {
                this.pendingScrollCallbacks.bottom.left++;
              }
              bottomOverlay.scrollLeft = tempScrollValue;
              delegatedScroll = masterVertical !== window;
            }
          } else if (target === leftOverlay) {
            tempScrollValue = (0, _element.getScrollTop)(target);
            if (this.overlayScrollPositions.left.top !== tempScrollValue) {
              this.verticalScrolling = true;
              this.overlayScrollPositions.left.top = tempScrollValue;
              scrollValueChanged = true;
              if (this.pendingScrollCallbacks.left.top > 0) {
                this.pendingScrollCallbacks.left.top--;
              } else {
                if (fakeScrollValue == null) {
                  this.pendingScrollCallbacks.master.top++;
                }
                masterVertical.scrollTop = tempScrollValue;
              }
            }
            if (fakeScrollValue !== null) {
              scrollValueChanged = true;
              masterVertical.scrollLeft += fakeScrollValue;
            }
          } else if (target === topLeftCornerOverlay || target === bottomLeftCornerOverlay) {
            if (fakeScrollValue !== null) {
              scrollValueChanged = true;
              if (fakeScrollDirection === 'x') {
                masterVertical.scrollLeft += fakeScrollValue;
              } else if (fakeScrollDirection === 'y') {
                masterVertical.scrollTop += fakeScrollValue;
              }
            }
          }
          if (!this.keyPressed && scrollValueChanged && event.type === 'scroll') {
            if (this.delegatedScrollCallback) {
              this.delegatedScrollCallback = false;
            } else {
              this.refreshAll();
            }
            if (delegatedScroll) {
              this.delegatedScrollCallback = true;
            }
          }
        }
      }, {
        key: 'syncScrollWithMaster',
        value: function syncScrollWithMaster() {
          var master = this.topOverlay.mainTableScrollableElement;
          var scrollLeft = master.scrollLeft,
            scrollTop = master.scrollTop;
          if (this.topOverlay.needFullRender) {
            this.topOverlay.clone.wtTable.holder.scrollLeft = scrollLeft;
          }
          if (this.bottomOverlay.needFullRender) {
            this.bottomOverlay.clone.wtTable.holder.scrollLeft = scrollLeft;
          }
          if (this.leftOverlay.needFullRender) {
            this.leftOverlay.clone.wtTable.holder.scrollTop = scrollTop;
          }
        }
      }, {
        key: 'updateMainScrollableElements',
        value: function updateMainScrollableElements() {
          this.deregisterListeners();
          this.leftOverlay.updateMainScrollableElement();
          this.topOverlay.updateMainScrollableElement();
          if (this.bottomOverlay.needFullRender) {
            this.bottomOverlay.updateMainScrollableElement();
          }
          this.scrollableElement = (0, _element.getScrollableElement)(this.wot.wtTable.TABLE);
          this.registerListeners();
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          this.eventManager.destroy();
          this.topOverlay.destroy();
          if (this.bottomOverlay.clone) {
            this.bottomOverlay.destroy();
          }
          this.leftOverlay.destroy();
          if (this.topLeftCornerOverlay) {
            this.topLeftCornerOverlay.destroy();
          }
          if (this.bottomLeftCornerOverlay && this.bottomLeftCornerOverlay.clone) {
            this.bottomLeftCornerOverlay.destroy();
          }
          if (this.debug) {
            this.debug.destroy();
          }
          this.destroyed = true;
        }
      }, {
        key: 'refresh',
        value: function refresh() {
          var fastDraw = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
          if (this.topOverlay.areElementSizesAdjusted && this.leftOverlay.areElementSizesAdjusted) {
            var container = this.wot.wtTable.wtRootElement.parentNode || this.wot.wtTable.wtRootElement;
            var width = container.clientWidth;
            var height = container.clientHeight;
            if (width !== this.spreaderLastSize.width || height !== this.spreaderLastSize.height) {
              this.spreaderLastSize.width = width;
              this.spreaderLastSize.height = height;
              this.adjustElementsSize();
            }
          }
          if (this.bottomOverlay.clone) {
            this.bottomOverlay.refresh(fastDraw);
          }
          this.leftOverlay.refresh(fastDraw);
          this.topOverlay.refresh(fastDraw);
          if (this.topLeftCornerOverlay) {
            this.topLeftCornerOverlay.refresh(fastDraw);
          }
          if (this.bottomLeftCornerOverlay && this.bottomLeftCornerOverlay.clone) {
            this.bottomLeftCornerOverlay.refresh(fastDraw);
          }
          if (this.debug) {
            this.debug.refresh(fastDraw);
          }
        }
      }, {
        key: 'adjustElementsSize',
        value: function adjustElementsSize() {
          var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
          var totalColumns = this.wot.getSetting('totalColumns');
          var totalRows = this.wot.getSetting('totalRows');
          var headerRowSize = this.wot.wtViewport.getRowHeaderWidth();
          var headerColumnSize = this.wot.wtViewport.getColumnHeaderHeight();
          var hiderStyle = this.wot.wtTable.hider.style;
          hiderStyle.width = headerRowSize + this.leftOverlay.sumCellSizes(0, totalColumns) + 'px';
          hiderStyle.height = headerColumnSize + this.topOverlay.sumCellSizes(0, totalRows) + 1 + 'px';
          this.topOverlay.adjustElementsSize(force);
          this.leftOverlay.adjustElementsSize(force);
          if (this.bottomOverlay.clone) {
            this.bottomOverlay.adjustElementsSize(force);
          }
        }
      }, {
        key: 'applyToDOM',
        value: function applyToDOM() {
          if (!this.topOverlay.areElementSizesAdjusted || !this.leftOverlay.areElementSizesAdjusted) {
            this.adjustElementsSize();
          }
          this.topOverlay.applyToDOM();
          if (this.bottomOverlay.clone) {
            this.bottomOverlay.applyToDOM();
          }
          this.leftOverlay.applyToDOM();
        }
      }, {
        key: 'getParentOverlay',
        value: function getParentOverlay(element) {
          if (!element) {
            return null;
          }
          var overlays = [this.topOverlay, this.leftOverlay, this.bottomOverlay, this.topLeftCornerOverlay, this.bottomLeftCornerOverlay];
          var result = null;
          (0, _array.arrayEach)(overlays, function (elem, i) {
            if (!elem) {
              return;
            }
            if (elem.clone && elem.clone.wtTable.TABLE.contains(element)) {
              result = elem.clone;
            }
          });
          return result;
        }
      }]);
      return Overlays;
    }();
    exports.default = Overlays;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _element = __webpack_require__(0);
    var _number = __webpack_require__(5);

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var Scroll = function () {
      function Scroll(wotInstance) {
        _classCallCheck(this, Scroll);
        this.wot = wotInstance;
        this.instance = wotInstance;
      }
      _createClass(Scroll, [{
        key: 'scrollViewport',
        value: function scrollViewport(coords) {
          if (!this.wot.drawn) {
            return;
          }
          var _getVariables2 = this._getVariables(),
            topOverlay = _getVariables2.topOverlay,
            leftOverlay = _getVariables2.leftOverlay,
            totalRows = _getVariables2.totalRows,
            totalColumns = _getVariables2.totalColumns,
            fixedRowsTop = _getVariables2.fixedRowsTop,
            fixedRowsBottom = _getVariables2.fixedRowsBottom,
            fixedColumnsLeft = _getVariables2.fixedColumnsLeft;
          if (coords.row < 0 || coords.row > Math.max(totalRows - 1, 0)) {
            throw new Error('row ' + coords.row + ' does not exist');
          }
          if (coords.col < 0 || coords.col > Math.max(totalColumns - 1, 0)) {
            throw new Error('column ' + coords.col + ' does not exist');
          }
          if (coords.row >= fixedRowsTop && coords.row < this.getFirstVisibleRow()) {
            topOverlay.scrollTo(coords.row);
          } else if (coords.row > this.getLastVisibleRow() && coords.row < totalRows - fixedRowsBottom) {
            topOverlay.scrollTo(coords.row, true);
          }
          if (coords.col >= fixedColumnsLeft && coords.col < this.getFirstVisibleColumn()) {
            leftOverlay.scrollTo(coords.col);
          } else if (coords.col > this.getLastVisibleColumn()) {
            leftOverlay.scrollTo(coords.col, true);
          }
        }
      }, {
        key: 'getFirstVisibleRow',
        value: function getFirstVisibleRow() {
          var _getVariables3 = this._getVariables(),
            topOverlay = _getVariables3.topOverlay,
            wtTable = _getVariables3.wtTable,
            wtViewport = _getVariables3.wtViewport,
            totalRows = _getVariables3.totalRows,
            fixedRowsTop = _getVariables3.fixedRowsTop;
          var firstVisibleRow = wtTable.getFirstVisibleRow();
          if (topOverlay.mainTableScrollableElement === window) {
            var rootElementOffset = (0, _element.offset)(wtTable.wtRootElement);
            var totalTableHeight = (0, _element.innerHeight)(wtTable.hider);
            var windowHeight = (0, _element.innerHeight)(window);
            var windowScrollTop = (0, _element.getScrollTop)(window);
            if (rootElementOffset.top + totalTableHeight - windowHeight <= windowScrollTop) {
              var rowsHeight = wtViewport.getColumnHeaderHeight();
              rowsHeight += topOverlay.sumCellSizes(0, fixedRowsTop);
              (0, _number.rangeEachReverse)(totalRows, 1, function (row) {
                rowsHeight += topOverlay.sumCellSizes(row - 1, row);
                if (rootElementOffset.top + totalTableHeight - rowsHeight <= windowScrollTop) {
                  firstVisibleRow = row;
                  return false;
                }
              });
            }
          }
          return firstVisibleRow;
        }
      }, {
        key: 'getLastVisibleRow',
        value: function getLastVisibleRow() {
          var _getVariables4 = this._getVariables(),
            topOverlay = _getVariables4.topOverlay,
            wtTable = _getVariables4.wtTable,
            wtViewport = _getVariables4.wtViewport,
            totalRows = _getVariables4.totalRows;
          var lastVisibleRow = wtTable.getLastVisibleRow();
          if (topOverlay.mainTableScrollableElement === window) {
            var rootElementOffset = (0, _element.offset)(wtTable.wtRootElement);
            var windowHeight = (0, _element.innerHeight)(window);
            var windowScrollTop = (0, _element.getScrollTop)(window);
            if (rootElementOffset.top > windowScrollTop) {
              var rowsHeight = wtViewport.getColumnHeaderHeight();
              (0, _number.rangeEach)(1, totalRows, function (row) {
                rowsHeight += topOverlay.sumCellSizes(row - 1, row);
                if (rootElementOffset.top + rowsHeight - windowScrollTop >= windowHeight) {
                  lastVisibleRow = row - 2;
                  return false;
                }
              });
            }
          }
          return lastVisibleRow;
        }
      }, {
        key: 'getFirstVisibleColumn',
        value: function getFirstVisibleColumn() {
          var _getVariables5 = this._getVariables(),
            leftOverlay = _getVariables5.leftOverlay,
            wtTable = _getVariables5.wtTable,
            wtViewport = _getVariables5.wtViewport,
            totalColumns = _getVariables5.totalColumns,
            fixedColumnsLeft = _getVariables5.fixedColumnsLeft;
          var firstVisibleColumn = wtTable.getFirstVisibleColumn();
          if (leftOverlay.mainTableScrollableElement === window) {
            var rootElementOffset = (0, _element.offset)(wtTable.wtRootElement);
            var totalTableWidth = (0, _element.innerWidth)(wtTable.hider);
            var windowWidth = (0, _element.innerWidth)(window);
            var windowScrollLeft = (0, _element.getScrollLeft)(window);
            if (rootElementOffset.left + totalTableWidth - windowWidth <= windowScrollLeft) {
              var columnsWidth = wtViewport.getRowHeaderWidth();
              (0, _number.rangeEachReverse)(totalColumns, 1, function (column) {
                columnsWidth += leftOverlay.sumCellSizes(column - 1, column);
                if (rootElementOffset.left + totalTableWidth - columnsWidth <= windowScrollLeft) {
                  firstVisibleColumn = column;
                  return false;
                }
              });
            }
          }
          return firstVisibleColumn;
        }
      }, {
        key: 'getLastVisibleColumn',
        value: function getLastVisibleColumn() {
          var _getVariables6 = this._getVariables(),
            leftOverlay = _getVariables6.leftOverlay,
            wtTable = _getVariables6.wtTable,
            wtViewport = _getVariables6.wtViewport,
            totalColumns = _getVariables6.totalColumns;
          var lastVisibleColumn = wtTable.getLastVisibleColumn();
          if (leftOverlay.mainTableScrollableElement === window) {
            var rootElementOffset = (0, _element.offset)(wtTable.wtRootElement);
            var windowWidth = (0, _element.innerWidth)(window);
            var windowScrollLeft = (0, _element.getScrollLeft)(window);
            if (rootElementOffset.left > windowScrollLeft) {
              var columnsWidth = wtViewport.getRowHeaderWidth();
              (0, _number.rangeEach)(1, totalColumns, function (column) {
                columnsWidth += leftOverlay.sumCellSizes(column - 1, column);
                if (rootElementOffset.left + columnsWidth - windowScrollLeft >= windowWidth) {
                  lastVisibleColumn = column - 2;
                  return false;
                }
              });
            }
          }
          return lastVisibleColumn;
        }
      }, {
        key: '_getVariables',
        value: function _getVariables() {
          var wot = this.wot;
          var topOverlay = wot.wtOverlays.topOverlay;
          var leftOverlay = wot.wtOverlays.leftOverlay;
          var wtTable = wot.wtTable;
          var wtViewport = wot.wtViewport;
          var totalRows = wot.getSetting('totalRows');
          var totalColumns = wot.getSetting('totalColumns');
          var fixedRowsTop = wot.getSetting('fixedRowsTop');
          var fixedRowsBottom = wot.getSetting('fixedRowsBottom');
          var fixedColumnsLeft = wot.getSetting('fixedColumnsLeft');
          return {
            topOverlay: topOverlay,
            leftOverlay: leftOverlay,
            wtTable: wtTable,
            wtViewport: wtViewport,
            totalRows: totalRows,
            totalColumns: totalColumns,
            fixedRowsTop: fixedRowsTop,
            fixedRowsBottom: fixedRowsBottom,
            fixedColumnsLeft: fixedColumnsLeft
          };
        }
      }]);
      return Scroll;
    }();
    exports.default = Scroll;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _element = __webpack_require__(0);
    var _object = __webpack_require__(3);

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var Settings = function () {
      function Settings(wotInstance, settings) {
        var _this = this;
        _classCallCheck(this, Settings);
        this.wot = wotInstance;
        this.instance = wotInstance;
        this.defaults = {
          table: void 0,
          debug: false,
          externalRowCalculator: false,
          stretchH: 'none',
          currentRowClassName: null,
          currentColumnClassName: null,
          preventOverflow: function preventOverflow() {
            return false;
          },
          data: void 0,
          freezeOverlays: false,
          fixedColumnsLeft: 0,
          fixedRowsTop: 0,
          fixedRowsBottom: 0,
          minSpareRows: 0,
          rowHeaders: function rowHeaders() {
            return [];
          },
          columnHeaders: function columnHeaders() {
            return [];
          },
          totalRows: void 0,
          totalColumns: void 0,
          cellRenderer: function cellRenderer(row, column, TD) {
            var cellData = _this.getSetting('data', row, column);
            (0, _element.fastInnerText)(TD, cellData === void 0 || cellData === null ? '' : cellData);
          },
          columnWidth: function columnWidth(col) { },
          rowHeight: function rowHeight(row) { },
          defaultRowHeight: 23,
          defaultColumnWidth: 50,
          selections: null,
          hideBorderOnMouseDownOver: false,
          viewportRowCalculatorOverride: null,
          viewportColumnCalculatorOverride: null,
          onCellMouseDown: null,
          onCellMouseOver: null,
          onCellMouseOut: null,
          onCellMouseUp: null,
          onCellDblClick: null,
          onCellCornerMouseDown: null,
          onCellCornerDblClick: null,
          beforeDraw: null,
          onDraw: null,
          onBeforeDrawBorders: null,
          onScrollVertically: null,
          onScrollHorizontally: null,
          onBeforeTouchScroll: null,
          onAfterMomentumScroll: null,
          onBeforeStretchingColumnWidth: function onBeforeStretchingColumnWidth(width) {
            return width;
          },
          onModifyRowHeaderWidth: null,
          scrollbarWidth: 10,
          scrollbarHeight: 10,
          renderAllRows: false,
          groups: false,
          rowHeaderWidth: null,
          columnHeaderHeight: null,
          headerClassName: null
        };
        this.settings = {};
        for (var i in this.defaults) {
          if ((0, _object.hasOwnProperty)(this.defaults, i)) {
            if (settings[i] !== void 0) {
              this.settings[i] = settings[i];
            } else if (this.defaults[i] === void 0) {
              throw new Error('A required setting "' + i + '" was not provided');
            } else {
              this.settings[i] = this.defaults[i];
            }
          }
        }
      }
      _createClass(Settings, [{
        key: 'update',
        value: function update(settings, value) {
          if (value === void 0) {
            for (var i in settings) {
              if ((0, _object.hasOwnProperty)(settings, i)) {
                this.settings[i] = settings[i];
              }
            }
          } else {
            this.settings[settings] = value;
          }
          return this.wot;
        }
      }, {
        key: 'getSetting',
        value: function getSetting(key, param1, param2, param3, param4) {
          if (typeof this.settings[key] === 'function') {
            return this.settings[key](param1, param2, param3, param4);
          } else if (param1 !== void 0 && Array.isArray(this.settings[key])) {
            return this.settings[key][param1];
          }
          return this.settings[key];
        }
      }, {
        key: 'has',
        value: function has(key) {
          return !!this.settings[key];
        }
      }]);
      return Settings;
    }();
    exports.default = Settings;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
      return typeof obj;
    } : function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _element = __webpack_require__(0);
    var _function = __webpack_require__(35);
    var _coords = __webpack_require__(43);
    var _coords2 = _interopRequireDefault(_coords);
    var _range = __webpack_require__(71);
    var _range2 = _interopRequireDefault(_range);
    var _column = __webpack_require__(255);
    var _column2 = _interopRequireDefault(_column);
    var _row = __webpack_require__(256);
    var _row2 = _interopRequireDefault(_row);
    var _tableRenderer = __webpack_require__(261);
    var _tableRenderer2 = _interopRequireDefault(_tableRenderer);
    var _base = __webpack_require__(29);
    var _base2 = _interopRequireDefault(_base);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _toConsumableArray(arr) {
      if (Array.isArray(arr)) {
        for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
          arr2[i] = arr[i];
        }
        return arr2;
      } else {
        return Array.from(arr);
      }
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var Table = function () {
      function Table(wotInstance, table) {
        var _this = this;
        _classCallCheck(this, Table);
        this.wot = wotInstance;
        this.instance = this.wot;
        this.TABLE = table;
        this.TBODY = null;
        this.THEAD = null;
        this.COLGROUP = null;
        this.tableOffset = 0;
        this.holderOffset = 0;
        (0, _element.removeTextNodes)(this.TABLE);
        this.spreader = this.createSpreader(this.TABLE);
        this.hider = this.createHider(this.spreader);
        this.holder = this.createHolder(this.hider);
        this.wtRootElement = this.holder.parentNode;
        this.alignOverlaysWithTrimmingContainer();
        this.fixTableDomTree();
        this.colgroupChildrenLength = this.COLGROUP.childNodes.length;
        this.theadChildrenLength = this.THEAD.firstChild ? this.THEAD.firstChild.childNodes.length : 0;
        this.tbodyChildrenLength = this.TBODY.childNodes.length;
        this.rowFilter = null;
        this.columnFilter = null;
        this.correctHeaderWidth = false;
        var origRowHeaderWidth = this.wot.wtSettings.settings.rowHeaderWidth;
        this.wot.wtSettings.settings.rowHeaderWidth = function () {
          return _this._modifyRowHeaderWidth(origRowHeaderWidth);
        };
      }
      _createClass(Table, [{
        key: 'fixTableDomTree',
        value: function fixTableDomTree() {
          this.TBODY = this.TABLE.querySelector('tbody');
          if (!this.TBODY) {
            this.TBODY = document.createElement('tbody');
            this.TABLE.appendChild(this.TBODY);
          }
          this.THEAD = this.TABLE.querySelector('thead');
          if (!this.THEAD) {
            this.THEAD = document.createElement('thead');
            this.TABLE.insertBefore(this.THEAD, this.TBODY);
          }
          this.COLGROUP = this.TABLE.querySelector('colgroup');
          if (!this.COLGROUP) {
            this.COLGROUP = document.createElement('colgroup');
            this.TABLE.insertBefore(this.COLGROUP, this.THEAD);
          }
          if (this.wot.getSetting('columnHeaders').length && !this.THEAD.childNodes.length) {
            this.THEAD.appendChild(document.createElement('TR'));
          }
        }
      }, {
        key: 'createSpreader',
        value: function createSpreader(table) {
          var parent = table.parentNode;
          var spreader = void 0;
          if (!parent || parent.nodeType !== 1 || !(0, _element.hasClass)(parent, 'wtHolder')) {
            spreader = document.createElement('div');
            spreader.className = 'wtSpreader';
            if (parent) {
              parent.insertBefore(spreader, table);
            }
            spreader.appendChild(table);
          }
          spreader.style.position = 'relative';
          return spreader;
        }
      }, {
        key: 'createHider',
        value: function createHider(spreader) {
          var parent = spreader.parentNode;
          var hider = void 0;
          if (!parent || parent.nodeType !== 1 || !(0, _element.hasClass)(parent, 'wtHolder')) {
            hider = document.createElement('div');
            hider.className = 'wtHider';
            if (parent) {
              parent.insertBefore(hider, spreader);
            }
            hider.appendChild(spreader);
          }
          return hider;
        }
      }, {
        key: 'createHolder',
        value: function createHolder(hider) {
          var parent = hider.parentNode;
          var holder = void 0;
          if (!parent || parent.nodeType !== 1 || !(0, _element.hasClass)(parent, 'wtHolder')) {
            holder = document.createElement('div');
            holder.style.position = 'relative';
            holder.className = 'wtHolder';
            if (parent) {
              parent.insertBefore(holder, hider);
            }
            if (!this.isWorkingOnClone()) {
              holder.parentNode.className += 'ht_master handsontable';
            }
            holder.appendChild(hider);
          }
          return holder;
        }
      }, {
        key: 'alignOverlaysWithTrimmingContainer',
        value: function alignOverlaysWithTrimmingContainer() {
          var trimmingElement = (0, _element.getTrimmingContainer)(this.wtRootElement);
          if (!this.isWorkingOnClone()) {
            this.holder.parentNode.style.position = 'relative';
            if (trimmingElement === window) {
              var preventOverflow = this.wot.getSetting('preventOverflow');
              if (!preventOverflow) {
                this.holder.style.overflow = 'visible';
                this.wtRootElement.style.overflow = 'visible';
              }
            } else {
              this.holder.style.width = (0, _element.getStyle)(trimmingElement, 'width');
              this.holder.style.height = (0, _element.getStyle)(trimmingElement, 'height');
              this.holder.style.overflow = '';
            }
          }
        }
      }, {
        key: 'isWorkingOnClone',
        value: function isWorkingOnClone() {
          return !!this.wot.cloneSource;
        }
      }, {
        key: 'draw',
        value: function draw(fastDraw) {
          var _wot = this.wot,
            wtOverlays = _wot.wtOverlays,
            wtViewport = _wot.wtViewport;
          var totalRows = this.instance.getSetting('totalRows');
          var rowHeaders = this.wot.getSetting('rowHeaders').length;
          var columnHeaders = this.wot.getSetting('columnHeaders').length;
          var syncScroll = false;
          if (!this.isWorkingOnClone()) {
            this.holderOffset = (0, _element.offset)(this.holder);
            fastDraw = wtViewport.createRenderCalculators(fastDraw);
            if (rowHeaders && !this.wot.getSetting('fixedColumnsLeft')) {
              var leftScrollPos = wtOverlays.leftOverlay.getScrollPosition();
              var previousState = this.correctHeaderWidth;
              this.correctHeaderWidth = leftScrollPos > 0;
              if (previousState !== this.correctHeaderWidth) {
                fastDraw = false;
              }
            }
          }
          if (!this.isWorkingOnClone()) {
            syncScroll = wtOverlays.prepareOverlays();
          }
          if (fastDraw) {
            if (!this.isWorkingOnClone()) {
              wtViewport.createVisibleCalculators();
            }
            if (wtOverlays) {
              wtOverlays.refresh(true);
            }
          } else {
            if (this.isWorkingOnClone()) {
              this.tableOffset = this.wot.cloneSource.wtTable.tableOffset;
            } else {
              this.tableOffset = (0, _element.offset)(this.TABLE);
            }
            var startRow = void 0;
            if (_base2.default.isOverlayTypeOf(this.wot.cloneOverlay, _base2.default.CLONE_DEBUG) || _base2.default.isOverlayTypeOf(this.wot.cloneOverlay, _base2.default.CLONE_TOP) || _base2.default.isOverlayTypeOf(this.wot.cloneOverlay, _base2.default.CLONE_TOP_LEFT_CORNER)) {
              startRow = 0;
            } else if (_base2.default.isOverlayTypeOf(this.instance.cloneOverlay, _base2.default.CLONE_BOTTOM) || _base2.default.isOverlayTypeOf(this.instance.cloneOverlay, _base2.default.CLONE_BOTTOM_LEFT_CORNER)) {
              startRow = Math.max(totalRows - this.wot.getSetting('fixedRowsBottom'), 0);
            } else {
              startRow = wtViewport.rowsRenderCalculator.startRow;
            }
            var startColumn = void 0;
            if (_base2.default.isOverlayTypeOf(this.wot.cloneOverlay, _base2.default.CLONE_DEBUG) || _base2.default.isOverlayTypeOf(this.wot.cloneOverlay, _base2.default.CLONE_LEFT) || _base2.default.isOverlayTypeOf(this.wot.cloneOverlay, _base2.default.CLONE_TOP_LEFT_CORNER) || _base2.default.isOverlayTypeOf(this.wot.cloneOverlay, _base2.default.CLONE_BOTTOM_LEFT_CORNER)) {
              startColumn = 0;
            } else {
              startColumn = wtViewport.columnsRenderCalculator.startColumn;
            }
            this.rowFilter = new _row2.default(startRow, totalRows, columnHeaders);
            this.columnFilter = new _column2.default(startColumn, this.wot.getSetting('totalColumns'), rowHeaders);
            this.alignOverlaysWithTrimmingContainer();
            this._doDraw();
          }
          this.refreshSelections(fastDraw);
          if (!this.isWorkingOnClone()) {
            wtOverlays.topOverlay.resetFixedPosition();
            if (wtOverlays.bottomOverlay.clone) {
              wtOverlays.bottomOverlay.resetFixedPosition();
            }
            wtOverlays.leftOverlay.resetFixedPosition();
            if (wtOverlays.topLeftCornerOverlay) {
              wtOverlays.topLeftCornerOverlay.resetFixedPosition();
            }
            if (wtOverlays.bottomLeftCornerOverlay && wtOverlays.bottomLeftCornerOverlay.clone) {
              wtOverlays.bottomLeftCornerOverlay.resetFixedPosition();
            }
          }
          if (syncScroll) {
            wtOverlays.syncScrollWithMaster();
          }
          this.wot.drawn = true;
          return this;
        }
      }, {
        key: '_doDraw',
        value: function _doDraw() {
          var wtRenderer = new _tableRenderer2.default(this);
          wtRenderer.render();
        }
      }, {
        key: 'removeClassFromCells',
        value: function removeClassFromCells(className) {
          var nodes = this.TABLE.querySelectorAll('.' + className);
          for (var i = 0, len = nodes.length; i < len; i++) {
            (0, _element.removeClass)(nodes[i], className);
          }
        }
      }, {
        key: 'refreshSelections',
        value: function refreshSelections(fastDraw) {
          if (!this.wot.selections) {
            return;
          }
          var len = this.wot.selections.length;
          if (fastDraw) {
            for (var i = 0; i < len; i++) {
              if (this.wot.selections[i].settings.className) {
                this.removeClassFromCells(this.wot.selections[i].settings.className);
              }
              if (this.wot.selections[i].settings.highlightHeaderClassName) {
                this.removeClassFromCells(this.wot.selections[i].settings.highlightHeaderClassName);
              }
              if (this.wot.selections[i].settings.highlightRowClassName) {
                this.removeClassFromCells(this.wot.selections[i].settings.highlightRowClassName);
              }
              if (this.wot.selections[i].settings.highlightColumnClassName) {
                this.removeClassFromCells(this.wot.selections[i].settings.highlightColumnClassName);
              }
            }
          }
          for (var _i = 0; _i < len; _i++) {
            this.wot.selections[_i].draw(this.wot, fastDraw);
          }
        }
      }, {
        key: 'getCell',
        value: function getCell(coords) {
          if (this.isRowBeforeRenderedRows(coords.row)) {
            return -1;
          } else if (this.isRowAfterRenderedRows(coords.row)) {
            return -2;
          }
          var TR = this.TBODY.childNodes[this.rowFilter.sourceToRendered(coords.row)];
          if (TR) {
            return TR.childNodes[this.columnFilter.sourceColumnToVisibleRowHeadedColumn(coords.col)];
          }
        }
      }, {
        key: 'getColumnHeader',
        value: function getColumnHeader(col) {
          var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
          var TR = this.THEAD.childNodes[level];
          if (TR) {
            return TR.childNodes[this.columnFilter.sourceColumnToVisibleRowHeadedColumn(col)];
          }
        }
      }, {
        key: 'getRowHeader',
        value: function getRowHeader(row) {
          if (this.columnFilter.sourceColumnToVisibleRowHeadedColumn(0) === 0) {
            return null;
          }
          var TR = this.TBODY.childNodes[this.rowFilter.sourceToRendered(row)];
          if (TR) {
            return TR.childNodes[0];
          }
        }
      }, {
        key: 'getCoords',
        value: function getCoords(TD) {
          if (TD.nodeName !== 'TD' && TD.nodeName !== 'TH') {
            TD = (0, _element.closest)(TD, ['TD', 'TH']);
          }
          if (TD === null) {
            return null;
          }
          var TR = TD.parentNode;
          var CONTAINER = TR.parentNode;
          var row = (0, _element.index)(TR);
          var col = TD.cellIndex;
          if ((0, _element.overlayContainsElement)(_base2.default.CLONE_TOP_LEFT_CORNER, TD) || (0, _element.overlayContainsElement)(_base2.default.CLONE_TOP, TD)) {
            if (CONTAINER.nodeName === 'THEAD') {
              row -= CONTAINER.childNodes.length;
            }
          } else if (CONTAINER === this.THEAD) {
            row = this.rowFilter.visibleColHeadedRowToSourceRow(row);
          } else {
            row = this.rowFilter.renderedToSource(row);
          }
          if ((0, _element.overlayContainsElement)(_base2.default.CLONE_TOP_LEFT_CORNER, TD) || (0, _element.overlayContainsElement)(_base2.default.CLONE_LEFT, TD)) {
            col = this.columnFilter.offsettedTH(col);
          } else {
            col = this.columnFilter.visibleRowHeadedColumnToSourceColumn(col);
          }
          return new _coords2.default(row, col);
        }
      }, {
        key: 'getTrForRow',
        value: function getTrForRow(row) {
          return this.TBODY.childNodes[this.rowFilter.sourceToRendered(row)];
        }
      }, {
        key: 'getFirstRenderedRow',
        value: function getFirstRenderedRow() {
          return this.wot.wtViewport.rowsRenderCalculator.startRow;
        }
      }, {
        key: 'getFirstVisibleRow',
        value: function getFirstVisibleRow() {
          return this.wot.wtViewport.rowsVisibleCalculator.startRow;
        }
      }, {
        key: 'getFirstRenderedColumn',
        value: function getFirstRenderedColumn() {
          return this.wot.wtViewport.columnsRenderCalculator.startColumn;
        }
      }, {
        key: 'getFirstVisibleColumn',
        value: function getFirstVisibleColumn() {
          return this.wot.wtViewport.columnsVisibleCalculator.startColumn;
        }
      }, {
        key: 'getLastRenderedRow',
        value: function getLastRenderedRow() {
          return this.wot.wtViewport.rowsRenderCalculator.endRow;
        }
      }, {
        key: 'getLastVisibleRow',
        value: function getLastVisibleRow() {
          return this.wot.wtViewport.rowsVisibleCalculator.endRow;
        }
      }, {
        key: 'getLastRenderedColumn',
        value: function getLastRenderedColumn() {
          return this.wot.wtViewport.columnsRenderCalculator.endColumn;
        }
      }, {
        key: 'getLastVisibleColumn',
        value: function getLastVisibleColumn() {
          return this.wot.wtViewport.columnsVisibleCalculator.endColumn;
        }
      }, {
        key: 'isRowBeforeRenderedRows',
        value: function isRowBeforeRenderedRows(row) {
          return this.rowFilter && this.rowFilter.sourceToRendered(row) < 0 && row >= 0;
        }
      }, {
        key: 'isRowAfterViewport',
        value: function isRowAfterViewport(row) {
          return this.rowFilter && this.rowFilter.sourceToRendered(row) > this.getLastVisibleRow();
        }
      }, {
        key: 'isRowAfterRenderedRows',
        value: function isRowAfterRenderedRows(row) {
          return this.rowFilter && this.rowFilter.sourceToRendered(row) > this.getLastRenderedRow();
        }
      }, {
        key: 'isColumnBeforeViewport',
        value: function isColumnBeforeViewport(column) {
          return this.columnFilter && this.columnFilter.sourceToRendered(column) < 0 && column >= 0;
        }
      }, {
        key: 'isColumnAfterViewport',
        value: function isColumnAfterViewport(column) {
          return this.columnFilter && this.columnFilter.sourceToRendered(column) > this.getLastVisibleColumn();
        }
      }, {
        key: 'isLastRowFullyVisible',
        value: function isLastRowFullyVisible() {
          return this.getLastVisibleRow() === this.getLastRenderedRow();
        }
      }, {
        key: 'isLastColumnFullyVisible',
        value: function isLastColumnFullyVisible() {
          return this.getLastVisibleColumn() === this.getLastRenderedColumn();
        }
      }, {
        key: 'getRenderedColumnsCount',
        value: function getRenderedColumnsCount() {
          var columnsCount = this.wot.wtViewport.columnsRenderCalculator.count;
          var totalColumns = this.wot.getSetting('totalColumns');
          if (this.wot.isOverlayName(_base2.default.CLONE_DEBUG)) {
            columnsCount = totalColumns;
          } else if (this.wot.isOverlayName(_base2.default.CLONE_LEFT) || this.wot.isOverlayName(_base2.default.CLONE_TOP_LEFT_CORNER) || this.wot.isOverlayName(_base2.default.CLONE_BOTTOM_LEFT_CORNER)) {
            return Math.min(this.wot.getSetting('fixedColumnsLeft'), totalColumns);
          }
          return columnsCount;
        }
      }, {
        key: 'getRenderedRowsCount',
        value: function getRenderedRowsCount() {
          var rowsCount = this.wot.wtViewport.rowsRenderCalculator.count;
          var totalRows = this.wot.getSetting('totalRows');
          if (this.wot.isOverlayName(_base2.default.CLONE_DEBUG)) {
            rowsCount = totalRows;
          } else if (this.wot.isOverlayName(_base2.default.CLONE_TOP) || this.wot.isOverlayName(_base2.default.CLONE_TOP_LEFT_CORNER)) {
            rowsCount = Math.min(this.wot.getSetting('fixedRowsTop'), totalRows);
          } else if (this.wot.isOverlayName(_base2.default.CLONE_BOTTOM) || this.wot.isOverlayName(_base2.default.CLONE_BOTTOM_LEFT_CORNER)) {
            rowsCount = Math.min(this.wot.getSetting('fixedRowsBottom'), totalRows);
          }
          return rowsCount;
        }
      }, {
        key: 'getVisibleRowsCount',
        value: function getVisibleRowsCount() {
          return this.wot.wtViewport.rowsVisibleCalculator.count;
        }
      }, {
        key: 'allRowsInViewport',
        value: function allRowsInViewport() {
          return this.wot.getSetting('totalRows') == this.getVisibleRowsCount();
        }
      }, {
        key: 'getRowHeight',
        value: function getRowHeight(sourceRow) {
          var height = this.wot.wtSettings.settings.rowHeight(sourceRow);
          var oversizedHeight = this.wot.wtViewport.oversizedRows[sourceRow];
          if (oversizedHeight !== void 0) {
            height = height === void 0 ? oversizedHeight : Math.max(height, oversizedHeight);
          }
          return height;
        }
      }, {
        key: 'getColumnHeaderHeight',
        value: function getColumnHeaderHeight(level) {
          var height = this.wot.wtSettings.settings.defaultRowHeight;
          var oversizedHeight = this.wot.wtViewport.oversizedColumnHeaders[level];
          if (oversizedHeight !== void 0) {
            height = height ? Math.max(height, oversizedHeight) : oversizedHeight;
          }
          return height;
        }
      }, {
        key: 'getVisibleColumnsCount',
        value: function getVisibleColumnsCount() {
          return this.wot.wtViewport.columnsVisibleCalculator.count;
        }
      }, {
        key: 'allColumnsInViewport',
        value: function allColumnsInViewport() {
          return this.wot.getSetting('totalColumns') == this.getVisibleColumnsCount();
        }
      }, {
        key: 'getColumnWidth',
        value: function getColumnWidth(sourceColumn) {
          var width = this.wot.wtSettings.settings.columnWidth;
          if (typeof width === 'function') {
            width = width(sourceColumn);
          } else if ((typeof width === 'undefined' ? 'undefined' : _typeof(width)) === 'object') {
            width = width[sourceColumn];
          }
          return width || this.wot.wtSettings.settings.defaultColumnWidth;
        }
      }, {
        key: 'getStretchedColumnWidth',
        value: function getStretchedColumnWidth(sourceColumn) {
          var columnWidth = this.getColumnWidth(sourceColumn);
          var width = columnWidth == null ? this.instance.wtSettings.settings.defaultColumnWidth : columnWidth;
          var calculator = this.wot.wtViewport.columnsRenderCalculator;
          if (calculator) {
            var stretchedWidth = calculator.getStretchedColumnWidth(sourceColumn, width);
            if (stretchedWidth) {
              width = stretchedWidth;
            }
          }
          return width;
        }
      }, {
        key: '_modifyRowHeaderWidth',
        value: function _modifyRowHeaderWidth(rowHeaderWidthFactory) {
          var widths = (0, _function.isFunction)(rowHeaderWidthFactory) ? rowHeaderWidthFactory() : null;
          if (Array.isArray(widths)) {
            widths = [].concat(_toConsumableArray(widths));
            widths[widths.length - 1] = this._correctRowHeaderWidth(widths[widths.length - 1]);
          } else {
            widths = this._correctRowHeaderWidth(widths);
          }
          return widths;
        }
      }, {
        key: '_correctRowHeaderWidth',
        value: function _correctRowHeaderWidth(width) {
          if (typeof width !== 'number') {
            width = this.wot.getSetting('defaultColumnWidth');
          }
          if (this.correctHeaderWidth) {
            width++;
          }
          return width;
        }
      }]);
      return Table;
    }();
    exports.default = Table;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _element = __webpack_require__(0);
    var _base = __webpack_require__(29);
    var _base2 = _interopRequireDefault(_base);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var performanceWarningAppeared = false;
    var TableRenderer = function () {
      function TableRenderer(wtTable) {
        _classCallCheck(this, TableRenderer);
        this.wtTable = wtTable;
        this.wot = wtTable.instance;
        this.instance = wtTable.instance;
        this.rowFilter = wtTable.rowFilter;
        this.columnFilter = wtTable.columnFilter;
        this.TABLE = wtTable.TABLE;
        this.THEAD = wtTable.THEAD;
        this.TBODY = wtTable.TBODY;
        this.COLGROUP = wtTable.COLGROUP;
        this.rowHeaders = [];
        this.rowHeaderCount = 0;
        this.columnHeaders = [];
        this.columnHeaderCount = 0;
        this.fixedRowsTop = 0;
        this.fixedRowsBottom = 0;
      }
      _createClass(TableRenderer, [{
        key: 'render',
        value: function render() {
          if (!this.wtTable.isWorkingOnClone()) {
            var skipRender = {};
            this.wot.getSetting('beforeDraw', true, skipRender);
            if (skipRender.skipRender === true) {
              return;
            }
          }
          this.rowHeaders = this.wot.getSetting('rowHeaders');
          this.rowHeaderCount = this.rowHeaders.length;
          this.fixedRowsTop = this.wot.getSetting('fixedRowsTop');
          this.fixedRowsBottom = this.wot.getSetting('fixedRowsBottom');
          this.columnHeaders = this.wot.getSetting('columnHeaders');
          this.columnHeaderCount = this.columnHeaders.length;
          var columnsToRender = this.wtTable.getRenderedColumnsCount();
          var rowsToRender = this.wtTable.getRenderedRowsCount();
          var totalColumns = this.wot.getSetting('totalColumns');
          var totalRows = this.wot.getSetting('totalRows');
          var workspaceWidth = void 0;
          var adjusted = false;
          if (_base2.default.isOverlayTypeOf(this.wot.cloneOverlay, _base2.default.CLONE_BOTTOM) || _base2.default.isOverlayTypeOf(this.wot.cloneOverlay, _base2.default.CLONE_BOTTOM_LEFT_CORNER)) {
            this.columnHeaders = [];
            this.columnHeaderCount = 0;
          }
          if (totalColumns >= 0) {
            this.adjustAvailableNodes();
            adjusted = true;
            this.renderColumnHeaders();
            this.renderRows(totalRows, rowsToRender, columnsToRender);
            if (!this.wtTable.isWorkingOnClone()) {
              workspaceWidth = this.wot.wtViewport.getWorkspaceWidth();
              this.wot.wtViewport.containerWidth = null;
            }
            this.adjustColumnWidths(columnsToRender);
            this.markOversizedColumnHeaders();
            this.adjustColumnHeaderHeights();
          }
          if (!adjusted) {
            this.adjustAvailableNodes();
          }
          this.removeRedundantRows(rowsToRender);
          if (!this.wtTable.isWorkingOnClone() || this.wot.isOverlayName(_base2.default.CLONE_BOTTOM)) {
            this.markOversizedRows();
          }
          if (!this.wtTable.isWorkingOnClone()) {
            this.wot.wtViewport.createVisibleCalculators();
            this.wot.wtOverlays.refresh(false);
            this.wot.wtOverlays.applyToDOM();
            var hiderWidth = (0, _element.outerWidth)(this.wtTable.hider);
            var tableWidth = (0, _element.outerWidth)(this.wtTable.TABLE);
            if (hiderWidth !== 0 && tableWidth !== hiderWidth) {
              this.adjustColumnWidths(columnsToRender);
            }
            if (workspaceWidth !== this.wot.wtViewport.getWorkspaceWidth()) {
              this.wot.wtViewport.containerWidth = null;
              var firstRendered = this.wtTable.getFirstRenderedColumn();
              var lastRendered = this.wtTable.getLastRenderedColumn();
              var defaultColumnWidth = this.wot.getSetting('defaultColumnWidth');
              var rowHeaderWidthSetting = this.wot.getSetting('rowHeaderWidth');
              rowHeaderWidthSetting = this.instance.getSetting('onModifyRowHeaderWidth', rowHeaderWidthSetting);
              if (rowHeaderWidthSetting != null) {
                for (var i = 0; i < this.rowHeaderCount; i++) {
                  var width = Array.isArray(rowHeaderWidthSetting) ? rowHeaderWidthSetting[i] : rowHeaderWidthSetting;
                  width = width == null ? defaultColumnWidth : width;
                  this.COLGROUP.childNodes[i].style.width = width + 'px';
                }
              }
              for (var _i = firstRendered; _i < lastRendered; _i++) {
                var _width = this.wtTable.getStretchedColumnWidth(_i);
                var renderedIndex = this.columnFilter.sourceToRendered(_i);
                this.COLGROUP.childNodes[renderedIndex + this.rowHeaderCount].style.width = _width + 'px';
              }
            }
            this.wot.getSetting('onDraw', true);
          } else if (this.wot.isOverlayName(_base2.default.CLONE_BOTTOM)) {
            this.wot.cloneSource.wtOverlays.adjustElementsSize();
          }
        }
      }, {
        key: 'removeRedundantRows',
        value: function removeRedundantRows(renderedRowsCount) {
          while (this.wtTable.tbodyChildrenLength > renderedRowsCount) {
            this.TBODY.removeChild(this.TBODY.lastChild);
            this.wtTable.tbodyChildrenLength--;
          }
        }
      }, {
        key: 'renderRows',
        value: function renderRows(totalRows, rowsToRender, columnsToRender) {
          var lastTD = void 0,
            TR = void 0;
          var visibleRowIndex = 0;
          var sourceRowIndex = this.rowFilter.renderedToSource(visibleRowIndex);
          var isWorkingOnClone = this.wtTable.isWorkingOnClone();
          while (sourceRowIndex < totalRows && sourceRowIndex >= 0) {
            if (!performanceWarningAppeared && visibleRowIndex > 1000) {
              performanceWarningAppeared = true;
              console.warn('Performance tip: Handsontable rendered more than 1000 visible rows. Consider limiting the number ' + 'of rendered rows by specifying the table height and/or turning off the "renderAllRows" option.');
            }
            if (rowsToRender !== void 0 && visibleRowIndex === rowsToRender) {
              break;
            }
            TR = this.getOrCreateTrForRow(visibleRowIndex, TR);
            this.renderRowHeaders(sourceRowIndex, TR);
            this.adjustColumns(TR, columnsToRender + this.rowHeaderCount);
            lastTD = this.renderCells(sourceRowIndex, TR, columnsToRender);
            if (!isWorkingOnClone || this.wot.isOverlayName(_base2.default.CLONE_BOTTOM)) {
              this.resetOversizedRow(sourceRowIndex);
            }
            if (TR.firstChild) {
              var height = this.wot.wtTable.getRowHeight(sourceRowIndex);
              if (height) {
                height--;
                TR.firstChild.style.height = height + 'px';
              } else {
                TR.firstChild.style.height = '';
              }
            }
            visibleRowIndex++;
            sourceRowIndex = this.rowFilter.renderedToSource(visibleRowIndex);
          }
        }
      }, {
        key: 'resetOversizedRow',
        value: function resetOversizedRow(sourceRow) {
          if (this.wot.getSetting('externalRowCalculator')) {
            return;
          }
          if (this.wot.wtViewport.oversizedRows && this.wot.wtViewport.oversizedRows[sourceRow]) {
            this.wot.wtViewport.oversizedRows[sourceRow] = void 0;
          }
        }
      }, {
        key: 'markOversizedRows',
        value: function markOversizedRows() {
          if (this.wot.getSetting('externalRowCalculator')) {
            return;
          }
          var rowCount = this.instance.wtTable.TBODY.childNodes.length;
          var expectedTableHeight = rowCount * this.instance.wtSettings.settings.defaultRowHeight;
          var actualTableHeight = (0, _element.innerHeight)(this.instance.wtTable.TBODY) - 1;
          var previousRowHeight = void 0;
          var rowInnerHeight = void 0;
          var sourceRowIndex = void 0;
          var currentTr = void 0;
          var rowHeader = void 0;
          var totalRows = this.instance.getSetting('totalRows');
          if (expectedTableHeight === actualTableHeight && !this.instance.getSetting('fixedRowsBottom')) {
            return;
          }
          while (rowCount) {
            rowCount--;
            sourceRowIndex = this.instance.wtTable.rowFilter.renderedToSource(rowCount);
            previousRowHeight = this.instance.wtTable.getRowHeight(sourceRowIndex);
            currentTr = this.instance.wtTable.getTrForRow(sourceRowIndex);
            rowHeader = currentTr.querySelector('th');
            if (rowHeader) {
              rowInnerHeight = (0, _element.innerHeight)(rowHeader);
            } else {
              rowInnerHeight = (0, _element.innerHeight)(currentTr) - 1;
            }
            if (!previousRowHeight && this.instance.wtSettings.settings.defaultRowHeight < rowInnerHeight || previousRowHeight < rowInnerHeight) {
              this.instance.wtViewport.oversizedRows[sourceRowIndex] = ++rowInnerHeight;
            }
          }
        }
      }, {
        key: 'markOversizedColumnHeaders',
        value: function markOversizedColumnHeaders() {
          var overlayName = this.wot.getOverlayName();
          if (!this.columnHeaderCount || this.wot.wtViewport.hasOversizedColumnHeadersMarked[overlayName] || this.wtTable.isWorkingOnClone()) {
            return;
          }
          var columnCount = this.wtTable.getRenderedColumnsCount();
          for (var i = 0; i < this.columnHeaderCount; i++) {
            for (var renderedColumnIndex = -1 * this.rowHeaderCount; renderedColumnIndex < columnCount; renderedColumnIndex++) {
              this.markIfOversizedColumnHeader(renderedColumnIndex);
            }
          }
          this.wot.wtViewport.hasOversizedColumnHeadersMarked[overlayName] = true;
        }
      }, {
        key: 'adjustColumnHeaderHeights',
        value: function adjustColumnHeaderHeights() {
          var columnHeaders = this.wot.getSetting('columnHeaders');
          var children = this.wot.wtTable.THEAD.childNodes;
          var oversizedColumnHeaders = this.wot.wtViewport.oversizedColumnHeaders;
          for (var i = 0, len = columnHeaders.length; i < len; i++) {
            if (oversizedColumnHeaders[i]) {
              if (!children[i] || children[i].childNodes.length === 0) {
                return;
              }
              children[i].childNodes[0].style.height = oversizedColumnHeaders[i] + 'px';
            }
          }
        }
      }, {
        key: 'markIfOversizedColumnHeader',
        value: function markIfOversizedColumnHeader(col) {
          var sourceColIndex = this.wot.wtTable.columnFilter.renderedToSource(col);
          var level = this.columnHeaderCount;
          var defaultRowHeight = this.wot.wtSettings.settings.defaultRowHeight;
          var previousColHeaderHeight = void 0;
          var currentHeader = void 0;
          var currentHeaderHeight = void 0;
          var columnHeaderHeightSetting = this.wot.getSetting('columnHeaderHeight') || [];
          while (level) {
            level--;
            previousColHeaderHeight = this.wot.wtTable.getColumnHeaderHeight(level);
            currentHeader = this.wot.wtTable.getColumnHeader(sourceColIndex, level);
            if (!currentHeader) {
              continue;
            }
            currentHeaderHeight = (0, _element.innerHeight)(currentHeader);
            if (!previousColHeaderHeight && defaultRowHeight < currentHeaderHeight || previousColHeaderHeight < currentHeaderHeight) {
              this.wot.wtViewport.oversizedColumnHeaders[level] = currentHeaderHeight;
            }
            if (Array.isArray(columnHeaderHeightSetting)) {
              if (columnHeaderHeightSetting[level] != null) {
                this.wot.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting[level];
              }
            } else if (!isNaN(columnHeaderHeightSetting)) {
              this.wot.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting;
            }
            if (this.wot.wtViewport.oversizedColumnHeaders[level] < (columnHeaderHeightSetting[level] || columnHeaderHeightSetting)) {
              this.wot.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting[level] || columnHeaderHeightSetting;
            }
          }
        }
      }, {
        key: 'renderCells',
        value: function renderCells(sourceRowIndex, TR, columnsToRender) {
          var TD = void 0;
          var sourceColIndex = void 0;
          for (var visibleColIndex = 0; visibleColIndex < columnsToRender; visibleColIndex++) {
            sourceColIndex = this.columnFilter.renderedToSource(visibleColIndex);
            if (visibleColIndex === 0) {
              TD = TR.childNodes[this.columnFilter.sourceColumnToVisibleRowHeadedColumn(sourceColIndex)];
            } else {
              TD = TD.nextSibling;
            }
            if (TD.nodeName == 'TH') {
              TD = replaceThWithTd(TD, TR);
            }
            if (!(0, _element.hasClass)(TD, 'hide')) {
              TD.className = '';
            }
            TD.removeAttribute('style');
            this.wot.wtSettings.settings.cellRenderer(sourceRowIndex, sourceColIndex, TD);
          }
          return TD;
        }
      }, {
        key: 'adjustColumnWidths',
        value: function adjustColumnWidths(columnsToRender) {
          var scrollbarCompensation = 0;
          var sourceInstance = this.wot.cloneSource ? this.wot.cloneSource : this.wot;
          var mainHolder = sourceInstance.wtTable.holder;
          var defaultColumnWidth = this.wot.getSetting('defaultColumnWidth');
          var rowHeaderWidthSetting = this.wot.getSetting('rowHeaderWidth');
          if (mainHolder.offsetHeight < mainHolder.scrollHeight) {
            scrollbarCompensation = (0, _element.getScrollbarWidth)();
          }
          this.wot.wtViewport.columnsRenderCalculator.refreshStretching(this.wot.wtViewport.getViewportWidth() - scrollbarCompensation);
          rowHeaderWidthSetting = this.instance.getSetting('onModifyRowHeaderWidth', rowHeaderWidthSetting);
          if (rowHeaderWidthSetting != null) {
            for (var i = 0; i < this.rowHeaderCount; i++) {
              var width = Array.isArray(rowHeaderWidthSetting) ? rowHeaderWidthSetting[i] : rowHeaderWidthSetting;
              width = width == null ? defaultColumnWidth : width;
              this.COLGROUP.childNodes[i].style.width = width + 'px';
            }
          }
          for (var renderedColIndex = 0; renderedColIndex < columnsToRender; renderedColIndex++) {
            var _width2 = this.wtTable.getStretchedColumnWidth(this.columnFilter.renderedToSource(renderedColIndex));
            this.COLGROUP.childNodes[renderedColIndex + this.rowHeaderCount].style.width = _width2 + 'px';
          }
        }
      }, {
        key: 'appendToTbody',
        value: function appendToTbody(TR) {
          this.TBODY.appendChild(TR);
          this.wtTable.tbodyChildrenLength++;
        }
      }, {
        key: 'getOrCreateTrForRow',
        value: function getOrCreateTrForRow(rowIndex, currentTr) {
          var TR = void 0;
          if (rowIndex >= this.wtTable.tbodyChildrenLength) {
            TR = this.createRow();
            this.appendToTbody(TR);
          } else if (rowIndex === 0) {
            TR = this.TBODY.firstChild;
          } else {
            TR = currentTr.nextSibling;
          }
          if (TR.className) {
            TR.removeAttribute('class');
          }
          return TR;
        }
      }, {
        key: 'createRow',
        value: function createRow() {
          var TR = document.createElement('TR');
          for (var visibleColIndex = 0; visibleColIndex < this.rowHeaderCount; visibleColIndex++) {
            TR.appendChild(document.createElement('TH'));
          }
          return TR;
        }
      }, {
        key: 'renderRowHeader',
        value: function renderRowHeader(row, col, TH) {
          TH.className = '';
          TH.removeAttribute('style');
          this.rowHeaders[col](row, TH, col);
        }
      }, {
        key: 'renderRowHeaders',
        value: function renderRowHeaders(row, TR) {
          for (var TH = TR.firstChild, visibleColIndex = 0; visibleColIndex < this.rowHeaderCount; visibleColIndex++) {
            if (!TH) {
              TH = document.createElement('TH');
              TR.appendChild(TH);
            } else if (TH.nodeName == 'TD') {
              TH = replaceTdWithTh(TH, TR);
            }
            this.renderRowHeader(row, visibleColIndex, TH);
            TH = TH.nextSibling;
          }
        }
      }, {
        key: 'adjustAvailableNodes',
        value: function adjustAvailableNodes() {
          this.adjustColGroups();
          this.adjustThead();
        }
      }, {
        key: 'renderColumnHeaders',
        value: function renderColumnHeaders() {
          if (!this.columnHeaderCount) {
            return;
          }
          var columnCount = this.wtTable.getRenderedColumnsCount();
          for (var i = 0; i < this.columnHeaderCount; i++) {
            var TR = this.getTrForColumnHeaders(i);
            for (var renderedColumnIndex = -1 * this.rowHeaderCount; renderedColumnIndex < columnCount; renderedColumnIndex++) {
              var sourceCol = this.columnFilter.renderedToSource(renderedColumnIndex);
              this.renderColumnHeader(i, sourceCol, TR.childNodes[renderedColumnIndex + this.rowHeaderCount]);
            }
          }
        }
      }, {
        key: 'adjustColGroups',
        value: function adjustColGroups() {
          var columnCount = this.wtTable.getRenderedColumnsCount();
          while (this.wtTable.colgroupChildrenLength < columnCount + this.rowHeaderCount) {
            this.COLGROUP.appendChild(document.createElement('COL'));
            this.wtTable.colgroupChildrenLength++;
          }
          while (this.wtTable.colgroupChildrenLength > columnCount + this.rowHeaderCount) {
            this.COLGROUP.removeChild(this.COLGROUP.lastChild);
            this.wtTable.colgroupChildrenLength--;
          }
          if (this.rowHeaderCount) {
            (0, _element.addClass)(this.COLGROUP.childNodes[0], 'rowHeader');
          }
        }
      }, {
        key: 'adjustThead',
        value: function adjustThead() {
          var columnCount = this.wtTable.getRenderedColumnsCount();
          var TR = this.THEAD.firstChild;
          if (this.columnHeaders.length) {
            for (var i = 0, len = this.columnHeaders.length; i < len; i++) {
              TR = this.THEAD.childNodes[i];
              if (!TR) {
                TR = document.createElement('TR');
                this.THEAD.appendChild(TR);
              }
              this.theadChildrenLength = TR.childNodes.length;
              while (this.theadChildrenLength < columnCount + this.rowHeaderCount) {
                TR.appendChild(document.createElement('TH'));
                this.theadChildrenLength++;
              }
              while (this.theadChildrenLength > columnCount + this.rowHeaderCount) {
                TR.removeChild(TR.lastChild);
                this.theadChildrenLength--;
              }
            }
            var theadChildrenLength = this.THEAD.childNodes.length;
            if (theadChildrenLength > this.columnHeaders.length) {
              for (var _i2 = this.columnHeaders.length; _i2 < theadChildrenLength; _i2++) {
                this.THEAD.removeChild(this.THEAD.lastChild);
              }
            }
          } else if (TR) {
            (0, _element.empty)(TR);
          }
        }
      }, {
        key: 'getTrForColumnHeaders',
        value: function getTrForColumnHeaders(index) {
          return this.THEAD.childNodes[index];
        }
      }, {
        key: 'renderColumnHeader',
        value: function renderColumnHeader(row, col, TH) {
          TH.className = '';
          TH.removeAttribute('style');
          return this.columnHeaders[row](col, TH, row);
        }
      }, {
        key: 'adjustColumns',
        value: function adjustColumns(TR, desiredCount) {
          var count = TR.childNodes.length;
          while (count < desiredCount) {
            var TD = document.createElement('TD');
            TR.appendChild(TD);
            count++;
          }
          while (count > desiredCount) {
            TR.removeChild(TR.lastChild);
            count--;
          }
        }
      }, {
        key: 'removeRedundantColumns',
        value: function removeRedundantColumns(columnsToRender) {
          while (this.wtTable.tbodyChildrenLength > columnsToRender) {
            this.TBODY.removeChild(this.TBODY.lastChild);
            this.wtTable.tbodyChildrenLength--;
          }
        }
      }]);
      return TableRenderer;
    }();

    function replaceTdWithTh(TD, TR) {
      var TH = document.createElement('TH');
      TR.insertBefore(TH, TD);
      TR.removeChild(TD);
      return TH;
    }

    function replaceThWithTd(TH, TR) {
      var TD = document.createElement('TD');
      TR.insertBefore(TD, TH);
      TR.removeChild(TH);
      return TD;
    }
    exports.default = TableRenderer;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _element = __webpack_require__(0);
    var _object = __webpack_require__(3);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _viewportColumns = __webpack_require__(251);
    var _viewportColumns2 = _interopRequireDefault(_viewportColumns);
    var _viewportRows = __webpack_require__(252);
    var _viewportRows2 = _interopRequireDefault(_viewportRows);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var Viewport = function () {
      function Viewport(wotInstance) {
        var _this = this;
        _classCallCheck(this, Viewport);
        this.wot = wotInstance;
        this.instance = this.wot;
        this.oversizedRows = [];
        this.oversizedColumnHeaders = [];
        this.hasOversizedColumnHeadersMarked = {};
        this.clientHeight = 0;
        this.containerWidth = NaN;
        this.rowHeaderWidth = NaN;
        this.rowsVisibleCalculator = null;
        this.columnsVisibleCalculator = null;
        this.eventManager = new _eventManager2.default(this.wot);
        this.eventManager.addEventListener(window, 'resize', function () {
          _this.clientHeight = _this.getWorkspaceHeight();
        });
      }
      _createClass(Viewport, [{
        key: 'getWorkspaceHeight',
        value: function getWorkspaceHeight() {
          var trimmingContainer = this.instance.wtOverlays.topOverlay.trimmingContainer;
          var elemHeight = void 0;
          var height = 0;
          if (trimmingContainer === window) {
            height = document.documentElement.clientHeight;
          } else {
            elemHeight = (0, _element.outerHeight)(trimmingContainer);
            height = elemHeight > 0 && trimmingContainer.clientHeight > 0 ? trimmingContainer.clientHeight : Infinity;
          }
          return height;
        }
      }, {
        key: 'getWorkspaceWidth',
        value: function getWorkspaceWidth() {
          var width = void 0;
          var totalColumns = this.wot.getSetting('totalColumns');
          var trimmingContainer = this.instance.wtOverlays.leftOverlay.trimmingContainer;
          var overflow = void 0;
          var stretchSetting = this.wot.getSetting('stretchH');
          var docOffsetWidth = document.documentElement.offsetWidth;
          var preventOverflow = this.wot.getSetting('preventOverflow');
          if (preventOverflow) {
            return (0, _element.outerWidth)(this.instance.wtTable.wtRootElement);
          }
          if (this.wot.getSetting('freezeOverlays')) {
            width = Math.min(docOffsetWidth - this.getWorkspaceOffset().left, docOffsetWidth);
          } else {
            width = Math.min(this.getContainerFillWidth(), docOffsetWidth - this.getWorkspaceOffset().left, docOffsetWidth);
          }
          if (trimmingContainer === window && totalColumns > 0 && this.sumColumnWidths(0, totalColumns - 1) > width) {
            return document.documentElement.clientWidth;
          }
          if (trimmingContainer !== window) {
            overflow = (0, _element.getStyle)(this.instance.wtOverlays.leftOverlay.trimmingContainer, 'overflow');
            if (overflow == 'scroll' || overflow == 'hidden' || overflow == 'auto') {
              return Math.max(width, trimmingContainer.clientWidth);
            }
          }
          if (stretchSetting === 'none' || !stretchSetting) {
            return Math.max(width, (0, _element.outerWidth)(this.instance.wtTable.TABLE));
          }
          return width;
        }
      }, {
        key: 'hasVerticalScroll',
        value: function hasVerticalScroll() {
          return this.getWorkspaceActualHeight() > this.getWorkspaceHeight();
        }
      }, {
        key: 'hasHorizontalScroll',
        value: function hasHorizontalScroll() {
          return this.getWorkspaceActualWidth() > this.getWorkspaceWidth();
        }
      }, {
        key: 'sumColumnWidths',
        value: function sumColumnWidths(from, length) {
          var sum = 0;
          while (from < length) {
            sum += this.wot.wtTable.getColumnWidth(from);
            from++;
          }
          return sum;
        }
      }, {
        key: 'getContainerFillWidth',
        value: function getContainerFillWidth() {
          if (this.containerWidth) {
            return this.containerWidth;
          }
          var mainContainer = this.instance.wtTable.holder;
          var fillWidth = void 0;
          var dummyElement = void 0;
          dummyElement = document.createElement('div');
          dummyElement.style.width = '100%';
          dummyElement.style.height = '1px';
          mainContainer.appendChild(dummyElement);
          fillWidth = dummyElement.offsetWidth;
          this.containerWidth = fillWidth;
          mainContainer.removeChild(dummyElement);
          return fillWidth;
        }
      }, {
        key: 'getWorkspaceOffset',
        value: function getWorkspaceOffset() {
          return (0, _element.offset)(this.wot.wtTable.TABLE);
        }
      }, {
        key: 'getWorkspaceActualHeight',
        value: function getWorkspaceActualHeight() {
          return (0, _element.outerHeight)(this.wot.wtTable.TABLE);
        }
      }, {
        key: 'getWorkspaceActualWidth',
        value: function getWorkspaceActualWidth() {
          return (0, _element.outerWidth)(this.wot.wtTable.TABLE) || (0, _element.outerWidth)(this.wot.wtTable.TBODY) || (0, _element.outerWidth)(this.wot.wtTable.THEAD);
        }
      }, {
        key: 'getColumnHeaderHeight',
        value: function getColumnHeaderHeight() {
          if (isNaN(this.columnHeaderHeight)) {
            this.columnHeaderHeight = (0, _element.outerHeight)(this.wot.wtTable.THEAD);
          }
          return this.columnHeaderHeight;
        }
      }, {
        key: 'getViewportHeight',
        value: function getViewportHeight() {
          var containerHeight = this.getWorkspaceHeight();
          var columnHeaderHeight = void 0;
          if (containerHeight === Infinity) {
            return containerHeight;
          }
          columnHeaderHeight = this.getColumnHeaderHeight();
          if (columnHeaderHeight > 0) {
            containerHeight -= columnHeaderHeight;
          }
          return containerHeight;
        }
      }, {
        key: 'getRowHeaderWidth',
        value: function getRowHeaderWidth() {
          var rowHeadersHeightSetting = this.instance.getSetting('rowHeaderWidth');
          var rowHeaders = this.instance.getSetting('rowHeaders');
          if (rowHeadersHeightSetting) {
            this.rowHeaderWidth = 0;
            for (var i = 0, len = rowHeaders.length; i < len; i++) {
              this.rowHeaderWidth += rowHeadersHeightSetting[i] || rowHeadersHeightSetting;
            }
          }
          if (this.wot.cloneSource) {
            return this.wot.cloneSource.wtViewport.getRowHeaderWidth();
          }
          if (isNaN(this.rowHeaderWidth)) {
            if (rowHeaders.length) {
              var TH = this.instance.wtTable.TABLE.querySelector('TH');
              this.rowHeaderWidth = 0;
              for (var _i = 0, _len = rowHeaders.length; _i < _len; _i++) {
                if (TH) {
                  this.rowHeaderWidth += (0, _element.outerWidth)(TH);
                  TH = TH.nextSibling;
                } else {
                  this.rowHeaderWidth += 50;
                }
              }
            } else {
              this.rowHeaderWidth = 0;
            }
          }
          this.rowHeaderWidth = this.instance.getSetting('onModifyRowHeaderWidth', this.rowHeaderWidth) || this.rowHeaderWidth;
          return this.rowHeaderWidth;
        }
      }, {
        key: 'getViewportWidth',
        value: function getViewportWidth() {
          var containerWidth = this.getWorkspaceWidth();
          var rowHeaderWidth = void 0;
          if (containerWidth === Infinity) {
            return containerWidth;
          }
          rowHeaderWidth = this.getRowHeaderWidth();
          if (rowHeaderWidth > 0) {
            return containerWidth - rowHeaderWidth;
          }
          return containerWidth;
        }
      }, {
        key: 'createRowsCalculator',
        value: function createRowsCalculator() {
          var _this2 = this;
          var visible = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
          var height = void 0;
          var pos = void 0;
          var fixedRowsTop = void 0;
          var scrollbarHeight = void 0;
          var fixedRowsBottom = void 0;
          var fixedRowsHeight = void 0;
          var totalRows = void 0;
          this.rowHeaderWidth = NaN;
          if (this.wot.wtSettings.settings.renderAllRows) {
            height = Infinity;
          } else {
            height = this.getViewportHeight();
          }
          pos = this.wot.wtOverlays.topOverlay.getScrollPosition() - this.wot.wtOverlays.topOverlay.getTableParentOffset();
          if (pos < 0) {
            pos = 0;
          }
          fixedRowsTop = this.wot.getSetting('fixedRowsTop');
          fixedRowsBottom = this.wot.getSetting('fixedRowsBottom');
          totalRows = this.wot.getSetting('totalRows');
          if (fixedRowsTop) {
            fixedRowsHeight = this.wot.wtOverlays.topOverlay.sumCellSizes(0, fixedRowsTop);
            pos += fixedRowsHeight;
            height -= fixedRowsHeight;
          }
          if (fixedRowsBottom && this.wot.wtOverlays.bottomOverlay.clone) {
            fixedRowsHeight = this.wot.wtOverlays.bottomOverlay.sumCellSizes(totalRows - fixedRowsBottom, totalRows);
            height -= fixedRowsHeight;
          }
          if (this.wot.wtTable.holder.clientHeight === this.wot.wtTable.holder.offsetHeight) {
            scrollbarHeight = 0;
          } else {
            scrollbarHeight = (0, _element.getScrollbarWidth)();
          }
          return new _viewportRows2.default(height, pos, this.wot.getSetting('totalRows'), function (sourceRow) {
            return _this2.wot.wtTable.getRowHeight(sourceRow);
          }, visible ? null : this.wot.wtSettings.settings.viewportRowCalculatorOverride, visible, scrollbarHeight);
        }
      }, {
        key: 'createColumnsCalculator',
        value: function createColumnsCalculator() {
          var _this3 = this;
          var visible = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
          var width = this.getViewportWidth();
          var pos = void 0;
          var fixedColumnsLeft = void 0;
          this.columnHeaderHeight = NaN;
          pos = this.wot.wtOverlays.leftOverlay.getScrollPosition() - this.wot.wtOverlays.leftOverlay.getTableParentOffset();
          if (pos < 0) {
            pos = 0;
          }
          fixedColumnsLeft = this.wot.getSetting('fixedColumnsLeft');
          if (fixedColumnsLeft) {
            var fixedColumnsWidth = this.wot.wtOverlays.leftOverlay.sumCellSizes(0, fixedColumnsLeft);
            pos += fixedColumnsWidth;
            width -= fixedColumnsWidth;
          }
          if (this.wot.wtTable.holder.clientWidth !== this.wot.wtTable.holder.offsetWidth) {
            width -= (0, _element.getScrollbarWidth)();
          }
          return new _viewportColumns2.default(width, pos, this.wot.getSetting('totalColumns'), function (sourceCol) {
            return _this3.wot.wtTable.getColumnWidth(sourceCol);
          }, visible ? null : this.wot.wtSettings.settings.viewportColumnCalculatorOverride, visible, this.wot.getSetting('stretchH'), function (stretchedWidth, column) {
            return _this3.wot.getSetting('onBeforeStretchingColumnWidth', stretchedWidth, column);
          });
        }
      }, {
        key: 'createRenderCalculators',
        value: function createRenderCalculators() {
          var fastDraw = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
          if (fastDraw) {
            var proposedRowsVisibleCalculator = this.createRowsCalculator(true);
            var proposedColumnsVisibleCalculator = this.createColumnsCalculator(true);
            if (!(this.areAllProposedVisibleRowsAlreadyRendered(proposedRowsVisibleCalculator) && this.areAllProposedVisibleColumnsAlreadyRendered(proposedColumnsVisibleCalculator))) {
              fastDraw = false;
            }
          }
          if (!fastDraw) {
            this.rowsRenderCalculator = this.createRowsCalculator();
            this.columnsRenderCalculator = this.createColumnsCalculator();
          }
          this.rowsVisibleCalculator = null;
          this.columnsVisibleCalculator = null;
          return fastDraw;
        }
      }, {
        key: 'createVisibleCalculators',
        value: function createVisibleCalculators() {
          this.rowsVisibleCalculator = this.createRowsCalculator(true);
          this.columnsVisibleCalculator = this.createColumnsCalculator(true);
        }
      }, {
        key: 'areAllProposedVisibleRowsAlreadyRendered',
        value: function areAllProposedVisibleRowsAlreadyRendered(proposedRowsVisibleCalculator) {
          if (this.rowsVisibleCalculator) {
            if (proposedRowsVisibleCalculator.startRow < this.rowsRenderCalculator.startRow || proposedRowsVisibleCalculator.startRow === this.rowsRenderCalculator.startRow && proposedRowsVisibleCalculator.startRow > 0) {
              return false;
            } else if (proposedRowsVisibleCalculator.endRow > this.rowsRenderCalculator.endRow || proposedRowsVisibleCalculator.endRow === this.rowsRenderCalculator.endRow && proposedRowsVisibleCalculator.endRow < this.wot.getSetting('totalRows') - 1) {
              return false;
            }
            return true;
          }
          return false;
        }
      }, {
        key: 'areAllProposedVisibleColumnsAlreadyRendered',
        value: function areAllProposedVisibleColumnsAlreadyRendered(proposedColumnsVisibleCalculator) {
          if (this.columnsVisibleCalculator) {
            if (proposedColumnsVisibleCalculator.startColumn < this.columnsRenderCalculator.startColumn || proposedColumnsVisibleCalculator.startColumn === this.columnsRenderCalculator.startColumn && proposedColumnsVisibleCalculator.startColumn > 0) {
              return false;
            } else if (proposedColumnsVisibleCalculator.endColumn > this.columnsRenderCalculator.endColumn || proposedColumnsVisibleCalculator.endColumn === this.columnsRenderCalculator.endColumn && proposedColumnsVisibleCalculator.endColumn < this.wot.getSetting('totalColumns') - 1) {
              return false;
            }
            return true;
          }
          return false;
        }
      }, {
        key: 'resetHasOversizedColumnHeadersMarked',
        value: function resetHasOversizedColumnHeadersMarked() {
          (0, _object.objectEach)(this.hasOversizedColumnHeadersMarked, function (value, key, object) {
            object[key] = void 0;
          });
        }
      }]);
      return Viewport;
    }();
    exports.default = Viewport;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _unicode = __webpack_require__(15);
    var _mixed = __webpack_require__(23);
    var _string = __webpack_require__(28);
    var _array = __webpack_require__(2);
    var _element = __webpack_require__(0);
    var _handsontableEditor = __webpack_require__(264);
    var _handsontableEditor2 = _interopRequireDefault(_handsontableEditor);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }
    var AutocompleteEditor = _handsontableEditor2.default.prototype.extend();
    AutocompleteEditor.prototype.init = function () {
      _handsontableEditor2.default.prototype.init.apply(this, arguments);
      this.query = null;
      this.strippedChoices = [];
      this.rawChoices = [];
    };
    AutocompleteEditor.prototype.getValue = function () {
      var _this2 = this;
      var selectedValue = this.rawChoices.find(function (value) {
        var strippedValue = _this2.stripValueIfNeeded(value);
        return strippedValue === _this2.TEXTAREA.value;
      });
      if ((0, _mixed.isDefined)(selectedValue)) {
        return selectedValue;
      }
      return this.TEXTAREA.value;
    };
    AutocompleteEditor.prototype.createElements = function () {
      _handsontableEditor2.default.prototype.createElements.apply(this, arguments);
      (0, _element.addClass)(this.htContainer, 'autocompleteEditor');
      (0, _element.addClass)(this.htContainer, window.navigator.platform.indexOf('Mac') === -1 ? '' : 'htMacScroll');
    };
    var skipOne = false;

    function onBeforeKeyDown(event) {
      skipOne = false;
      var editor = this.getActiveEditor();
      if ((0, _unicode.isPrintableChar)(event.keyCode) || event.keyCode === _unicode.KEY_CODES.BACKSPACE || event.keyCode === _unicode.KEY_CODES.DELETE || event.keyCode === _unicode.KEY_CODES.INSERT) {
        var timeOffset = 0;
        if (event.keyCode === _unicode.KEY_CODES.C && (event.ctrlKey || event.metaKey)) {
          return;
        }
        if (!editor.isOpened()) {
          timeOffset += 10;
        }
        if (editor.htEditor) {
          editor.instance._registerTimeout(setTimeout(function () {
            editor.queryChoices(editor.TEXTAREA.value);
            skipOne = true;
          }, timeOffset));
        }
      }
    }
    AutocompleteEditor.prototype.prepare = function () {
      this.instance.addHook('beforeKeyDown', onBeforeKeyDown);
      _handsontableEditor2.default.prototype.prepare.apply(this, arguments);
    };
    AutocompleteEditor.prototype.open = function () {
      this.TEXTAREA_PARENT.style.overflow = 'auto';
      _handsontableEditor2.default.prototype.open.apply(this, arguments);
      this.TEXTAREA_PARENT.style.overflow = '';
      var choicesListHot = this.htEditor.getInstance();
      var _this = this;
      var trimDropdown = this.cellProperties.trimDropdown === void 0 ? true : this.cellProperties.trimDropdown;
      this.TEXTAREA.style.visibility = 'visible';
      this.focus();
      choicesListHot.updateSettings({
        colWidths: trimDropdown ? [(0, _element.outerWidth)(this.TEXTAREA) - 2] : void 0,
        width: trimDropdown ? (0, _element.outerWidth)(this.TEXTAREA) + (0, _element.getScrollbarWidth)() + 2 : void 0,
        afterRenderer: function afterRenderer(TD, row, col, prop, value, cellProperties) {
          var _this$cellProperties = _this.cellProperties,
            filteringCaseSensitive = _this$cellProperties.filteringCaseSensitive,
            allowHtml = _this$cellProperties.allowHtml;
          var indexOfMatch = void 0;
          var match = void 0;
          value = (0, _mixed.stringify)(value);
          if (value && !allowHtml) {
            indexOfMatch = filteringCaseSensitive === true ? value.indexOf(this.query) : value.toLowerCase().indexOf(_this.query.toLowerCase());
            if (indexOfMatch !== -1) {
              match = value.substr(indexOfMatch, _this.query.length);
              value = value.replace(match, '<strong>' + match + '</strong>');
            }
          }
          TD.innerHTML = value;
        },
        autoColumnSize: true,
        modifyColWidth: function modifyColWidth(width, col) {
          var autoWidths = this.getPlugin('autoColumnSize').widths;
          if (autoWidths[col]) {
            width = autoWidths[col];
          }
          return trimDropdown ? width : width + 15;
        }
      });
      this.htEditor.view.wt.wtTable.holder.parentNode.style['padding-right'] = (0, _element.getScrollbarWidth)() + 2 + 'px';
      if (skipOne) {
        skipOne = false;
      }
      _this.instance._registerTimeout(setTimeout(function () {
        _this.queryChoices(_this.TEXTAREA.value);
      }, 0));
    };
    AutocompleteEditor.prototype.close = function () {
      _handsontableEditor2.default.prototype.close.apply(this, arguments);
    };
    AutocompleteEditor.prototype.queryChoices = function (query) {
      var _this3 = this;
      this.query = query;
      var source = this.cellProperties.source;
      if (typeof source == 'function') {
        source.call(this.cellProperties, query, function (choices) {
          _this3.rawChoices = choices;
          _this3.updateChoicesList(_this3.stripValuesIfNeeded(choices));
        });
      } else if (Array.isArray(source)) {
        this.rawChoices = source;
        this.updateChoicesList(this.stripValuesIfNeeded(source));
      } else {
        this.updateChoicesList([]);
      }
    };
    AutocompleteEditor.prototype.updateChoicesList = function (choices) {
      var pos = (0, _element.getCaretPosition)(this.TEXTAREA);
      var endPos = (0, _element.getSelectionEndPosition)(this.TEXTAREA);
      var sortByRelevanceSetting = this.cellProperties.sortByRelevance;
      var filterSetting = this.cellProperties.filter;
      var orderByRelevance = null;
      var highlightIndex = null;
      if (sortByRelevanceSetting) {
        orderByRelevance = AutocompleteEditor.sortByRelevance(this.stripValueIfNeeded(this.getValue()), choices, this.cellProperties.filteringCaseSensitive);
      }
      var orderByRelevanceLength = Array.isArray(orderByRelevance) ? orderByRelevance.length : 0;
      if (filterSetting === false) {
        if (orderByRelevanceLength) {
          highlightIndex = orderByRelevance[0];
        }
      } else {
        var sorted = [];
        for (var i = 0, choicesCount = choices.length; i < choicesCount; i++) {
          if (sortByRelevanceSetting && orderByRelevanceLength <= i) {
            break;
          }
          if (orderByRelevanceLength) {
            sorted.push(choices[orderByRelevance[i]]);
          } else {
            sorted.push(choices[i]);
          }
        }
        highlightIndex = 0;
        choices = sorted;
      }
      this.strippedChoices = choices;
      this.htEditor.loadData((0, _array.pivot)([choices]));
      this.updateDropdownHeight();
      this.flipDropdownIfNeeded();
      if (this.cellProperties.strict === true) {
        this.highlightBestMatchingChoice(highlightIndex);
      }
      this.instance.listen();
      this.TEXTAREA.focus();
      (0, _element.setCaretPosition)(this.TEXTAREA, pos, pos === endPos ? void 0 : endPos);
    };
    AutocompleteEditor.prototype.flipDropdownIfNeeded = function () {
      var textareaOffset = (0, _element.offset)(this.TEXTAREA);
      var textareaHeight = (0, _element.outerHeight)(this.TEXTAREA);
      var dropdownHeight = this.getDropdownHeight();
      var trimmingContainer = (0, _element.getTrimmingContainer)(this.instance.view.wt.wtTable.TABLE);
      var trimmingContainerScrollTop = trimmingContainer.scrollTop;
      var headersHeight = (0, _element.outerHeight)(this.instance.view.wt.wtTable.THEAD);
      var containerOffset = {
        row: 0,
        col: 0
      };
      if (trimmingContainer !== window) {
        containerOffset = (0, _element.offset)(trimmingContainer);
      }
      var spaceAbove = textareaOffset.top - containerOffset.top - headersHeight + trimmingContainerScrollTop;
      var spaceBelow = trimmingContainer.scrollHeight - spaceAbove - headersHeight - textareaHeight;
      var flipNeeded = dropdownHeight > spaceBelow && spaceAbove > spaceBelow;
      if (flipNeeded) {
        this.flipDropdown(dropdownHeight);
      } else {
        this.unflipDropdown();
      }
      this.limitDropdownIfNeeded(flipNeeded ? spaceAbove : spaceBelow, dropdownHeight);
      return flipNeeded;
    };
    AutocompleteEditor.prototype.limitDropdownIfNeeded = function (spaceAvailable, dropdownHeight) {
      if (dropdownHeight > spaceAvailable) {
        var tempHeight = 0;
        var i = 0;
        var lastRowHeight = 0;
        var height = null;
        do {
          lastRowHeight = this.htEditor.getRowHeight(i) || this.htEditor.view.wt.wtSettings.settings.defaultRowHeight;
          tempHeight += lastRowHeight;
          i++;
        } while (tempHeight < spaceAvailable);
        height = tempHeight - lastRowHeight;
        if (this.htEditor.flipped) {
          this.htEditor.rootElement.style.top = parseInt(this.htEditor.rootElement.style.top, 10) + dropdownHeight - height + 'px';
        }
        this.setDropdownHeight(tempHeight - lastRowHeight);
      }
    };
    AutocompleteEditor.prototype.flipDropdown = function (dropdownHeight) {
      var dropdownStyle = this.htEditor.rootElement.style;
      dropdownStyle.position = 'absolute';
      dropdownStyle.top = -dropdownHeight + 'px';
      this.htEditor.flipped = true;
    };
    AutocompleteEditor.prototype.unflipDropdown = function () {
      var dropdownStyle = this.htEditor.rootElement.style;
      if (dropdownStyle.position === 'absolute') {
        dropdownStyle.position = '';
        dropdownStyle.top = '';
      }
      this.htEditor.flipped = void 0;
    };
    AutocompleteEditor.prototype.updateDropdownHeight = function () {
      var currentDropdownWidth = this.htEditor.getColWidth(0) + (0, _element.getScrollbarWidth)() + 2;
      var trimDropdown = this.cellProperties.trimDropdown;
      this.htEditor.updateSettings({
        height: this.getDropdownHeight(),
        width: trimDropdown ? void 0 : currentDropdownWidth
      });
      this.htEditor.view.wt.wtTable.alignOverlaysWithTrimmingContainer();
    };
    AutocompleteEditor.prototype.setDropdownHeight = function (height) {
      this.htEditor.updateSettings({
        height: height
      });
    };
    AutocompleteEditor.prototype.finishEditing = function (restoreOriginalValue) {
      if (!restoreOriginalValue) {
        this.instance.removeHook('beforeKeyDown', onBeforeKeyDown);
      }
      _handsontableEditor2.default.prototype.finishEditing.apply(this, arguments);
    };
    AutocompleteEditor.prototype.highlightBestMatchingChoice = function (index) {
      if (typeof index === 'number') {
        this.htEditor.selectCell(index, 0);
      } else {
        this.htEditor.deselectCell();
      }
    };
    AutocompleteEditor.sortByRelevance = function (value, choices, caseSensitive) {
      var choicesRelevance = [];
      var currentItem = void 0;
      var valueLength = value.length;
      var valueIndex = void 0;
      var charsLeft = void 0;
      var result = [];
      var i = void 0;
      var choicesCount = choices.length;
      if (valueLength === 0) {
        for (i = 0; i < choicesCount; i++) {
          result.push(i);
        }
        return result;
      }
      for (i = 0; i < choicesCount; i++) {
        currentItem = (0, _string.stripTags)((0, _mixed.stringify)(choices[i]));
        if (caseSensitive) {
          valueIndex = currentItem.indexOf(value);
        } else {
          valueIndex = currentItem.toLowerCase().indexOf(value.toLowerCase());
        }
        if (valueIndex !== -1) {
          charsLeft = currentItem.length - valueIndex - valueLength;
          choicesRelevance.push({
            baseIndex: i,
            index: valueIndex,
            charsLeft: charsLeft,
            value: currentItem
          });
        }
      }
      choicesRelevance.sort(function (a, b) {
        if (b.index === -1) {
          return -1;
        }
        if (a.index === -1) {
          return 1;
        }
        if (a.index < b.index) {
          return -1;
        } else if (b.index < a.index) {
          return 1;
        } else if (a.index === b.index) {
          if (a.charsLeft < b.charsLeft) {
            return -1;
          } else if (a.charsLeft > b.charsLeft) {
            return 1;
          }
        }
        return 0;
      });
      for (i = 0, choicesCount = choicesRelevance.length; i < choicesCount; i++) {
        result.push(choicesRelevance[i].baseIndex);
      }
      return result;
    };
    AutocompleteEditor.prototype.getDropdownHeight = function () {
      var firstRowHeight = this.htEditor.getInstance().getRowHeight(0) || 23;
      var visibleRows = this.cellProperties.visibleRows;
      return this.strippedChoices.length >= visibleRows ? visibleRows * firstRowHeight : this.strippedChoices.length * firstRowHeight + 8;
    };
    AutocompleteEditor.prototype.stripValueIfNeeded = function (value) {
      return this.stripValuesIfNeeded([value])[0];
    };
    AutocompleteEditor.prototype.stripValuesIfNeeded = function (values) {
      var allowHtml = this.cellProperties.allowHtml;
      var stringifiedValues = (0, _array.arrayMap)(values, function (value) {
        return (0, _mixed.stringify)(value);
      });
      var strippedValues = (0, _array.arrayMap)(stringifiedValues, function (value) {
        return allowHtml ? value : (0, _string.stripTags)(value);
      });
      return strippedValues;
    };
    AutocompleteEditor.prototype.allowKeyEventPropagation = function (keyCode) {
      var selected = {
        row: this.htEditor.getSelectedRange() ? this.htEditor.getSelectedRange().from.row : -1
      };
      var allowed = false;
      if (keyCode === _unicode.KEY_CODES.ARROW_DOWN && selected.row > 0 && selected.row < this.htEditor.countRows() - 1) {
        allowed = true;
      }
      if (keyCode === _unicode.KEY_CODES.ARROW_UP && selected.row > -1) {
        allowed = true;
      }
      return allowed;
    };
    AutocompleteEditor.prototype.discardEditor = function (result) {
      _handsontableEditor2.default.prototype.discardEditor.apply(this, arguments);
      this.instance.view.render();
    };
    exports.default = AutocompleteEditor;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _unicode = __webpack_require__(15);
    var _object = __webpack_require__(3);
    var _element = __webpack_require__(0);
    var _event = __webpack_require__(7);
    var _textEditor = __webpack_require__(44);
    var _textEditor2 = _interopRequireDefault(_textEditor);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }
    var HandsontableEditor = _textEditor2.default.prototype.extend();
    HandsontableEditor.prototype.createElements = function () {
      _textEditor2.default.prototype.createElements.apply(this, arguments);
      var DIV = document.createElement('DIV');
      DIV.className = 'handsontableEditor';
      this.TEXTAREA_PARENT.appendChild(DIV);
      this.htContainer = DIV;
      this.assignHooks();
    };
    HandsontableEditor.prototype.prepare = function (td, row, col, prop, value, cellProperties) {
      _textEditor2.default.prototype.prepare.apply(this, arguments);
      var parent = this;
      var options = {
        startRows: 0,
        startCols: 0,
        minRows: 0,
        minCols: 0,
        className: 'listbox',
        copyPaste: false,
        autoColumnSize: false,
        autoRowSize: false,
        readOnly: true,
        fillHandle: false,
        afterOnCellMouseDown: function afterOnCellMouseDown(_, coords) {
          var value = this.getSourceData(coords.row, coords.col);
          if (value !== void 0) {
            parent.setValue(value);
          }
          parent.instance.destroyEditor();
        }
      };
      if (this.cellProperties.handsontable) {
        (0, _object.extend)(options, cellProperties.handsontable);
      }
      this.htOptions = options;
    };
    var onBeforeKeyDown = function onBeforeKeyDown(event) {
      if ((0, _event.isImmediatePropagationStopped)(event)) {
        return;
      }
      var editor = this.getActiveEditor();
      var innerHOT = editor.htEditor.getInstance();
      var rowToSelect;
      var selectedRow;
      if (event.keyCode == _unicode.KEY_CODES.ARROW_DOWN) {
        if (!innerHOT.getSelected() && !innerHOT.flipped) {
          rowToSelect = 0;
        } else if (innerHOT.getSelected()) {
          if (innerHOT.flipped) {
            rowToSelect = innerHOT.getSelected()[0] + 1;
          } else if (!innerHOT.flipped) {
            selectedRow = innerHOT.getSelected()[0];
            var lastRow = innerHOT.countRows() - 1;
            rowToSelect = Math.min(lastRow, selectedRow + 1);
          }
        }
      } else if (event.keyCode == _unicode.KEY_CODES.ARROW_UP) {
        if (!innerHOT.getSelected() && innerHOT.flipped) {
          rowToSelect = innerHOT.countRows() - 1;
        } else if (innerHOT.getSelected()) {
          if (innerHOT.flipped) {
            selectedRow = innerHOT.getSelected()[0];
            rowToSelect = Math.max(0, selectedRow - 1);
          } else {
            selectedRow = innerHOT.getSelected()[0];
            rowToSelect = selectedRow - 1;
          }
        }
      }
      if (rowToSelect !== void 0) {
        if (rowToSelect < 0 || innerHOT.flipped && rowToSelect > innerHOT.countRows() - 1) {
          innerHOT.deselectCell();
        } else {
          innerHOT.selectCell(rowToSelect, 0);
        }
        if (innerHOT.getData().length) {
          event.preventDefault();
          (0, _event.stopImmediatePropagation)(event);
          editor.instance.listen();
          editor.TEXTAREA.focus();
        }
      }
    };
    HandsontableEditor.prototype.open = function () {
      this.instance.addHook('beforeKeyDown', onBeforeKeyDown);
      _textEditor2.default.prototype.open.apply(this, arguments);
      if (this.htEditor) {
        this.htEditor.destroy();
      }
      this.htEditor = new this.instance.constructor(this.htContainer, this.htOptions);
      this.htEditor.init();
      if (this.cellProperties.strict) {
        this.htEditor.selectCell(0, 0);
        this.TEXTAREA.style.visibility = 'hidden';
      } else {
        this.htEditor.deselectCell();
        this.TEXTAREA.style.visibility = 'visible';
      } (0, _element.setCaretPosition)(this.TEXTAREA, 0, this.TEXTAREA.value.length);
    };
    HandsontableEditor.prototype.close = function () {
      this.instance.removeHook('beforeKeyDown', onBeforeKeyDown);
      this.instance.listen();
      _textEditor2.default.prototype.close.apply(this, arguments);
    };
    HandsontableEditor.prototype.focus = function () {
      this.instance.listen();
      _textEditor2.default.prototype.focus.apply(this, arguments);
    };
    HandsontableEditor.prototype.beginEditing = function (initialValue) {
      var onBeginEditing = this.instance.getSettings().onBeginEditing;
      if (onBeginEditing && onBeginEditing() === false) {
        return;
      }
      _textEditor2.default.prototype.beginEditing.apply(this, arguments);
    };
    HandsontableEditor.prototype.finishEditing = function (isCancelled, ctrlDown) {
      if (this.htEditor && this.htEditor.isListening()) {
        this.instance.listen();
      }
      if (this.htEditor && this.htEditor.getSelected()) {
        var value = this.htEditor.getInstance().getValue();
        if (value !== void 0) {
          this.setValue(value);
        }
      }
      return _textEditor2.default.prototype.finishEditing.apply(this, arguments);
    };
    HandsontableEditor.prototype.assignHooks = function () {
      var _this = this;
      this.instance.addHook('afterDestroy', function () {
        if (_this.htEditor) {
          _this.htEditor.destroy();
        }
      });
    };
    exports.default = HandsontableEditor;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _array = __webpack_require__(2);
    var _object = __webpack_require__(3);
    var _number = __webpack_require__(5);
    var MIXIN_NAME = 'arrayMapper';
    var arrayMapper = {
      _arrayMap: [],
      getValueByIndex: function getValueByIndex(index) {
        var value = void 0;
        return (value = this._arrayMap[index]) === void 0 ? null : value;
      },
      getIndexByValue: function getIndexByValue(value) {
        var index = void 0;
        return (index = this._arrayMap.indexOf(value)) === -1 ? null : index;
      },
      insertItems: function insertItems(index) {
        var _this = this;
        var amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
        var newIndex = (0, _array.arrayMax)(this._arrayMap) + 1;
        var addedItems = [];
        (0, _number.rangeEach)(amount - 1, function (count) {
          addedItems.push(_this._arrayMap.splice(index + count, 0, newIndex + count));
        });
        return addedItems;
      },
      removeItems: function removeItems(index) {
        var _this2 = this;
        var amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
        var removedItems = [];
        if (Array.isArray(index)) {
          var mapCopy = [].concat(this._arrayMap);
          index.sort(function (a, b) {
            return b - a;
          });
          removedItems = (0, _array.arrayReduce)(index, function (acc, item) {
            _this2._arrayMap.splice(item, 1);
            return acc.concat(mapCopy.slice(item, item + 1));
          }, []);
        } else {
          removedItems = this._arrayMap.splice(index, amount);
        }
        return removedItems;
      },
      unshiftItems: function unshiftItems(index) {
        var amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
        var removedItems = this.removeItems(index, amount);

        function countRowShift(logicalRow) {
          return (0, _array.arrayReduce)(removedItems, function (count, removedLogicalRow) {
            if (logicalRow > removedLogicalRow) {
              count++;
            }
            return count;
          }, 0);
        }
        this._arrayMap = (0, _array.arrayMap)(this._arrayMap, function (logicalRow, physicalRow) {
          var rowShift = countRowShift(logicalRow);
          if (rowShift) {
            logicalRow -= rowShift;
          }
          return logicalRow;
        });
      },
      shiftItems: function shiftItems(index) {
        var _this3 = this;
        var amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
        this._arrayMap = (0, _array.arrayMap)(this._arrayMap, function (row) {
          if (row >= index) {
            row += amount;
          }
          return row;
        });
        (0, _number.rangeEach)(amount - 1, function (count) {
          _this3._arrayMap.splice(index + count, 0, index + count);
        });
      },
      clearMap: function clearMap() {
        this._arrayMap.length = 0;
      }
    };
    (0, _object.defineGetter)(arrayMapper, 'MIXIN_NAME', MIXIN_NAME, {
      writable: false,
      enumerable: false
    });
    exports.default = arrayMapper;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _number = __webpack_require__(5);

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var STATE_INITIALIZED = 0;
    var STATE_BUILT = 1;
    var STATE_APPENDED = 2;
    var UNIT = 'px';
    var BaseUI = function () {
      function BaseUI(hotInstance) {
        _classCallCheck(this, BaseUI);
        this.hot = hotInstance;
        this._element = null;
        this.state = STATE_INITIALIZED;
      }
      _createClass(BaseUI, [{
        key: 'appendTo',
        value: function appendTo(wrapper) {
          wrapper.appendChild(this._element);
          this.state = STATE_APPENDED;
        }
      }, {
        key: 'build',
        value: function build() {
          this._element = document.createElement('div');
          this.state = STATE_BUILT;
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          if (this.isAppended()) {
            this._element.parentElement.removeChild(this._element);
          }
          this._element = null;
          this.state = STATE_INITIALIZED;
        }
      }, {
        key: 'isAppended',
        value: function isAppended() {
          return this.state === STATE_APPENDED;
        }
      }, {
        key: 'isBuilt',
        value: function isBuilt() {
          return this.state >= STATE_BUILT;
        }
      }, {
        key: 'setPosition',
        value: function setPosition(top, left) {
          if ((0, _number.isNumeric)(top)) {
            this._element.style.top = top + UNIT;
          }
          if ((0, _number.isNumeric)(left)) {
            this._element.style.left = left + UNIT;
          }
        }
      }, {
        key: 'getPosition',
        value: function getPosition() {
          return {
            top: this._element.style.top ? parseInt(this._element.style.top, 10) : 0,
            left: this._element.style.left ? parseInt(this._element.style.left, 10) : 0
          };
        }
      }, {
        key: 'setSize',
        value: function setSize(width, height) {
          if ((0, _number.isNumeric)(width)) {
            this._element.style.width = width + UNIT;
          }
          if ((0, _number.isNumeric)(height)) {
            this._element.style.height = height + UNIT;
          }
        }
      }, {
        key: 'getSize',
        value: function getSize() {
          return {
            width: this._element.style.width ? parseInt(this._element.style.width, 10) : 0,
            height: this._element.style.height ? parseInt(this._element.style.height, 10) : 0
          };
        }
      }, {
        key: 'setOffset',
        value: function setOffset(top, left) {
          if ((0, _number.isNumeric)(top)) {
            this._element.style.marginTop = top + UNIT;
          }
          if ((0, _number.isNumeric)(left)) {
            this._element.style.marginLeft = left + UNIT;
          }
        }
      }, {
        key: 'getOffset',
        value: function getOffset() {
          return {
            top: this._element.style.marginTop ? parseInt(this._element.style.marginTop, 10) : 0,
            left: this._element.style.marginLeft ? parseInt(this._element.style.marginLeft, 10) : 0
          };
        }
      }]);
      return BaseUI;
    }();
    exports.default = BaseUI;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var STATE_INITIALIZED = 0;
    var STATE_BUILT = 1;
    var STATE_APPENDED = 2;
    var UNIT = 'px';
    var BaseUI = function () {
      function BaseUI(hotInstance) {
        _classCallCheck(this, BaseUI);
        this.hot = hotInstance;
        this._element = null;
        this.state = STATE_INITIALIZED;
      }
      _createClass(BaseUI, [{
        key: 'appendTo',
        value: function appendTo(wrapper) {
          wrapper.appendChild(this._element);
          this.state = STATE_APPENDED;
        }
      }, {
        key: 'build',
        value: function build() {
          this._element = document.createElement('div');
          this.state = STATE_BUILT;
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          if (this.isAppended()) {
            this._element.parentElement.removeChild(this._element);
          }
          this._element = null;
          this.state = STATE_INITIALIZED;
        }
      }, {
        key: 'isAppended',
        value: function isAppended() {
          return this.state === STATE_APPENDED;
        }
      }, {
        key: 'isBuilt',
        value: function isBuilt() {
          return this.state >= STATE_BUILT;
        }
      }, {
        key: 'setPosition',
        value: function setPosition(top, left) {
          if (top) {
            this._element.style.top = top + UNIT;
          }
          if (left) {
            this._element.style.left = left + UNIT;
          }
        }
      }, {
        key: 'getPosition',
        value: function getPosition() {
          return {
            top: this._element.style.top ? parseInt(this._element.style.top, 10) : 0,
            left: this._element.style.left ? parseInt(this._element.style.left, 10) : 0
          };
        }
      }, {
        key: 'setSize',
        value: function setSize(width, height) {
          if (width) {
            this._element.style.width = width + UNIT;
          }
          if (height) {
            this._element.style.height = height + UNIT;
          }
        }
      }, {
        key: 'getSize',
        value: function getSize() {
          return {
            width: this._element.style.width ? parseInt(this._element.style.width, 10) : 0,
            height: this._element.style.height ? parseInt(this._element.style.height, 10) : 0
          };
        }
      }, {
        key: 'setOffset',
        value: function setOffset(top, left) {
          if (top) {
            this._element.style.marginTop = top + UNIT;
          }
          if (left) {
            this._element.style.marginLeft = left + UNIT;
          }
        }
      }, {
        key: 'getOffset',
        value: function getOffset() {
          return {
            top: this._element.style.marginTop ? parseInt(this._element.style.marginTop, 10) : 0,
            left: this._element.style.marginLeft ? parseInt(this._element.style.marginLeft, 10) : 0
          };
        }
      }]);
      return BaseUI;
    }();
    exports.default = BaseUI;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.RecordTranslator = undefined;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    exports.registerIdentity = registerIdentity;
    exports.getTranslator = getTranslator;
    var _core = __webpack_require__(66);
    var _core2 = _interopRequireDefault(_core);
    var _object = __webpack_require__(3);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var RecordTranslator = function () {
      function RecordTranslator(hot) {
        _classCallCheck(this, RecordTranslator);
        this.hot = hot;
      }
      _createClass(RecordTranslator, [{
        key: 'toVisualRow',
        value: function toVisualRow(row) {
          return this.hot.runHooks('unmodifyRow', row);
        }
      }, {
        key: 'toVisualColumn',
        value: function toVisualColumn(column) {
          return this.hot.runHooks('unmodifyCol', column);
        }
      }, {
        key: 'toVisual',
        value: function toVisual(row, column) {
          var result = void 0;
          if ((0, _object.isObject)(row)) {
            result = {
              row: this.toVisualRow(row.row),
              column: this.toVisualColumn(row.column)
            };
          } else {
            result = [this.toVisualRow(row), this.toVisualColumn(column)];
          }
          return result;
        }
      }, {
        key: 'toPhysicalRow',
        value: function toPhysicalRow(row) {
          return this.hot.runHooks('modifyRow', row);
        }
      }, {
        key: 'toPhysicalColumn',
        value: function toPhysicalColumn(column) {
          return this.hot.runHooks('modifyCol', column);
        }
      }, {
        key: 'toPhysical',
        value: function toPhysical(row, column) {
          var result = void 0;
          if ((0, _object.isObject)(row)) {
            result = {
              row: this.toPhysicalRow(row.row),
              column: this.toPhysicalColumn(row.column)
            };
          } else {
            result = [this.toPhysicalRow(row), this.toPhysicalColumn(column)];
          }
          return result;
        }
      }]);
      return RecordTranslator;
    }();
    exports.RecordTranslator = RecordTranslator;
    var identities = new WeakMap();
    var translatorSingletons = new WeakMap();

    function registerIdentity(identity, hot) {
      identities.set(identity, hot);
    }

    function getTranslator(identity) {
      var singleton = void 0;
      if (!(identity instanceof _core2.default)) {
        if (!identities.has(identity)) {
          throw Error('Record translator was not registered for this object identity');
        }
        identity = identities.get(identity);
      }
      if (translatorSingletons.has(identity)) {
        singleton = translatorSingletons.get(identity);
      } else {
        singleton = new RecordTranslator(identity);
        translatorSingletons.set(identity, singleton);
      }
      return singleton;
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _object = __webpack_require__(3);
    var _number = __webpack_require__(5);
    var _mixed = __webpack_require__(23);

    function _defineProperty(obj, key, value) {
      if (key in obj) {
        Object.defineProperty(obj, key, {
          value: value,
          enumerable: true,
          configurable: true,
          writable: true
        });
      } else {
        obj[key] = value;
      }
      return obj;
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var SamplesGenerator = function () {
      _createClass(SamplesGenerator, null, [{
        key: 'SAMPLE_COUNT',
        get: function get() {
          return 3;
        }
      }]);

      function SamplesGenerator(dataFactory) {
        _classCallCheck(this, SamplesGenerator);
        this.samples = null;
        this.dataFactory = dataFactory;
        this.customSampleCount = null;
        this.allowDuplicates = false;
      }
      _createClass(SamplesGenerator, [{
        key: 'getSampleCount',
        value: function getSampleCount() {
          if (this.customSampleCount) {
            return this.customSampleCount;
          }
          return SamplesGenerator.SAMPLE_COUNT;
        }
      }, {
        key: 'setSampleCount',
        value: function setSampleCount(sampleCount) {
          this.customSampleCount = sampleCount;
        }
      }, {
        key: 'setAllowDuplicates',
        value: function setAllowDuplicates(allowDuplicates) {
          this.allowDuplicates = allowDuplicates;
        }
      }, {
        key: 'generateRowSamples',
        value: function generateRowSamples(rowRange, colRange) {
          return this.generateSamples('row', colRange, rowRange);
        }
      }, {
        key: 'generateColumnSamples',
        value: function generateColumnSamples(colRange, rowRange) {
          return this.generateSamples('col', rowRange, colRange);
        }
      }, {
        key: 'generateSamples',
        value: function generateSamples(type, range, specifierRange) {
          var _this = this;
          var samples = new Map();
          if (typeof specifierRange === 'number') {
            specifierRange = {
              from: specifierRange,
              to: specifierRange
            };
          } (0, _number.rangeEach)(specifierRange.from, specifierRange.to, function (index) {
            var sample = _this.generateSample(type, range, index);
            samples.set(index, sample);
          });
          return samples;
        }
      }, {
        key: 'generateSample',
        value: function generateSample(type, range, specifierValue) {
          var _this2 = this;
          var samples = new Map();
          var sampledValues = [];
          var length = void 0;
          (0, _number.rangeEach)(range.from, range.to, function (index) {
            var value = void 0;
            if (type === 'row') {
              value = _this2.dataFactory(specifierValue, index);
            } else if (type === 'col') {
              value = _this2.dataFactory(index, specifierValue);
            } else {
              throw new Error('Unsupported sample type');
            }
            if ((0, _object.isObject)(value)) {
              length = Object.keys(value).length;
            } else if (Array.isArray(value)) {
              length = value.length;
            } else {
              length = (0, _mixed.stringify)(value).length;
            }
            if (!samples.has(length)) {
              samples.set(length, {
                needed: _this2.getSampleCount(),
                strings: []
              });
            }
            var sample = samples.get(length);
            if (sample.needed) {
              var duplicate = sampledValues.indexOf(value) > -1;
              if (!duplicate || _this2.allowDuplicates) {
                var computedKey = type === 'row' ? 'col' : 'row';
                sample.strings.push(_defineProperty({
                  value: value
                }, computedKey, index));
                sampledValues.push(value);
                sample.needed--;
              }
            }
          });
          return samples;
        }
      }]);
      return SamplesGenerator;
    }();
    exports.default = SamplesGenerator;
  }), (function (module, exports, __webpack_require__) {
    var toIObject = __webpack_require__(27);
    var toLength = __webpack_require__(21);
    var toAbsoluteIndex = __webpack_require__(63);
    module.exports = function (IS_INCLUDES) {
      return function ($this, el, fromIndex) {
        var O = toIObject($this);
        var length = toLength(O.length);
        var index = toAbsoluteIndex(fromIndex, length);
        var value;
        if (IS_INCLUDES && el != el)
          while (length > index) {
            value = O[index++];
            if (value != value) return true;
          } else
          for (; length > index; index++)
            if (IS_INCLUDES || index in O) {
              if (O[index] === el) return IS_INCLUDES || index || 0;
            }
        return !IS_INCLUDES && -1;
      };
    };
  }), (function (module, exports, __webpack_require__) {
    var cof = __webpack_require__(38);
    var TAG = __webpack_require__(8)('toStringTag');
    var ARG = cof(function () {
      return arguments;
    }()) == 'Arguments';
    var tryGet = function (it, key) {
      try {
        return it[key];
      } catch (e) { }
    };
    module.exports = function (it) {
      var O, T, B;
      return it === undefined ? 'Undefined' : it === null ? 'Null' : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T : ARG ? cof(O) : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var dP = __webpack_require__(18).f;
    var create = __webpack_require__(80);
    var redefineAll = __webpack_require__(62);
    var ctx = __webpack_require__(30);
    var anInstance = __webpack_require__(55);
    var forOf = __webpack_require__(59);
    var $iterDefine = __webpack_require__(281);
    var step = __webpack_require__(282);
    var setSpecies = __webpack_require__(288);
    var DESCRIPTORS = __webpack_require__(20);
    var fastKey = __webpack_require__(47).fastKey;
    var validate = __webpack_require__(41);
    var SIZE = DESCRIPTORS ? '_s' : 'size';
    var getEntry = function (that, key) {
      var index = fastKey(key);
      var entry;
      if (index !== 'F') return that._i[index];
      for (entry = that._f; entry; entry = entry.n) {
        if (entry.k == key) return entry;
      }
    };
    module.exports = {
      getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {
        var C = wrapper(function (that, iterable) {
          anInstance(that, C, NAME, '_i');
          that._t = NAME;
          that._i = create(null);
          that._f = undefined;
          that._l = undefined;
          that[SIZE] = 0;
          if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);
        });
        redefineAll(C.prototype, {
          clear: function clear() {
            for (var that = validate(this, NAME), data = that._i, entry = that._f; entry; entry = entry.n) {
              entry.r = true;
              if (entry.p) entry.p = entry.p.n = undefined;
              delete data[entry.i];
            }
            that._f = that._l = undefined;
            that[SIZE] = 0;
          },
          'delete': function (key) {
            var that = validate(this, NAME);
            var entry = getEntry(that, key);
            if (entry) {
              var next = entry.n;
              var prev = entry.p;
              delete that._i[entry.i];
              entry.r = true;
              if (prev) prev.n = next;
              if (next) next.p = prev;
              if (that._f == entry) that._f = next;
              if (that._l == entry) that._l = prev;
              that[SIZE]--;
            }
            return !!entry;
          },
          forEach: function forEach(callbackfn) {
            validate(this, NAME);
            var f = ctx(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
            var entry;
            while (entry = entry ? entry.n : this._f) {
              f(entry.v, entry.k, this);
              while (entry && entry.r) entry = entry.p;
            }
          },
          has: function has(key) {
            return !!getEntry(validate(this, NAME), key);
          }
        });
        if (DESCRIPTORS) dP(C.prototype, 'size', {
          get: function () {
            return validate(this, NAME)[SIZE];
          }
        });
        return C;
      },
      def: function (that, key, value) {
        var entry = getEntry(that, key);
        var prev, index;
        if (entry) {
          entry.v = value;
        } else {
          that._l = entry = {
            i: index = fastKey(key, true),
            k: key,
            v: value,
            p: prev = that._l,
            n: undefined,
            r: false
          };
          if (!that._f) that._f = entry;
          if (prev) prev.n = entry;
          that[SIZE]++;
          if (index !== 'F') that._i[index] = entry;
        }
        return that;
      },
      getEntry: getEntry,
      setStrong: function (C, NAME, IS_MAP) {
        $iterDefine(C, NAME, function (iterated, kind) {
          this._t = validate(iterated, NAME);
          this._k = kind;
          this._l = undefined;
        }, function () {
          var that = this;
          var kind = that._k;
          var entry = that._l;
          while (entry && entry.r) entry = entry.p;
          if (!that._t || !(that._l = entry = entry ? entry.n : that._t._f)) {
            that._t = undefined;
            return step(1);
          }
          if (kind == 'keys') return step(0, entry.k);
          if (kind == 'values') return step(0, entry.v);
          return step(0, [entry.k, entry.v]);
        }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);
        setSpecies(NAME);
      }
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var redefineAll = __webpack_require__(62);
    var getWeak = __webpack_require__(47).getWeak;
    var anObject = __webpack_require__(17);
    var isObject = __webpack_require__(12);
    var anInstance = __webpack_require__(55);
    var forOf = __webpack_require__(59);
    var createArrayMethod = __webpack_require__(56);
    var $has = __webpack_require__(26);
    var validate = __webpack_require__(41);
    var arrayFind = createArrayMethod(5);
    var arrayFindIndex = createArrayMethod(6);
    var id = 0;
    var uncaughtFrozenStore = function (that) {
      return that._l || (that._l = new UncaughtFrozenStore());
    };
    var UncaughtFrozenStore = function () {
      this.a = [];
    };
    var findUncaughtFrozen = function (store, key) {
      return arrayFind(store.a, function (it) {
        return it[0] === key;
      });
    };
    UncaughtFrozenStore.prototype = {
      get: function (key) {
        var entry = findUncaughtFrozen(this, key);
        if (entry) return entry[1];
      },
      has: function (key) {
        return !!findUncaughtFrozen(this, key);
      },
      set: function (key, value) {
        var entry = findUncaughtFrozen(this, key);
        if (entry) entry[1] = value;
        else this.a.push([key, value]);
      },
      'delete': function (key) {
        var index = arrayFindIndex(this.a, function (it) {
          return it[0] === key;
        });
        if (~index) this.a.splice(index, 1);
        return !!~index;
      }
    };
    module.exports = {
      getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {
        var C = wrapper(function (that, iterable) {
          anInstance(that, C, NAME, '_i');
          that._t = NAME;
          that._i = id++;
          that._l = undefined;
          if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);
        });
        redefineAll(C.prototype, {
          'delete': function (key) {
            if (!isObject(key)) return false;
            var data = getWeak(key);
            if (data === true) return uncaughtFrozenStore(validate(this, NAME))['delete'](key);
            return data && $has(data, this._i) && delete data[this._i];
          },
          has: function has(key) {
            if (!isObject(key)) return false;
            var data = getWeak(key);
            if (data === true) return uncaughtFrozenStore(validate(this, NAME)).has(key);
            return data && $has(data, this._i);
          }
        });
        return C;
      },
      def: function (that, key, value) {
        var data = getWeak(anObject(key), true);
        if (data === true) uncaughtFrozenStore(that).set(key, value);
        else data[that._i] = value;
        return that;
      },
      ufstore: uncaughtFrozenStore
    };
  }), (function (module, exports, __webpack_require__) {
    var document = __webpack_require__(10).document;
    module.exports = document && document.documentElement;
  }), (function (module, exports, __webpack_require__) {
    module.exports = !__webpack_require__(20) && !__webpack_require__(25)(function () {
      return Object.defineProperty(__webpack_require__(75)('div'), 'a', {
        get: function () {
          return 7;
        }
      }).a != 7;
    });
  }), (function (module, exports, __webpack_require__) {
    var Iterators = __webpack_require__(46);
    var ITERATOR = __webpack_require__(8)('iterator');
    var ArrayProto = Array.prototype;
    module.exports = function (it) {
      return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
    };
  }), (function (module, exports, __webpack_require__) {
    var cof = __webpack_require__(38);
    module.exports = Array.isArray || function isArray(arg) {
      return cof(arg) == 'Array';
    };
  }), (function (module, exports, __webpack_require__) {
    var isObject = __webpack_require__(12);
    var floor = Math.floor;
    module.exports = function isInteger(it) {
      return !isObject(it) && isFinite(it) && floor(it) === it;
    };
  }), (function (module, exports, __webpack_require__) {
    var isObject = __webpack_require__(12);
    var cof = __webpack_require__(38);
    var MATCH = __webpack_require__(8)('match');
    module.exports = function (it) {
      var isRegExp;
      return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : cof(it) == 'RegExp');
    };
  }), (function (module, exports, __webpack_require__) {
    var anObject = __webpack_require__(17);
    module.exports = function (iterator, fn, value, entries) {
      try {
        return entries ? fn(anObject(value)[0], value[1]) : fn(value);
      } catch (e) {
        var ret = iterator['return'];
        if (ret !== undefined) anObject(ret.call(iterator));
        throw e;
      }
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var LIBRARY = __webpack_require__(60);
    var $export = __webpack_require__(1);
    var redefine = __webpack_require__(32);
    var hide = __webpack_require__(31);
    var has = __webpack_require__(26);
    var Iterators = __webpack_require__(46);
    var $iterCreate = __webpack_require__(397);
    var setToStringTag = __webpack_require__(50);
    var getPrototypeOf = __webpack_require__(401);
    var ITERATOR = __webpack_require__(8)('iterator');
    var BUGGY = !([].keys && 'next' in [].keys());
    var FF_ITERATOR = '@@iterator';
    var KEYS = 'keys';
    var VALUES = 'values';
    var returnThis = function () {
      return this;
    };
    module.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {
      $iterCreate(Constructor, NAME, next);
      var getMethod = function (kind) {
        if (!BUGGY && kind in proto) return proto[kind];
        switch (kind) {
          case KEYS:
            return function keys() {
              return new Constructor(this, kind);
            };
          case VALUES:
            return function values() {
              return new Constructor(this, kind);
            };
        }
        return function entries() {
          return new Constructor(this, kind);
        };
      };
      var TAG = NAME + ' Iterator';
      var DEF_VALUES = DEFAULT == VALUES;
      var VALUES_BUG = false;
      var proto = Base.prototype;
      var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT];
      var $default = $native || getMethod(DEFAULT);
      var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined;
      var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;
      var methods, key, IteratorPrototype;
      if ($anyNative) {
        IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));
        if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {
          setToStringTag(IteratorPrototype, TAG, true);
          if (!LIBRARY && !has(IteratorPrototype, ITERATOR)) hide(IteratorPrototype, ITERATOR, returnThis);
        }
      }
      if (DEF_VALUES && $native && $native.name !== VALUES) {
        VALUES_BUG = true;
        $default = function values() {
          return $native.call(this);
        };
      }
      if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {
        hide(proto, ITERATOR, $default);
      }
      Iterators[NAME] = $default;
      Iterators[TAG] = returnThis;
      if (DEFAULT) {
        methods = {
          values: DEF_VALUES ? $default : getMethod(VALUES),
          keys: IS_SET ? $default : getMethod(KEYS),
          entries: $entries
        };
        if (FORCED)
          for (key in methods) {
            if (!(key in proto)) redefine(proto, key, methods[key]);
          } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
      }
      return methods;
    };
  }), (function (module, exports) {
    module.exports = function (done, value) {
      return {
        value: value,
        done: !!done
      };
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var aFunction = __webpack_require__(54);

    function PromiseCapability(C) {
      var resolve, reject;
      this.promise = new C(function ($$resolve, $$reject) {
        if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
        resolve = $$resolve;
        reject = $$reject;
      });
      this.resolve = aFunction(resolve);
      this.reject = aFunction(reject);
    }
    module.exports.f = function (C) {
      return new PromiseCapability(C);
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var getKeys = __webpack_require__(39);
    var gOPS = __webpack_require__(61);
    var pIE = __webpack_require__(48);
    var toObject = __webpack_require__(40);
    var IObject = __webpack_require__(78);
    var $assign = Object.assign;
    module.exports = !$assign || __webpack_require__(25)(function () {
      var A = {};
      var B = {};
      var S = Symbol();
      var K = 'abcdefghijklmnopqrst';
      A[S] = 7;
      K.split('').forEach(function (k) {
        B[k] = k;
      });
      return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
    }) ? function assign(target, source) {
      var T = toObject(target);
      var aLen = arguments.length;
      var index = 1;
      var getSymbols = gOPS.f;
      var isEnum = pIE.f;
      while (aLen > index) {
        var S = IObject(arguments[index++]);
        var keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S);
        var length = keys.length;
        var j = 0;
        var key;
        while (length > j)
          if (isEnum.call(S, key = keys[j++])) T[key] = S[key];
      }
      return T;
    } : $assign;
  }), (function (module, exports, __webpack_require__) {
    var has = __webpack_require__(26);
    var toIObject = __webpack_require__(27);
    var arrayIndexOf = __webpack_require__(270)(false);
    var IE_PROTO = __webpack_require__(83)('IE_PROTO');
    module.exports = function (object, names) {
      var O = toIObject(object);
      var i = 0;
      var result = [];
      var key;
      for (key in O)
        if (key != IE_PROTO) has(O, key) && result.push(key);
      while (names.length > i)
        if (has(O, key = names[i++])) {
          ~arrayIndexOf(result, key) || result.push(key);
        }
      return result;
    };
  }), (function (module, exports, __webpack_require__) {
    var getKeys = __webpack_require__(39);
    var toIObject = __webpack_require__(27);
    var isEnum = __webpack_require__(48).f;
    module.exports = function (isEntries) {
      return function (it) {
        var O = toIObject(it);
        var keys = getKeys(O);
        var length = keys.length;
        var i = 0;
        var result = [];
        var key;
        while (length > i)
          if (isEnum.call(O, key = keys[i++])) {
            result.push(isEntries ? [key, O[key]] : O[key]);
          }
        return result;
      };
    };
  }), (function (module, exports, __webpack_require__) {
    var isObject = __webpack_require__(12);
    var anObject = __webpack_require__(17);
    var check = function (O, proto) {
      anObject(O);
      if (!isObject(proto) && proto !== null) throw TypeError(proto + ": can't set as prototype!");
    };
    module.exports = {
      set: Object.setPrototypeOf || ('__proto__' in {} ? function (test, buggy, set) {
        try {
          set = __webpack_require__(30)(Function.call, __webpack_require__(81).f(Object.prototype, '__proto__').set, 2);
          set(test, []);
          buggy = !(test instanceof Array);
        } catch (e) {
          buggy = true;
        }
        return function setPrototypeOf(O, proto) {
          check(O, proto);
          if (buggy) O.__proto__ = proto;
          else set(O, proto);
          return O;
        };
      }({}, false) : undefined),
      check: check
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var global = __webpack_require__(10);
    var dP = __webpack_require__(18);
    var DESCRIPTORS = __webpack_require__(20);
    var SPECIES = __webpack_require__(8)('species');
    module.exports = function (KEY) {
      var C = global[KEY];
      if (DESCRIPTORS && C && !C[SPECIES]) dP.f(C, SPECIES, {
        configurable: true,
        get: function () {
          return this;
        }
      });
    };
  }), (function (module, exports, __webpack_require__) {
    var toLength = __webpack_require__(21);
    var repeat = __webpack_require__(290);
    var defined = __webpack_require__(33);
    module.exports = function (that, maxLength, fillString, left) {
      var S = String(defined(that));
      var stringLength = S.length;
      var fillStr = fillString === undefined ? ' ' : String(fillString);
      var intMaxLength = toLength(maxLength);
      if (intMaxLength <= stringLength || fillStr == '') return S;
      var fillLen = intMaxLength - stringLength;
      var stringFiller = repeat.call(fillStr, Math.ceil(fillLen / fillStr.length));
      if (stringFiller.length > fillLen) stringFiller = stringFiller.slice(0, fillLen);
      return left ? stringFiller + S : S + stringFiller;
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var toInteger = __webpack_require__(64);
    var defined = __webpack_require__(33);
    module.exports = function repeat(count) {
      var str = String(defined(this));
      var res = '';
      var n = toInteger(count);
      if (n < 0 || n == Infinity) throw RangeError("Count can't be negative");
      for (; n > 0;
        (n >>>= 1) && (str += str))
        if (n & 1) res += str;
      return res;
    };
  }), (function (module, exports, __webpack_require__) {
    exports.f = __webpack_require__(8);
  }), (function (module, exports, __webpack_require__) {
    var classof = __webpack_require__(271);
    var ITERATOR = __webpack_require__(8)('iterator');
    var Iterators = __webpack_require__(46);
    module.exports = __webpack_require__(45).getIteratorMethod = function (it) {
      if (it != undefined) return it[ITERATOR] || it['@@iterator'] || Iterators[classof(it)];
    };
  }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.default = jQueryWrapper;

    function jQueryWrapper(Handsontable) {
      var jQuery = typeof window === 'undefined' ? false : window.jQuery;
      if (!jQuery) {
        return;
      }
      jQuery.fn.handsontable = function (action) {
        var $this = this.first();
        var instance = $this.data('handsontable');
        if (typeof action !== 'string') {
          var userSettings = action || {};
          if (instance) {
            instance.updateSettings(userSettings);
          } else {
            instance = new Handsontable.Core($this[0], userSettings);
            $this.data('handsontable', instance);
            instance.init();
          }
          return $this;
        }
        var args = [];
        var output = void 0;
        if (arguments.length > 1) {
          for (var i = 1, ilen = arguments.length; i < ilen; i++) {
            args.push(arguments[i]);
          }
        }
        if (instance) {
          if (typeof instance[action] !== 'undefined') {
            output = instance[action].apply(instance, args);
            if (action === 'destroy') {
              $this.removeData();
            }
          } else {
            throw new Error('Handsontable do not provide action: ' + action);
          }
        }
        return output;
      };
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.Base = exports.Search = exports.MultipleSelectionHandles = exports.MergeCells = exports.ManualRowResize = exports.ManualRowMove = exports.ManualColumnResize = exports.ManualColumnMove = exports.ManualColumnFreeze = exports.DragToScroll = exports.CopyPaste = exports.ContextMenu = exports.AutoRowSize = exports.AutoFill = exports.AutoColumnSize = undefined;
    var _autoColumnSize = __webpack_require__(335);
    var _autoColumnSize2 = _interopRequireDefault(_autoColumnSize);
    var _autofill = __webpack_require__(337);
    var _autofill2 = _interopRequireDefault(_autofill);
    var _autoRowSize = __webpack_require__(336);
    var _autoRowSize2 = _interopRequireDefault(_autoRowSize);
    var _contextMenu = __webpack_require__(340);
    var _contextMenu2 = _interopRequireDefault(_contextMenu);
    var _copyPaste = __webpack_require__(357);
    var _copyPaste2 = _interopRequireDefault(_copyPaste);
    var _dragToScroll = __webpack_require__(359);
    var _dragToScroll2 = _interopRequireDefault(_dragToScroll);
    var _manualColumnFreeze = __webpack_require__(362);
    var _manualColumnFreeze2 = _interopRequireDefault(_manualColumnFreeze);
    var _manualColumnMove = __webpack_require__(364);
    var _manualColumnMove2 = _interopRequireDefault(_manualColumnMove);
    var _manualColumnResize = __webpack_require__(367);
    var _manualColumnResize2 = _interopRequireDefault(_manualColumnResize);
    var _manualRowMove = __webpack_require__(368);
    var _manualRowMove2 = _interopRequireDefault(_manualRowMove);
    var _manualRowResize = __webpack_require__(372);
    var _manualRowResize2 = _interopRequireDefault(_manualRowResize);
    var _mergeCells = __webpack_require__(373);
    var _mergeCells2 = _interopRequireDefault(_mergeCells);
    var _multipleSelectionHandles = __webpack_require__(374);
    var _multipleSelectionHandles2 = _interopRequireDefault(_multipleSelectionHandles);
    var _search = __webpack_require__(375);
    var _search2 = _interopRequireDefault(_search);
    var _base = __webpack_require__(16);
    var _base2 = _interopRequireDefault(_base);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }
    exports.AutoColumnSize = _autoColumnSize2.default;
    exports.AutoFill = _autofill2.default;
    exports.AutoRowSize = _autoRowSize2.default;
    exports.ContextMenu = _contextMenu2.default;
    exports.CopyPaste = _copyPaste2.default;
    exports.DragToScroll = _dragToScroll2.default;
    exports.ManualColumnFreeze = _manualColumnFreeze2.default;
    exports.ManualColumnMove = _manualColumnMove2.default;
    exports.ManualColumnResize = _manualColumnResize2.default;
    exports.ManualRowMove = _manualRowMove2.default;
    exports.ManualRowResize = _manualRowResize2.default;
    exports.MergeCells = _mergeCells2.default;
    exports.MultipleSelectionHandles = _multipleSelectionHandles2.default;
    exports.Search = _search2.default;
    exports.Base = _base2.default;
  }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) { }), (function (module, exports) {
    module.exports = function (module) {
      if (!module.webpackPolyfill) {
        module.deprecate = function () { };
        module.paths = [];
        if (!module.children) module.children = [];
        Object.defineProperty(module, "loaded", {
          enumerable: true,
          get: function () {
            return module.l;
          }
        });
        Object.defineProperty(module, "id", {
          enumerable: true,
          get: function () {
            return module.i;
          }
        });
        module.webpackPolyfill = 1;
      }
      return module;
    };
  }), (function (module, exports) { }), (function (module, exports, __webpack_require__) {
    "use strict";

    function autoResize() {
      var defaults = {
        minHeight: 200,
        maxHeight: 300,
        minWidth: 100,
        maxWidth: 300
      },
        el, body = document.body,
        text = document.createTextNode(''),
        span = document.createElement('SPAN'),
        observe = function observe(element, event, handler) {
          if (element.attachEvent) {
            element.attachEvent('on' + event, handler);
          } else {
            element.addEventListener(event, handler, false);
          }
        },
        _unObserve = function _unObserve(element, event, handler) {
          if (element.removeEventListener) {
            element.removeEventListener(event, handler, false);
          } else {
            element.detachEvent('on' + event, handler);
          }
        },
        resize = function resize(newChar) {
          var width, scrollHeight;
          if (!newChar) {
            newChar = "";
          } else if (!/^[a-zA-Z \.,\\\/\|0-9]$/.test(newChar)) {
            newChar = ".";
          }
          if (text.textContent !== void 0) {
            text.textContent = el.value + newChar;
          } else {
            text.data = el.value + newChar;
          }
          span.style.fontSize = getComputedStyle(el).fontSize;
          span.style.fontFamily = getComputedStyle(el).fontFamily;
          span.style.whiteSpace = "pre";
          body.appendChild(span);
          width = span.clientWidth + 2;
          body.removeChild(span);
          el.style.height = defaults.minHeight + 'px';
          if (defaults.minWidth > width) {
            el.style.width = defaults.minWidth + 'px';
          } else if (width > defaults.maxWidth) {
            el.style.width = defaults.maxWidth + 'px';
          } else {
            el.style.width = width + 'px';
          }
          scrollHeight = el.scrollHeight ? el.scrollHeight - 1 : 0;
          if (defaults.minHeight > scrollHeight) {
            el.style.height = defaults.minHeight + 'px';
          } else if (defaults.maxHeight < scrollHeight) {
            el.style.height = defaults.maxHeight + 'px';
            el.style.overflowY = 'visible';
          } else {
            el.style.height = scrollHeight + 'px';
          }
        },
        delayedResize = function delayedResize() {
          window.setTimeout(resize, 0);
        },
        extendDefaults = function extendDefaults(config) {
          if (config && config.minHeight) {
            if (config.minHeight == 'inherit') {
              defaults.minHeight = el.clientHeight;
            } else {
              var minHeight = parseInt(config.minHeight);
              if (!isNaN(minHeight)) {
                defaults.minHeight = minHeight;
              }
            }
          }
          if (config && config.maxHeight) {
            if (config.maxHeight == 'inherit') {
              defaults.maxHeight = el.clientHeight;
            } else {
              var maxHeight = parseInt(config.maxHeight);
              if (!isNaN(maxHeight)) {
                defaults.maxHeight = maxHeight;
              }
            }
          }
          if (config && config.minWidth) {
            if (config.minWidth == 'inherit') {
              defaults.minWidth = el.clientWidth;
            } else {
              var minWidth = parseInt(config.minWidth);
              if (!isNaN(minWidth)) {
                defaults.minWidth = minWidth;
              }
            }
          }
          if (config && config.maxWidth) {
            if (config.maxWidth == 'inherit') {
              defaults.maxWidth = el.clientWidth;
            } else {
              var maxWidth = parseInt(config.maxWidth);
              if (!isNaN(maxWidth)) {
                defaults.maxWidth = maxWidth;
              }
            }
          }
          if (!span.firstChild) {
            span.className = "autoResize";
            span.style.display = 'inline-block';
            span.appendChild(text);
          }
        },
        _init = function _init(el_, config, doObserve) {
          el = el_;
          extendDefaults(config);
          if (el.nodeName == 'TEXTAREA') {
            el.style.resize = 'none';
            el.style.overflowY = '';
            el.style.height = defaults.minHeight + 'px';
            el.style.minWidth = defaults.minWidth + 'px';
            el.style.maxWidth = defaults.maxWidth + 'px';
            el.style.overflowY = 'hidden';
          }
          if (doObserve) {
            observe(el, 'change', resize);
            observe(el, 'cut', delayedResize);
            observe(el, 'paste', delayedResize);
            observe(el, 'drop', delayedResize);
            observe(el, 'keydown', delayedResize);
            observe(el, 'focus', resize);
          }
          resize();
        };

      function getComputedStyle(element) {
        return element.currentStyle || document.defaultView.getComputedStyle(element);
      }
      return {
        init: function init(el_, config, doObserve) {
          _init(el_, config, doObserve);
        },
        unObserve: function unObserve() {
          _unObserve(el, 'change', resize);
          _unObserve(el, 'cut', delayedResize);
          _unObserve(el, 'paste', delayedResize);
          _unObserve(el, 'drop', delayedResize);
          _unObserve(el, 'keydown', delayedResize);
          _unObserve(el, 'focus', resize);
        },
        resize: resize
      };
    }
    if (true) {
      module.exports = autoResize;
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _element = __webpack_require__(0);
    var _base = __webpack_require__(29);
    var _base2 = _interopRequireDefault(_base);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var DebugOverlay = function (_Overlay) {
      _inherits(DebugOverlay, _Overlay);

      function DebugOverlay(wotInstance) {
        _classCallCheck(this, DebugOverlay);
        var _this = _possibleConstructorReturn(this, (DebugOverlay.__proto__ || Object.getPrototypeOf(DebugOverlay)).call(this, wotInstance));
        _this.clone = _this.makeClone(_base2.default.CLONE_DEBUG);
        _this.clone.wtTable.holder.style.opacity = 0.4;
        _this.clone.wtTable.holder.style.textShadow = '0 0 2px #ff0000';
        (0, _element.addClass)(_this.clone.wtTable.holder.parentNode, 'wtDebugVisible');
        return _this;
      }
      return DebugOverlay;
    }(_base2.default);
    _base2.default.registerOverlay(_base2.default.CLONE_DEBUG, DebugOverlay);
    exports.default = DebugOverlay;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _element = __webpack_require__(0);
    var _base = __webpack_require__(29);
    var _base2 = _interopRequireDefault(_base);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var LeftOverlay = function (_Overlay) {
      _inherits(LeftOverlay, _Overlay);

      function LeftOverlay(wotInstance) {
        _classCallCheck(this, LeftOverlay);
        var _this = _possibleConstructorReturn(this, (LeftOverlay.__proto__ || Object.getPrototypeOf(LeftOverlay)).call(this, wotInstance));
        _this.clone = _this.makeClone(_base2.default.CLONE_LEFT);
        return _this;
      }
      _createClass(LeftOverlay, [{
        key: 'shouldBeRendered',
        value: function shouldBeRendered() {
          return !!(this.wot.getSetting('fixedColumnsLeft') || this.wot.getSetting('rowHeaders').length);
        }
      }, {
        key: 'resetFixedPosition',
        value: function resetFixedPosition() {
          if (!this.needFullRender || !this.wot.wtTable.holder.parentNode) {
            return;
          }
          var overlayRoot = this.clone.wtTable.holder.parentNode;
          var headerPosition = 0;
          var preventOverflow = this.wot.getSetting('preventOverflow');
          if (this.trimmingContainer === window && (!preventOverflow || preventOverflow !== 'horizontal')) {
            var box = this.wot.wtTable.hider.getBoundingClientRect();
            var left = Math.ceil(box.left);
            var right = Math.ceil(box.right);
            var finalLeft = void 0;
            var finalTop = void 0;
            finalTop = this.wot.wtTable.hider.style.top;
            finalTop = finalTop === '' ? 0 : finalTop;
            if (left < 0 && right - overlayRoot.offsetWidth > 0) {
              finalLeft = -left;
            } else {
              finalLeft = 0;
            }
            headerPosition = finalLeft;
            finalLeft += 'px';
            (0, _element.setOverlayPosition)(overlayRoot, finalLeft, finalTop);
          } else {
            headerPosition = this.getScrollPosition();
            (0, _element.resetCssTransform)(overlayRoot);
          }
          this.adjustHeaderBordersPosition(headerPosition);
          this.adjustElementsSize();
        }
      }, {
        key: 'setScrollPosition',
        value: function setScrollPosition(pos) {
          if (this.mainTableScrollableElement === window) {
            window.scrollTo(pos, (0, _element.getWindowScrollTop)());
          } else {
            this.mainTableScrollableElement.scrollLeft = pos;
          }
        }
      }, {
        key: 'onScroll',
        value: function onScroll() {
          this.wot.getSetting('onScrollVertically');
        }
      }, {
        key: 'sumCellSizes',
        value: function sumCellSizes(from, to) {
          var sum = 0;
          var defaultColumnWidth = this.wot.wtSettings.defaultColumnWidth;
          while (from < to) {
            sum += this.wot.wtTable.getStretchedColumnWidth(from) || defaultColumnWidth;
            from++;
          }
          return sum;
        }
      }, {
        key: 'adjustElementsSize',
        value: function adjustElementsSize() {
          var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
          this.updateTrimmingContainer();
          if (this.needFullRender || force) {
            this.adjustRootElementSize();
            this.adjustRootChildrenSize();
            if (!force) {
              this.areElementSizesAdjusted = true;
            }
          }
        }
      }, {
        key: 'adjustRootElementSize',
        value: function adjustRootElementSize() {
          var masterHolder = this.wot.wtTable.holder;
          var scrollbarHeight = masterHolder.clientHeight === masterHolder.offsetHeight ? 0 : (0, _element.getScrollbarWidth)();
          var overlayRoot = this.clone.wtTable.holder.parentNode;
          var overlayRootStyle = overlayRoot.style;
          var preventOverflow = this.wot.getSetting('preventOverflow');
          var tableWidth = void 0;
          if (this.trimmingContainer !== window || preventOverflow === 'vertical') {
            var height = this.wot.wtViewport.getWorkspaceHeight() - scrollbarHeight;
            height = Math.min(height, (0, _element.innerHeight)(this.wot.wtTable.wtRootElement));
            overlayRootStyle.height = height + 'px';
          } else {
            overlayRootStyle.height = '';
          }
          this.clone.wtTable.holder.style.height = overlayRootStyle.height;
          tableWidth = (0, _element.outerWidth)(this.clone.wtTable.TABLE);
          overlayRootStyle.width = (tableWidth === 0 ? tableWidth : tableWidth + 4) + 'px';
        }
      }, {
        key: 'adjustRootChildrenSize',
        value: function adjustRootChildrenSize() {
          var scrollbarWidth = (0, _element.getScrollbarWidth)();
          this.clone.wtTable.hider.style.height = this.hider.style.height;
          this.clone.wtTable.holder.style.height = this.clone.wtTable.holder.parentNode.style.height;
          if (scrollbarWidth === 0) {
            scrollbarWidth = 30;
          }
          this.clone.wtTable.holder.style.width = parseInt(this.clone.wtTable.holder.parentNode.style.width, 10) + scrollbarWidth + 'px';
        }
      }, {
        key: 'applyToDOM',
        value: function applyToDOM() {
          var total = this.wot.getSetting('totalColumns');
          if (!this.areElementSizesAdjusted) {
            this.adjustElementsSize();
          }
          if (typeof this.wot.wtViewport.columnsRenderCalculator.startPosition === 'number') {
            this.spreader.style.left = this.wot.wtViewport.columnsRenderCalculator.startPosition + 'px';
          } else if (total === 0) {
            this.spreader.style.left = '0';
          } else {
            throw new Error('Incorrect value of the columnsRenderCalculator');
          }
          this.spreader.style.right = '';
          if (this.needFullRender) {
            this.syncOverlayOffset();
          }
        }
      }, {
        key: 'syncOverlayOffset',
        value: function syncOverlayOffset() {
          if (typeof this.wot.wtViewport.rowsRenderCalculator.startPosition === 'number') {
            this.clone.wtTable.spreader.style.top = this.wot.wtViewport.rowsRenderCalculator.startPosition + 'px';
          } else {
            this.clone.wtTable.spreader.style.top = '';
          }
        }
      }, {
        key: 'scrollTo',
        value: function scrollTo(sourceCol, beyondRendered) {
          var newX = this.getTableParentOffset();
          var sourceInstance = this.wot.cloneSource ? this.wot.cloneSource : this.wot;
          var mainHolder = sourceInstance.wtTable.holder;
          var scrollbarCompensation = 0;
          if (beyondRendered && mainHolder.offsetWidth !== mainHolder.clientWidth) {
            scrollbarCompensation = (0, _element.getScrollbarWidth)();
          }
          if (beyondRendered) {
            newX += this.sumCellSizes(0, sourceCol + 1);
            newX -= this.wot.wtViewport.getViewportWidth();
          } else {
            newX += this.sumCellSizes(this.wot.getSetting('fixedColumnsLeft'), sourceCol);
          }
          newX += scrollbarCompensation;
          this.setScrollPosition(newX);
        }
      }, {
        key: 'getTableParentOffset',
        value: function getTableParentOffset() {
          var preventOverflow = this.wot.getSetting('preventOverflow');
          var offset = 0;
          if (!preventOverflow && this.trimmingContainer === window) {
            offset = this.wot.wtTable.holderOffset.left;
          }
          return offset;
        }
      }, {
        key: 'getScrollPosition',
        value: function getScrollPosition() {
          return (0, _element.getScrollLeft)(this.mainTableScrollableElement);
        }
      }, {
        key: 'adjustHeaderBordersPosition',
        value: function adjustHeaderBordersPosition(position) {
          var masterParent = this.wot.wtTable.holder.parentNode;
          var rowHeaders = this.wot.getSetting('rowHeaders');
          var fixedColumnsLeft = this.wot.getSetting('fixedColumnsLeft');
          var totalRows = this.wot.getSetting('totalRows');
          if (totalRows) {
            (0, _element.removeClass)(masterParent, 'emptyRows');
          } else {
            (0, _element.addClass)(masterParent, 'emptyRows');
          }
          if (fixedColumnsLeft && !rowHeaders.length) {
            (0, _element.addClass)(masterParent, 'innerBorderLeft');
          } else if (!fixedColumnsLeft && rowHeaders.length) {
            var previousState = (0, _element.hasClass)(masterParent, 'innerBorderLeft');
            if (position) {
              (0, _element.addClass)(masterParent, 'innerBorderLeft');
            } else {
              (0, _element.removeClass)(masterParent, 'innerBorderLeft');
            }
            if (!previousState && position || previousState && !position) {
              this.wot.wtOverlays.adjustElementsSize();
            }
          }
        }
      }]);
      return LeftOverlay;
    }(_base2.default);
    _base2.default.registerOverlay(_base2.default.CLONE_LEFT, LeftOverlay);
    exports.default = LeftOverlay;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _element = __webpack_require__(0);
    var _base = __webpack_require__(29);
    var _base2 = _interopRequireDefault(_base);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var TopOverlay = function (_Overlay) {
      _inherits(TopOverlay, _Overlay);

      function TopOverlay(wotInstance) {
        _classCallCheck(this, TopOverlay);
        var _this = _possibleConstructorReturn(this, (TopOverlay.__proto__ || Object.getPrototypeOf(TopOverlay)).call(this, wotInstance));
        _this.clone = _this.makeClone(_base2.default.CLONE_TOP);
        return _this;
      }
      _createClass(TopOverlay, [{
        key: 'shouldBeRendered',
        value: function shouldBeRendered() {
          return !!(this.wot.getSetting('fixedRowsTop') || this.wot.getSetting('columnHeaders').length);
        }
      }, {
        key: 'resetFixedPosition',
        value: function resetFixedPosition() {
          if (!this.needFullRender || !this.wot.wtTable.holder.parentNode) {
            return;
          }
          var overlayRoot = this.clone.wtTable.holder.parentNode;
          var headerPosition = 0;
          var preventOverflow = this.wot.getSetting('preventOverflow');
          if (this.trimmingContainer === window && (!preventOverflow || preventOverflow !== 'vertical')) {
            var box = this.wot.wtTable.hider.getBoundingClientRect();
            var top = Math.ceil(box.top);
            var bottom = Math.ceil(box.bottom);
            var finalLeft = void 0;
            var finalTop = void 0;
            finalLeft = this.wot.wtTable.hider.style.left;
            finalLeft = finalLeft === '' ? 0 : finalLeft;
            if (top < 0 && bottom - overlayRoot.offsetHeight > 0) {
              finalTop = -top;
            } else {
              finalTop = 0;
            }
            headerPosition = finalTop;
            finalTop += 'px';
            (0, _element.setOverlayPosition)(overlayRoot, finalLeft, finalTop);
          } else {
            headerPosition = this.getScrollPosition();
            (0, _element.resetCssTransform)(overlayRoot);
          }
          this.adjustHeaderBordersPosition(headerPosition);
          this.adjustElementsSize();
        }
      }, {
        key: 'setScrollPosition',
        value: function setScrollPosition(pos) {
          if (this.mainTableScrollableElement === window) {
            window.scrollTo((0, _element.getWindowScrollLeft)(), pos);
          } else {
            this.mainTableScrollableElement.scrollTop = pos;
          }
        }
      }, {
        key: 'onScroll',
        value: function onScroll() {
          this.wot.getSetting('onScrollHorizontally');
        }
      }, {
        key: 'sumCellSizes',
        value: function sumCellSizes(from, to) {
          var sum = 0;
          var defaultRowHeight = this.wot.wtSettings.settings.defaultRowHeight;
          while (from < to) {
            var height = this.wot.wtTable.getRowHeight(from);
            sum += height === void 0 ? defaultRowHeight : height;
            from++;
          }
          return sum;
        }
      }, {
        key: 'adjustElementsSize',
        value: function adjustElementsSize() {
          var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
          this.updateTrimmingContainer();
          if (this.needFullRender || force) {
            this.adjustRootElementSize();
            this.adjustRootChildrenSize();
            if (!force) {
              this.areElementSizesAdjusted = true;
            }
          }
        }
      }, {
        key: 'adjustRootElementSize',
        value: function adjustRootElementSize() {
          var masterHolder = this.wot.wtTable.holder;
          var scrollbarWidth = masterHolder.clientWidth === masterHolder.offsetWidth ? 0 : (0, _element.getScrollbarWidth)();
          var overlayRoot = this.clone.wtTable.holder.parentNode;
          var overlayRootStyle = overlayRoot.style;
          var preventOverflow = this.wot.getSetting('preventOverflow');
          var tableHeight = void 0;
          if (this.trimmingContainer !== window || preventOverflow === 'horizontal') {
            var width = this.wot.wtViewport.getWorkspaceWidth() - scrollbarWidth;
            width = Math.min(width, (0, _element.innerWidth)(this.wot.wtTable.wtRootElement));
            overlayRootStyle.width = width + 'px';
          } else {
            overlayRootStyle.width = '';
          }
          this.clone.wtTable.holder.style.width = overlayRootStyle.width;
          tableHeight = (0, _element.outerHeight)(this.clone.wtTable.TABLE);
          overlayRootStyle.height = (tableHeight === 0 ? tableHeight : tableHeight + 4) + 'px';
        }
      }, {
        key: 'adjustRootChildrenSize',
        value: function adjustRootChildrenSize() {
          var scrollbarWidth = (0, _element.getScrollbarWidth)();
          this.clone.wtTable.hider.style.width = this.hider.style.width;
          this.clone.wtTable.holder.style.width = this.clone.wtTable.holder.parentNode.style.width;
          if (scrollbarWidth === 0) {
            scrollbarWidth = 30;
          }
          this.clone.wtTable.holder.style.height = parseInt(this.clone.wtTable.holder.parentNode.style.height, 10) + scrollbarWidth + 'px';
        }
      }, {
        key: 'applyToDOM',
        value: function applyToDOM() {
          var total = this.wot.getSetting('totalRows');
          if (!this.areElementSizesAdjusted) {
            this.adjustElementsSize();
          }
          if (typeof this.wot.wtViewport.rowsRenderCalculator.startPosition === 'number') {
            this.spreader.style.top = this.wot.wtViewport.rowsRenderCalculator.startPosition + 'px';
          } else if (total === 0) {
            this.spreader.style.top = '0';
          } else {
            throw new Error('Incorrect value of the rowsRenderCalculator');
          }
          this.spreader.style.bottom = '';
          if (this.needFullRender) {
            this.syncOverlayOffset();
          }
        }
      }, {
        key: 'syncOverlayOffset',
        value: function syncOverlayOffset() {
          if (typeof this.wot.wtViewport.columnsRenderCalculator.startPosition === 'number') {
            this.clone.wtTable.spreader.style.left = this.wot.wtViewport.columnsRenderCalculator.startPosition + 'px';
          } else {
            this.clone.wtTable.spreader.style.left = '';
          }
        }
      }, {
        key: 'scrollTo',
        value: function scrollTo(sourceRow, bottomEdge) {
          var newY = this.getTableParentOffset();
          var sourceInstance = this.wot.cloneSource ? this.wot.cloneSource : this.wot;
          var mainHolder = sourceInstance.wtTable.holder;
          var scrollbarCompensation = 0;
          if (bottomEdge && mainHolder.offsetHeight !== mainHolder.clientHeight) {
            scrollbarCompensation = (0, _element.getScrollbarWidth)();
          }
          if (bottomEdge) {
            var fixedRowsBottom = this.wot.getSetting('fixedRowsBottom');
            var fixedRowsTop = this.wot.getSetting('fixedRowsTop');
            var totalRows = this.wot.getSetting('totalRows');
            newY += this.sumCellSizes(0, sourceRow + 1);
            newY -= this.wot.wtViewport.getViewportHeight() - this.sumCellSizes(totalRows - fixedRowsBottom, totalRows);
            newY += 1;
          } else {
            newY += this.sumCellSizes(this.wot.getSetting('fixedRowsTop'), sourceRow);
          }
          newY += scrollbarCompensation;
          this.setScrollPosition(newY);
        }
      }, {
        key: 'getTableParentOffset',
        value: function getTableParentOffset() {
          if (this.mainTableScrollableElement === window) {
            return this.wot.wtTable.holderOffset.top;
          }
          return 0;
        }
      }, {
        key: 'getScrollPosition',
        value: function getScrollPosition() {
          return (0, _element.getScrollTop)(this.mainTableScrollableElement);
        }
      }, {
        key: 'redrawSelectionBorders',
        value: function redrawSelectionBorders(selection) {
          if (selection && selection.cellRange) {
            var border = selection.getBorder(this.wot);
            if (border) {
              var corners = selection.getCorners();
              border.disappear();
              border.appear(corners);
            }
          }
        }
      }, {
        key: 'redrawAllSelectionsBorders',
        value: function redrawAllSelectionsBorders() {
          var selections = this.wot.selections;
          this.redrawSelectionBorders(selections.current);
          this.redrawSelectionBorders(selections.area);
          this.redrawSelectionBorders(selections.fill);
          this.wot.wtTable.wot.wtOverlays.leftOverlay.refresh();
        }
      }, {
        key: 'adjustHeaderBordersPosition',
        value: function adjustHeaderBordersPosition(position) {
          var masterParent = this.wot.wtTable.holder.parentNode;
          var totalColumns = this.wot.getSetting('totalColumns');
          if (totalColumns) {
            (0, _element.removeClass)(masterParent, 'emptyColumns');
          } else {
            (0, _element.addClass)(masterParent, 'emptyColumns');
          }
          if (this.wot.getSetting('fixedRowsTop') === 0 && this.wot.getSetting('columnHeaders').length > 0) {
            var previousState = (0, _element.hasClass)(masterParent, 'innerBorderTop');
            if (position || this.wot.getSetting('totalRows') === 0) {
              (0, _element.addClass)(masterParent, 'innerBorderTop');
            } else {
              (0, _element.removeClass)(masterParent, 'innerBorderTop');
            }
            if (!previousState && position || previousState && !position) {
              this.wot.wtOverlays.adjustElementsSize();
              this.redrawAllSelectionsBorders();
            }
          }
          if (this.wot.getSetting('rowHeaders').length === 0) {
            var secondHeaderCell = this.clone.wtTable.THEAD.querySelectorAll('th:nth-of-type(2)');
            if (secondHeaderCell) {
              for (var i = 0; i < secondHeaderCell.length; i++) {
                secondHeaderCell[i].style['border-left-width'] = 0;
              }
            }
          }
        }
      }]);
      return TopOverlay;
    }(_base2.default);
    _base2.default.registerOverlay(_base2.default.CLONE_TOP, TopOverlay);
    exports.default = TopOverlay;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _element = __webpack_require__(0);
    var _base = __webpack_require__(29);
    var _base2 = _interopRequireDefault(_base);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var TopLeftCornerOverlay = function (_Overlay) {
      _inherits(TopLeftCornerOverlay, _Overlay);

      function TopLeftCornerOverlay(wotInstance) {
        _classCallCheck(this, TopLeftCornerOverlay);
        var _this = _possibleConstructorReturn(this, (TopLeftCornerOverlay.__proto__ || Object.getPrototypeOf(TopLeftCornerOverlay)).call(this, wotInstance));
        _this.clone = _this.makeClone(_base2.default.CLONE_TOP_LEFT_CORNER);
        return _this;
      }
      _createClass(TopLeftCornerOverlay, [{
        key: 'shouldBeRendered',
        value: function shouldBeRendered() {
          return !!((this.wot.getSetting('fixedRowsTop') || this.wot.getSetting('columnHeaders').length) && (this.wot.getSetting('fixedColumnsLeft') || this.wot.getSetting('rowHeaders').length));
        }
      }, {
        key: 'resetFixedPosition',
        value: function resetFixedPosition() {
          this.updateTrimmingContainer();
          if (!this.wot.wtTable.holder.parentNode) {
            return;
          }
          var overlayRoot = this.clone.wtTable.holder.parentNode;
          var tableHeight = (0, _element.outerHeight)(this.clone.wtTable.TABLE);
          var tableWidth = (0, _element.outerWidth)(this.clone.wtTable.TABLE);
          var preventOverflow = this.wot.getSetting('preventOverflow');
          if (this.trimmingContainer === window) {
            var box = this.wot.wtTable.hider.getBoundingClientRect();
            var top = Math.ceil(box.top);
            var left = Math.ceil(box.left);
            var bottom = Math.ceil(box.bottom);
            var right = Math.ceil(box.right);
            var finalLeft = '0';
            var finalTop = '0';
            if (!preventOverflow || preventOverflow === 'vertical') {
              if (left < 0 && right - overlayRoot.offsetWidth > 0) {
                finalLeft = -left + 'px';
              }
            }
            if (!preventOverflow || preventOverflow === 'horizontal') {
              if (top < 0 && bottom - overlayRoot.offsetHeight > 0) {
                finalTop = -top + 'px';
              }
            } (0, _element.setOverlayPosition)(overlayRoot, finalLeft, finalTop);
          } else {
            (0, _element.resetCssTransform)(overlayRoot);
          }
          overlayRoot.style.height = (tableHeight === 0 ? tableHeight : tableHeight + 4) + 'px';
          overlayRoot.style.width = (tableWidth === 0 ? tableWidth : tableWidth + 4) + 'px';
        }
      }]);
      return TopLeftCornerOverlay;
    }(_base2.default);
    _base2.default.registerOverlay(_base2.default.CLONE_TOP_LEFT_CORNER, TopLeftCornerOverlay);
    exports.default = TopLeftCornerOverlay;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
      return typeof obj;
    } : function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _element = __webpack_require__(0);
    var _border2 = __webpack_require__(250);
    var _border3 = _interopRequireDefault(_border2);
    var _coords = __webpack_require__(43);
    var _coords2 = _interopRequireDefault(_coords);
    var _range = __webpack_require__(71);
    var _range2 = _interopRequireDefault(_range);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var Selection = function () {
      function Selection(settings, cellRange) {
        _classCallCheck(this, Selection);
        this.settings = settings;
        this.cellRange = cellRange || null;
        this.instanceBorders = {};
      }
      _createClass(Selection, [{
        key: 'getBorder',
        value: function getBorder(wotInstance) {
          if (this.instanceBorders[wotInstance.guid]) {
            return this.instanceBorders[wotInstance.guid];
          }
          this.instanceBorders[wotInstance.guid] = new _border3.default(wotInstance, this.settings);
        }
      }, {
        key: 'isEmpty',
        value: function isEmpty() {
          return this.cellRange === null;
        }
      }, {
        key: 'add',
        value: function add(coords) {
          if (this.isEmpty()) {
            this.cellRange = new _range2.default(coords, coords, coords);
          } else {
            this.cellRange.expand(coords);
          }
        }
      }, {
        key: 'replace',
        value: function replace(oldCoords, newCoords) {
          if (!this.isEmpty()) {
            if (this.cellRange.from.isEqual(oldCoords)) {
              this.cellRange.from = newCoords;
              return true;
            }
            if (this.cellRange.to.isEqual(oldCoords)) {
              this.cellRange.to = newCoords;
              return true;
            }
          }
          return false;
        }
      }, {
        key: 'clear',
        value: function clear() {
          this.cellRange = null;
        }
      }, {
        key: 'getCorners',
        value: function getCorners() {
          var topLeft = this.cellRange.getTopLeftCorner();
          var bottomRight = this.cellRange.getBottomRightCorner();
          return [topLeft.row, topLeft.col, bottomRight.row, bottomRight.col];
        }
      }, {
        key: 'addClassAtCoords',
        value: function addClassAtCoords(wotInstance, sourceRow, sourceColumn, className) {
          var TD = wotInstance.wtTable.getCell(new _coords2.default(sourceRow, sourceColumn));
          if ((typeof TD === 'undefined' ? 'undefined' : _typeof(TD)) === 'object') {
            (0, _element.addClass)(TD, className);
          }
        }
      }, {
        key: 'draw',
        value: function draw(wotInstance) {
          if (this.isEmpty()) {
            if (this.settings.border) {
              var border = this.getBorder(wotInstance);
              if (border) {
                border.disappear();
              }
            }
            return;
          }
          var renderedRows = wotInstance.wtTable.getRenderedRowsCount();
          var renderedColumns = wotInstance.wtTable.getRenderedColumnsCount();
          var corners = this.getCorners();
          var sourceRow = void 0,
            sourceCol = void 0,
            TH = void 0;
          for (var column = 0; column < renderedColumns; column++) {
            sourceCol = wotInstance.wtTable.columnFilter.renderedToSource(column);
            if (sourceCol >= corners[1] && sourceCol <= corners[3]) {
              TH = wotInstance.wtTable.getColumnHeader(sourceCol);
              if (TH) {
                var newClasses = [];
                if (this.settings.highlightHeaderClassName) {
                  newClasses.push(this.settings.highlightHeaderClassName);
                }
                if (this.settings.highlightColumnClassName) {
                  newClasses.push(this.settings.highlightColumnClassName);
                } (0, _element.addClass)(TH, newClasses);
              }
            }
          }
          for (var row = 0; row < renderedRows; row++) {
            sourceRow = wotInstance.wtTable.rowFilter.renderedToSource(row);
            if (sourceRow >= corners[0] && sourceRow <= corners[2]) {
              TH = wotInstance.wtTable.getRowHeader(sourceRow);
              if (TH) {
                var _newClasses = [];
                if (this.settings.highlightHeaderClassName) {
                  _newClasses.push(this.settings.highlightHeaderClassName);
                }
                if (this.settings.highlightRowClassName) {
                  _newClasses.push(this.settings.highlightRowClassName);
                } (0, _element.addClass)(TH, _newClasses);
              }
            }
            for (var _column = 0; _column < renderedColumns; _column++) {
              sourceCol = wotInstance.wtTable.columnFilter.renderedToSource(_column);
              if (sourceRow >= corners[0] && sourceRow <= corners[2] && sourceCol >= corners[1] && sourceCol <= corners[3]) {
                if (this.settings.className) {
                  this.addClassAtCoords(wotInstance, sourceRow, sourceCol, this.settings.className);
                }
              } else if (sourceRow >= corners[0] && sourceRow <= corners[2]) {
                if (this.settings.highlightRowClassName) {
                  this.addClassAtCoords(wotInstance, sourceRow, sourceCol, this.settings.highlightRowClassName);
                }
              } else if (sourceCol >= corners[1] && sourceCol <= corners[3]) {
                if (this.settings.highlightColumnClassName) {
                  this.addClassAtCoords(wotInstance, sourceRow, sourceCol, this.settings.highlightColumnClassName);
                }
              }
            }
          }
          wotInstance.getSetting('onBeforeDrawBorders', corners, this.settings.className);
          if (this.settings.border) {
            var _border = this.getBorder(wotInstance);
            if (_border) {
              _border.appear(corners);
            }
          }
        }
      }]);
      return Selection;
    }();
    exports.default = Selection;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _editors = __webpack_require__(13);
    var _renderers = __webpack_require__(6);
    var _validators = __webpack_require__(24);
    var CELL_TYPE = 'autocomplete';
    exports.default = {
      editor: (0, _editors.getEditor)(CELL_TYPE),
      renderer: (0, _renderers.getRenderer)(CELL_TYPE),
      validator: (0, _validators.getValidator)(CELL_TYPE)
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _editors = __webpack_require__(13);
    var _renderers = __webpack_require__(6);
    var CELL_TYPE = 'checkbox';
    exports.default = {
      editor: (0, _editors.getEditor)(CELL_TYPE),
      renderer: (0, _renderers.getRenderer)(CELL_TYPE)
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _editors = __webpack_require__(13);
    var _renderers = __webpack_require__(6);
    var _validators = __webpack_require__(24);
    var CELL_TYPE = 'date';
    exports.default = {
      editor: (0, _editors.getEditor)(CELL_TYPE),
      renderer: (0, _renderers.getRenderer)('autocomplete'),
      validator: (0, _validators.getValidator)(CELL_TYPE)
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _editors = __webpack_require__(13);
    var _renderers = __webpack_require__(6);
    var _validators = __webpack_require__(24);
    var CELL_TYPE = 'dropdown';
    exports.default = {
      editor: (0, _editors.getEditor)(CELL_TYPE),
      renderer: (0, _renderers.getRenderer)('autocomplete'),
      validator: (0, _validators.getValidator)('autocomplete')
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _editors = __webpack_require__(13);
    var _renderers = __webpack_require__(6);
    var CELL_TYPE = 'handsontable';
    exports.default = {
      editor: (0, _editors.getEditor)(CELL_TYPE),
      renderer: (0, _renderers.getRenderer)('autocomplete')
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _editors = __webpack_require__(13);
    var _renderers = __webpack_require__(6);
    var _validators = __webpack_require__(24);
    var CELL_TYPE = 'numeric';
    exports.default = {
      editor: (0, _editors.getEditor)(CELL_TYPE),
      renderer: (0, _renderers.getRenderer)(CELL_TYPE),
      validator: (0, _validators.getValidator)(CELL_TYPE),
      dataType: 'number'
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _editors = __webpack_require__(13);
    var _renderers = __webpack_require__(6);
    var _validators = __webpack_require__(24);
    var CELL_TYPE = 'password';
    exports.default = {
      editor: (0, _editors.getEditor)(CELL_TYPE),
      renderer: (0, _renderers.getRenderer)(CELL_TYPE),
      copyable: false
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _browser = __webpack_require__(22);
    var _editors = __webpack_require__(13);
    var _renderers = __webpack_require__(6);
    var CELL_TYPE = 'text';
    exports.default = {
      editor: (0, _browser.isMobileBrowser)() ? (0, _editors.getEditor)('mobile') : (0, _editors.getEditor)(CELL_TYPE),
      renderer: (0, _renderers.getRenderer)(CELL_TYPE)
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _editors = __webpack_require__(13);
    var _renderers = __webpack_require__(6);
    var _validators = __webpack_require__(24);
    var CELL_TYPE = 'time';
    exports.default = {
      editor: (0, _editors.getEditor)('text'),
      renderer: (0, _renderers.getRenderer)('text'),
      validator: (0, _validators.getValidator)(CELL_TYPE)
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
      return typeof obj;
    } : function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
    var _SheetClip = __webpack_require__(249);
    var _SheetClip2 = _interopRequireDefault(_SheetClip);
    var _data = __webpack_require__(67);
    var _setting = __webpack_require__(68);
    var _object = __webpack_require__(3);
    var _array = __webpack_require__(2);
    var _interval = __webpack_require__(384);
    var _interval2 = _interopRequireDefault(_interval);
    var _number = __webpack_require__(5);
    var _multiMap = __webpack_require__(334);
    var _multiMap2 = _interopRequireDefault(_multiMap);
    var _pluginHooks = __webpack_require__(11);
    var _pluginHooks2 = _interopRequireDefault(_pluginHooks);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function DataMap(instance, priv, GridSettings) {
      var _this = this;
      this.instance = instance;
      this.priv = priv;
      this.GridSettings = GridSettings;
      this.dataSource = this.instance.getSettings().data;
      this.cachedLength = null;
      this.skipCache = false;
      this.latestSourceRowsCount = 0;
      if (this.dataSource && this.dataSource[0]) {
        this.duckSchema = this.recursiveDuckSchema(this.dataSource[0]);
      } else {
        this.duckSchema = {};
      }
      this.createMap();
      this.interval = _interval2.default.create(function () {
        return _this.clearLengthCache();
      }, '15fps');
      this.instance.addHook('skipLengthCache', function (delay) {
        return _this.onSkipLengthCache(delay);
      });
      this.onSkipLengthCache(500);
    }
    DataMap.prototype.DESTINATION_RENDERER = 1;
    DataMap.prototype.DESTINATION_CLIPBOARD_GENERATOR = 2;
    DataMap.prototype.recursiveDuckSchema = function (object) {
      return (0, _object.duckSchema)(object);
    };
    DataMap.prototype.recursiveDuckColumns = function (schema, lastCol, parent) {
      var prop, i;
      if (typeof lastCol === 'undefined') {
        lastCol = 0;
        parent = '';
      }
      if ((typeof schema === 'undefined' ? 'undefined' : _typeof(schema)) === 'object' && !Array.isArray(schema)) {
        for (i in schema) {
          if ((0, _object.hasOwnProperty)(schema, i)) {
            if (schema[i] === null) {
              prop = parent + i;
              this.colToPropCache.push(prop);
              this.propToColCache.set(prop, lastCol);
              lastCol++;
            } else {
              lastCol = this.recursiveDuckColumns(schema[i], lastCol, i + '.');
            }
          }
        }
      }
      return lastCol;
    };
    DataMap.prototype.createMap = function () {
      var i = void 0;
      var schema = this.getSchema();
      if (typeof schema === 'undefined') {
        throw new Error('trying to create `columns` definition but you didn\'t provide `schema` nor `data`');
      }
      this.colToPropCache = [];
      this.propToColCache = new _multiMap2.default();
      var columns = this.instance.getSettings().columns;
      if (columns) {
        var maxCols = this.instance.getSettings().maxCols;
        var columnsLen = Math.min(maxCols, columns.length);
        var filteredIndex = 0;
        var columnsAsFunc = false;
        var schemaLen = (0, _object.deepObjectSize)(schema);
        if (typeof columns === 'function') {
          columnsLen = schemaLen > 0 ? schemaLen : this.instance.countSourceCols();
          columnsAsFunc = true;
        }
        for (i = 0; i < columnsLen; i++) {
          var column = columnsAsFunc ? columns(i) : columns[i];
          if ((0, _object.isObject)(column)) {
            if (typeof column.data !== 'undefined') {
              var index = columnsAsFunc ? filteredIndex : i;
              this.colToPropCache[index] = column.data;
              this.propToColCache.set(column.data, index);
            }
            filteredIndex++;
          }
        }
      } else {
        this.recursiveDuckColumns(schema);
      }
    };
    DataMap.prototype.colToProp = function (col) {
      col = this.instance.runHooks('modifyCol', col);
      if (!isNaN(col) && this.colToPropCache && typeof this.colToPropCache[col] !== 'undefined') {
        return this.colToPropCache[col];
      }
      return col;
    };
    DataMap.prototype.propToCol = function (prop) {
      var col;
      if (typeof this.propToColCache.get(prop) === 'undefined') {
        col = prop;
      } else {
        col = this.propToColCache.get(prop);
      }
      col = this.instance.runHooks('unmodifyCol', col);
      return col;
    };
    DataMap.prototype.getSchema = function () {
      var schema = this.instance.getSettings().dataSchema;
      if (schema) {
        if (typeof schema === 'function') {
          return schema();
        }
        return schema;
      }
      return this.duckSchema;
    };
    DataMap.prototype.createRow = function (index, amount, source) {
      var row, colCount = this.instance.countCols(),
        numberOfCreatedRows = 0,
        currentIndex;
      if (!amount) {
        amount = 1;
      }
      if (typeof index !== 'number' || index >= this.instance.countSourceRows()) {
        index = this.instance.countSourceRows();
      }
      this.instance.runHooks('beforeCreateRow', index, amount, source);
      currentIndex = index;
      var maxRows = this.instance.getSettings().maxRows;
      while (numberOfCreatedRows < amount && this.instance.countSourceRows() < maxRows) {
        if (this.instance.dataType === 'array') {
          if (this.instance.getSettings().dataSchema) {
            row = (0, _object.deepClone)(this.getSchema());
          } else {
            row = [];
            (0, _number.rangeEach)(colCount - 1, function () {
              return row.push(null);
            });
          }
        } else if (this.instance.dataType === 'function') {
          row = this.instance.getSettings().dataSchema(index);
        } else {
          row = {};
          (0, _object.deepExtend)(row, this.getSchema());
        }
        if (index === this.instance.countSourceRows()) {
          this.dataSource.push(row);
        } else {
          this.spliceData(index, 0, row);
        }
        numberOfCreatedRows++;
        currentIndex++;
      }
      this.instance.runHooks('afterCreateRow', index, numberOfCreatedRows, source);
      this.instance.forceFullRender = true;
      return numberOfCreatedRows;
    };
    DataMap.prototype.createCol = function (index, amount, source) {
      if (!this.instance.isColumnModificationAllowed()) {
        throw new Error('Cannot create new column. When data source in an object, ' + 'you can only have as much columns as defined in first data row, data schema or in the \'columns\' setting.' + 'If you want to be able to add new columns, you have to use array datasource.');
      }
      var rlen = this.instance.countSourceRows(),
        data = this.dataSource,
        constructor, numberOfCreatedCols = 0,
        currentIndex;
      if (!amount) {
        amount = 1;
      }
      if (typeof index !== 'number' || index >= this.instance.countCols()) {
        index = this.instance.countCols();
      }
      this.instance.runHooks('beforeCreateCol', index, amount, source);
      currentIndex = index;
      var maxCols = this.instance.getSettings().maxCols;
      while (numberOfCreatedCols < amount && this.instance.countCols() < maxCols) {
        constructor = (0, _setting.columnFactory)(this.GridSettings, this.priv.columnsSettingConflicts);
        if (typeof index !== 'number' || index >= this.instance.countCols()) {
          if (rlen > 0) {
            for (var r = 0; r < rlen; r++) {
              if (typeof data[r] === 'undefined') {
                data[r] = [];
              }
              data[r].push(null);
            }
          } else {
            data.push([null]);
          }
          this.priv.columnSettings.push(constructor);
        } else {
          for (var _r = 0; _r < rlen; _r++) {
            data[_r].splice(currentIndex, 0, null);
          }
          this.priv.columnSettings.splice(currentIndex, 0, constructor);
        }
        numberOfCreatedCols++;
        currentIndex++;
      }
      this.instance.runHooks('afterCreateCol', index, numberOfCreatedCols, source);
      this.instance.forceFullRender = true;
      return numberOfCreatedCols;
    };
    DataMap.prototype.removeRow = function (index, amount, source) {
      if (!amount) {
        amount = 1;
      }
      if (typeof index !== 'number') {
        index = -amount;
      }
      amount = this.instance.runHooks('modifyRemovedAmount', amount, index);
      index = (this.instance.countSourceRows() + index) % this.instance.countSourceRows();
      var logicRows = this.visualRowsToPhysical(index, amount);
      var actionWasNotCancelled = this.instance.runHooks('beforeRemoveRow', index, amount, logicRows, source);
      if (actionWasNotCancelled === false) {
        return;
      }
      var data = this.dataSource;
      var newData = void 0;
      newData = this.filterData(index, amount);
      if (newData) {
        data.length = 0;
        Array.prototype.push.apply(data, newData);
      }
      this.instance.runHooks('afterRemoveRow', index, amount, logicRows, source);
      this.instance.forceFullRender = true;
    };
    DataMap.prototype.removeCol = function (index, amount, source) {
      if (this.instance.dataType === 'object' || this.instance.getSettings().columns) {
        throw new Error('cannot remove column with object data source or columns option specified');
      }
      if (!amount) {
        amount = 1;
      }
      if (typeof index !== 'number') {
        index = -amount;
      }
      index = (this.instance.countCols() + index) % this.instance.countCols();
      var logicColumns = this.visualColumnsToPhysical(index, amount);
      var descendingLogicColumns = logicColumns.slice(0).sort(function (a, b) {
        return b - a;
      });
      var actionWasNotCancelled = this.instance.runHooks('beforeRemoveCol', index, amount, logicColumns, source);
      if (actionWasNotCancelled === false) {
        return;
      }
      var isTableUniform = true;
      var removedColumnsCount = descendingLogicColumns.length;
      var data = this.dataSource;
      for (var c = 0; c < removedColumnsCount; c++) {
        if (isTableUniform && logicColumns[0] !== logicColumns[c] - c) {
          isTableUniform = false;
        }
      }
      if (isTableUniform) {
        for (var r = 0, rlen = this.instance.countSourceRows(); r < rlen; r++) {
          data[r].splice(logicColumns[0], amount);
        }
      } else {
        for (var _r2 = 0, _rlen = this.instance.countSourceRows(); _r2 < _rlen; _r2++) {
          for (var _c = 0; _c < removedColumnsCount; _c++) {
            data[_r2].splice(descendingLogicColumns[_c], 1);
          }
        }
        for (var _c2 = 0; _c2 < removedColumnsCount; _c2++) {
          this.priv.columnSettings.splice(logicColumns[_c2], 1);
        }
      }
      this.instance.runHooks('afterRemoveCol', index, amount, logicColumns, source);
      this.instance.forceFullRender = true;
    };
    DataMap.prototype.spliceCol = function (col, index, amount) {
      var elements = arguments.length >= 4 ? [].slice.call(arguments, 3) : [];
      var colData = this.instance.getDataAtCol(col);
      var removed = colData.slice(index, index + amount);
      var after = colData.slice(index + amount);
      (0, _array.extendArray)(elements, after);
      var i = 0;
      while (i < amount) {
        elements.push(null);
        i++;
      } (0, _array.to2dArray)(elements);
      this.instance.populateFromArray(index, col, elements, null, null, 'spliceCol');
      return removed;
    };
    DataMap.prototype.spliceRow = function (row, index, amount) {
      var elements = arguments.length >= 4 ? [].slice.call(arguments, 3) : [];
      var rowData = this.instance.getSourceDataAtRow(row);
      var removed = rowData.slice(index, index + amount);
      var after = rowData.slice(index + amount);
      (0, _array.extendArray)(elements, after);
      var i = 0;
      while (i < amount) {
        elements.push(null);
        i++;
      }
      this.instance.populateFromArray(row, index, [elements], null, null, 'spliceRow');
      return removed;
    };
    DataMap.prototype.spliceData = function (index, amount, element) {
      var continueSplicing = this.instance.runHooks('beforeDataSplice', index, amount, element);
      if (continueSplicing !== false) {
        this.dataSource.splice(index, amount, element);
      }
    };
    DataMap.prototype.filterData = function (index, amount) {
      var physicalRows = this.visualRowsToPhysical(index, amount);
      var continueSplicing = this.instance.runHooks('beforeDataFilter', index, amount, physicalRows);
      if (continueSplicing !== false) {
        var newData = this.dataSource.filter(function (row, index) {
          return physicalRows.indexOf(index) == -1;
        });
        return newData;
      }
    };
    DataMap.prototype.get = function (row, prop) {
      row = this.instance.runHooks('modifyRow', row);
      var dataRow = this.dataSource[row];
      var modifiedRowData = this.instance.runHooks('modifyRowData', row);
      dataRow = isNaN(modifiedRowData) ? modifiedRowData : dataRow;
      var value = null;
      if (dataRow && dataRow.hasOwnProperty && (0, _object.hasOwnProperty)(dataRow, prop)) {
        value = dataRow[prop];
      } else if (typeof prop === 'string' && prop.indexOf('.') > -1) {
        var sliced = prop.split('.');
        var out = dataRow;
        if (!out) {
          return null;
        }
        for (var i = 0, ilen = sliced.length; i < ilen; i++) {
          out = out[sliced[i]];
          if (typeof out === 'undefined') {
            return null;
          }
        }
        value = out;
      } else if (typeof prop === 'function') {
        value = prop(this.dataSource.slice(row, row + 1)[0]);
      }
      if (this.instance.hasHook('modifyData')) {
        var valueHolder = (0, _object.createObjectPropListener)(value);
        this.instance.runHooks('modifyData', row, this.propToCol(prop), valueHolder, 'get');
        if (valueHolder.isTouched()) {
          value = valueHolder.value;
        }
      }
      return value;
    };
    var copyableLookup = (0, _data.cellMethodLookupFactory)('copyable', false);
    DataMap.prototype.getCopyable = function (row, prop) {
      if (copyableLookup.call(this.instance, row, this.propToCol(prop))) {
        return this.get(row, prop);
      }
      return '';
    };
    DataMap.prototype.set = function (row, prop, value, source) {
      row = this.instance.runHooks('modifyRow', row, source || 'datamapGet');
      var dataRow = this.dataSource[row];
      var modifiedRowData = this.instance.runHooks('modifyRowData', row);
      dataRow = isNaN(modifiedRowData) ? modifiedRowData : dataRow;
      if (this.instance.hasHook('modifyData')) {
        var valueHolder = (0, _object.createObjectPropListener)(value);
        this.instance.runHooks('modifyData', row, this.propToCol(prop), valueHolder, 'set');
        if (valueHolder.isTouched()) {
          value = valueHolder.value;
        }
      }
      if (dataRow && dataRow.hasOwnProperty && (0, _object.hasOwnProperty)(dataRow, prop)) {
        dataRow[prop] = value;
      } else if (typeof prop === 'string' && prop.indexOf('.') > -1) {
        var sliced = prop.split('.');
        var out = dataRow;
        var i = 0;
        var ilen = void 0;
        for (i = 0, ilen = sliced.length - 1; i < ilen; i++) {
          if (typeof out[sliced[i]] === 'undefined') {
            out[sliced[i]] = {};
          }
          out = out[sliced[i]];
        }
        out[sliced[i]] = value;
      } else if (typeof prop === 'function') {
        prop(this.dataSource.slice(row, row + 1)[0], value);
      } else {
        dataRow[prop] = value;
      }
    };
    DataMap.prototype.visualRowsToPhysical = function (index, amount) {
      var totalRows = this.instance.countSourceRows();
      var physicRow = (totalRows + index) % totalRows;
      var logicRows = [];
      var rowsToRemove = amount;
      var row;
      while (physicRow < totalRows && rowsToRemove) {
        row = this.instance.runHooks('modifyRow', physicRow);
        logicRows.push(row);
        rowsToRemove--;
        physicRow++;
      }
      return logicRows;
    };
    DataMap.prototype.visualColumnsToPhysical = function (index, amount) {
      var totalCols = this.instance.countCols();
      var physicalCol = (totalCols + index) % totalCols;
      var visualCols = [];
      var colsToRemove = amount;
      while (physicalCol < totalCols && colsToRemove) {
        var col = this.instance.runHooks('modifyCol', physicalCol);
        visualCols.push(col);
        colsToRemove--;
        physicalCol++;
      }
      return visualCols;
    };
    DataMap.prototype.clear = function () {
      for (var r = 0; r < this.instance.countSourceRows(); r++) {
        for (var c = 0; c < this.instance.countCols(); c++) {
          this.set(r, this.colToProp(c), '');
        }
      }
    };
    DataMap.prototype.clearLengthCache = function () {
      this.cachedLength = null;
    };
    DataMap.prototype.getLength = function () {
      var _this2 = this;
      var maxRows = void 0,
        maxRowsFromSettings = this.instance.getSettings().maxRows;
      if (maxRowsFromSettings < 0 || maxRowsFromSettings === 0) {
        maxRows = 0;
      } else {
        maxRows = maxRowsFromSettings || Infinity;
      }
      var length = this.instance.countSourceRows();
      if (this.instance.hasHook('modifyRow')) {
        var reValidate = this.skipCache;
        this.interval.start();
        if (length !== this.latestSourceRowsCount) {
          reValidate = true;
        }
        this.latestSourceRowsCount = length;
        if (this.cachedLength === null || reValidate) {
          (0, _number.rangeEach)(length - 1, function (row) {
            row = _this2.instance.runHooks('modifyRow', row);
            if (row === null) {
              --length;
            }
          });
          this.cachedLength = length;
        } else {
          length = this.cachedLength;
        }
      } else {
        this.interval.stop();
      }
      return Math.min(length, maxRows);
    };
    DataMap.prototype.getAll = function () {
      var start = {
        row: 0,
        col: 0
      };
      var end = {
        row: Math.max(this.instance.countSourceRows() - 1, 0),
        col: Math.max(this.instance.countCols() - 1, 0)
      };
      if (start.row - end.row === 0 && !this.instance.countSourceRows()) {
        return [];
      }
      return this.getRange(start, end, DataMap.prototype.DESTINATION_RENDERER);
    };
    DataMap.prototype.getRange = function (start, end, destination) {
      var r, rlen, c, clen, output = [],
        row;
      var maxRows = this.instance.getSettings().maxRows;
      var maxCols = this.instance.getSettings().maxCols;
      if (maxRows === 0 || maxCols === 0) {
        return [];
      }
      var getFn = destination === this.DESTINATION_CLIPBOARD_GENERATOR ? this.getCopyable : this.get;
      rlen = Math.min(Math.max(maxRows - 1, 0), Math.max(start.row, end.row));
      clen = Math.min(Math.max(maxCols - 1, 0), Math.max(start.col, end.col));
      for (r = Math.min(start.row, end.row); r <= rlen; r++) {
        row = [];
        var physicalRow = this.instance.runHooks('modifyRow', r);
        for (c = Math.min(start.col, end.col); c <= clen; c++) {
          if (physicalRow === null) {
            break;
          }
          row.push(getFn.call(this, r, this.colToProp(c)));
        }
        if (physicalRow !== null) {
          output.push(row);
        }
      }
      return output;
    };
    DataMap.prototype.getText = function (start, end) {
      return _SheetClip2.default.stringify(this.getRange(start, end, this.DESTINATION_RENDERER));
    };
    DataMap.prototype.getCopyableText = function (start, end) {
      return _SheetClip2.default.stringify(this.getRange(start, end, this.DESTINATION_CLIPBOARD_GENERATOR));
    };
    DataMap.prototype.onSkipLengthCache = function (delay) {
      var _this3 = this;
      this.skipCache = true;
      setTimeout(function () {
        _this3.skipCache = false;
      }, delay);
    };
    DataMap.prototype.destroy = function () {
      this.interval.stop();
      this.interval = null;
      this.instance = null;
      this.priv = null;
      this.GridSettings = null;
      this.dataSource = null;
      this.cachedLength = null;
      this.duckSchema = null;
    };
    exports.default = DataMap;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _object = __webpack_require__(3);
    var _array = __webpack_require__(2);
    var _number = __webpack_require__(5);

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var DataSource = function () {
      function DataSource(hotInstance) {
        var dataSource = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
        _classCallCheck(this, DataSource);
        this.hot = hotInstance;
        this.data = dataSource;
        this.dataType = 'array';
        this.colToProp = function () { };
        this.propToCol = function () { };
      }
      _createClass(DataSource, [{
        key: 'getData',
        value: function getData() {
          var toArray = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
          var result = this.data;
          if (toArray) {
            result = this.getByRange({
              row: 0,
              col: 0
            }, {
              row: Math.max(this.countRows() - 1, 0),
              col: Math.max(this.countColumns() - 1, 0)
            }, true);
          }
          return result;
        }
      }, {
        key: 'setData',
        value: function setData(data) {
          this.data = data;
        }
      }, {
        key: 'getAtColumn',
        value: function getAtColumn(column) {
          var _this = this;
          var result = [];
          (0, _array.arrayEach)(this.data, function (row) {
            var property = _this.colToProp(column);
            if (typeof property === 'string') {
              row = (0, _object.getProperty)(row, property);
            } else {
              row = row[property];
            }
            result.push(row);
          });
          return result;
        }
      }, {
        key: 'getAtRow',
        value: function getAtRow(row) {
          return this.data[row];
        }
      }, {
        key: 'getAtCell',
        value: function getAtCell(row, column) {
          var result = null;
          var modifyRowData = this.hot.runHooks('modifyRowData', row);
          var dataRow = isNaN(modifyRowData) ? modifyRowData : this.data[row];
          if (dataRow) {
            var prop = this.colToProp(column);
            if (typeof prop === 'string') {
              result = (0, _object.getProperty)(dataRow, prop);
            } else if (typeof prop === 'function') {
              result = prop(this.data.slice(row, row + 1)[0]);
            } else {
              result = dataRow[prop];
            }
          }
          return result;
        }
      }, {
        key: 'getByRange',
        value: function getByRange(start, end) {
          var _this2 = this;
          var toArray = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
          var startRow = Math.min(start.row, end.row);
          var startCol = Math.min(start.col, end.col);
          var endRow = Math.max(start.row, end.row);
          var endCol = Math.max(start.col, end.col);
          var result = [];
          (0, _number.rangeEach)(startRow, endRow, function (currentRow) {
            var row = _this2.getAtRow(currentRow);
            var newRow = void 0;
            if (_this2.dataType === 'array') {
              newRow = row.slice(startCol, endCol + 1);
            } else if (_this2.dataType === 'object') {
              newRow = toArray ? [] : {};
              (0, _number.rangeEach)(startCol, endCol, function (column) {
                var prop = _this2.colToProp(column);
                if (toArray) {
                  newRow.push(row[prop]);
                } else {
                  newRow[prop] = row[prop];
                }
              });
            }
            result.push(newRow);
          });
          return result;
        }
      }, {
        key: 'countRows',
        value: function countRows() {
          return Array.isArray(this.data) ? this.data.length : 0;
        }
      }, {
        key: 'countColumns',
        value: function countColumns() {
          var result = 0;
          if (Array.isArray(this.data)) {
            if (this.dataType === 'array') {
              result = this.data[0].length;
            } else if (this.dataType === 'object') {
              result = Object.keys(this.data[0]).length;
            }
          }
          return result;
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          this.data = null;
          this.hot = null;
        }
      }]);
      return DataSource;
    }();
    exports.default = DataSource;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _src = __webpack_require__(14);
    var _unicode = __webpack_require__(15);
    var _event = __webpack_require__(7);
    var _editors = __webpack_require__(13);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _baseEditor = __webpack_require__(36);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function EditorManager(instance, priv, selection) {
      var _this = this,
        destroyed = false,
        eventManager, activeEditor;
      eventManager = new _eventManager2.default(instance);

      function moveSelectionAfterEnter(shiftKey) {
        selection.setSelectedHeaders(false, false, false);
        var enterMoves = typeof priv.settings.enterMoves === 'function' ? priv.settings.enterMoves(event) : priv.settings.enterMoves;
        if (shiftKey) {
          selection.transformStart(-enterMoves.row, -enterMoves.col);
        } else {
          selection.transformStart(enterMoves.row, enterMoves.col, true);
        }
      }

      function moveSelectionUp(shiftKey) {
        if (shiftKey) {
          if (selection.selectedHeader.cols) {
            selection.setSelectedHeaders(selection.selectedHeader.rows, false, false);
          }
          selection.transformEnd(-1, 0);
        } else {
          selection.setSelectedHeaders(false, false, false);
          selection.transformStart(-1, 0);
        }
      }

      function moveSelectionDown(shiftKey) {
        if (shiftKey) {
          selection.transformEnd(1, 0);
        } else {
          selection.setSelectedHeaders(false, false, false);
          selection.transformStart(1, 0);
        }
      }

      function moveSelectionRight(shiftKey) {
        if (shiftKey) {
          selection.transformEnd(0, 1);
        } else {
          selection.setSelectedHeaders(false, false, false);
          selection.transformStart(0, 1);
        }
      }

      function moveSelectionLeft(shiftKey) {
        if (shiftKey) {
          if (selection.selectedHeader.rows) {
            selection.setSelectedHeaders(false, selection.selectedHeader.cols, false);
          }
          selection.transformEnd(0, -1);
        } else {
          selection.setSelectedHeaders(false, false, false);
          selection.transformStart(0, -1);
        }
      }

      function onKeyDown(event) {
        var ctrlDown, rangeModifier;
        if (!instance.isListening()) {
          return;
        }
        instance.runHooks('beforeKeyDown', event);
        if (destroyed) {
          return;
        }
        if ((0, _event.isImmediatePropagationStopped)(event)) {
          return;
        }
        priv.lastKeyCode = event.keyCode;
        if (!selection.isSelected()) {
          return;
        }
        ctrlDown = (event.ctrlKey || event.metaKey) && !event.altKey;
        if (activeEditor && !activeEditor.isWaiting()) {
          if (!(0, _unicode.isMetaKey)(event.keyCode) && !(0, _unicode.isCtrlKey)(event.keyCode) && !ctrlDown && !_this.isEditorOpened()) {
            _this.openEditor('', event);
            return;
          }
        }
        rangeModifier = event.shiftKey ? selection.setRangeEnd : selection.setRangeStart;
        switch (event.keyCode) {
          case _unicode.KEY_CODES.A:
            if (!_this.isEditorOpened() && ctrlDown) {
              selection.selectAll();
              event.preventDefault();
              (0, _event.stopPropagation)(event);
            }
            break;
          case _unicode.KEY_CODES.ARROW_UP:
            if (_this.isEditorOpened() && !activeEditor.isWaiting()) {
              _this.closeEditorAndSaveChanges(ctrlDown);
            }
            moveSelectionUp(event.shiftKey);
            event.preventDefault();
            (0, _event.stopPropagation)(event);
            break;
          case _unicode.KEY_CODES.ARROW_DOWN:
            if (_this.isEditorOpened() && !activeEditor.isWaiting()) {
              _this.closeEditorAndSaveChanges(ctrlDown);
            }
            moveSelectionDown(event.shiftKey);
            event.preventDefault();
            (0, _event.stopPropagation)(event);
            break;
          case _unicode.KEY_CODES.ARROW_RIGHT:
            if (_this.isEditorOpened() && !activeEditor.isWaiting()) {
              _this.closeEditorAndSaveChanges(ctrlDown);
            }
            moveSelectionRight(event.shiftKey);
            event.preventDefault();
            (0, _event.stopPropagation)(event);
            break;
          case _unicode.KEY_CODES.ARROW_LEFT:
            if (_this.isEditorOpened() && !activeEditor.isWaiting()) {
              _this.closeEditorAndSaveChanges(ctrlDown);
            }
            moveSelectionLeft(event.shiftKey);
            event.preventDefault();
            (0, _event.stopPropagation)(event);
            break;
          case _unicode.KEY_CODES.TAB:
            selection.setSelectedHeaders(false, false, false);
            var tabMoves = typeof priv.settings.tabMoves === 'function' ? priv.settings.tabMoves(event) : priv.settings.tabMoves;
            if (event.shiftKey) {
              selection.transformStart(-tabMoves.row, -tabMoves.col);
            } else {
              selection.transformStart(tabMoves.row, tabMoves.col, true);
            }
            event.preventDefault();
            (0, _event.stopPropagation)(event);
            break;
          case _unicode.KEY_CODES.BACKSPACE:
          case _unicode.KEY_CODES.DELETE:
            selection.empty(event);
            _this.prepareEditor();
            event.preventDefault();
            break;
          case _unicode.KEY_CODES.F2:
            _this.openEditor(null, event);
            if (activeEditor) {
              activeEditor.enableFullEditMode();
            }
            event.preventDefault();
            break;
          case _unicode.KEY_CODES.ENTER:
            if (_this.isEditorOpened()) {
              if (activeEditor && activeEditor.state !== _baseEditor.EditorState.WAITING) {
                _this.closeEditorAndSaveChanges(ctrlDown);
              }
              moveSelectionAfterEnter(event.shiftKey);
            } else if (instance.getSettings().enterBeginsEditing) {
              _this.openEditor(null, event);
              if (activeEditor) {
                activeEditor.enableFullEditMode();
              }
            } else {
              moveSelectionAfterEnter(event.shiftKey);
            }
            event.preventDefault();
            (0, _event.stopImmediatePropagation)(event);
            break;
          case _unicode.KEY_CODES.ESCAPE:
            if (_this.isEditorOpened()) {
              _this.closeEditorAndRestoreOriginalValue(ctrlDown);
            }
            event.preventDefault();
            break;
          case _unicode.KEY_CODES.HOME:
            selection.setSelectedHeaders(false, false, false);
            if (event.ctrlKey || event.metaKey) {
              rangeModifier(new _src.CellCoords(0, priv.selRange.from.col));
            } else {
              rangeModifier(new _src.CellCoords(priv.selRange.from.row, 0));
            }
            event.preventDefault();
            (0, _event.stopPropagation)(event);
            break;
          case _unicode.KEY_CODES.END:
            selection.setSelectedHeaders(false, false, false);
            if (event.ctrlKey || event.metaKey) {
              rangeModifier(new _src.CellCoords(instance.countRows() - 1, priv.selRange.from.col));
            } else {
              rangeModifier(new _src.CellCoords(priv.selRange.from.row, instance.countCols() - 1));
            }
            event.preventDefault();
            (0, _event.stopPropagation)(event);
            break;
          case _unicode.KEY_CODES.PAGE_UP:
            selection.setSelectedHeaders(false, false, false);
            selection.transformStart(-instance.countVisibleRows(), 0);
            event.preventDefault();
            (0, _event.stopPropagation)(event);
            break;
          case _unicode.KEY_CODES.PAGE_DOWN:
            selection.setSelectedHeaders(false, false, false);
            selection.transformStart(instance.countVisibleRows(), 0);
            event.preventDefault();
            (0, _event.stopPropagation)(event);
            break;
          default:
            break;
        }
      }

      function init() {
        instance.addHook('afterDocumentKeyDown', onKeyDown);
        eventManager.addEventListener(document.documentElement, 'keydown', function (event) {
          if (!destroyed) {
            instance.runHooks('afterDocumentKeyDown', event);
          }
        });

        function onDblClick(event, coords, elem) {
          if (elem.nodeName == 'TD') {
            _this.openEditor();
            if (activeEditor) {
              activeEditor.enableFullEditMode();
            }
          }
        }
        instance.view.wt.update('onCellDblClick', onDblClick);
        instance.addHook('afterDestroy', function () {
          destroyed = true;
        });
      }
      this.destroyEditor = function (revertOriginal) {
        this.closeEditor(revertOriginal);
      };
      this.getActiveEditor = function () {
        return activeEditor;
      };
      this.prepareEditor = function () {
        var row, col, prop, td, originalValue, cellProperties, editorClass;
        if (activeEditor && activeEditor.isWaiting()) {
          this.closeEditor(false, false, function (dataSaved) {
            if (dataSaved) {
              _this.prepareEditor();
            }
          });
          return;
        }
        row = priv.selRange.highlight.row;
        col = priv.selRange.highlight.col;
        prop = instance.colToProp(col);
        td = instance.getCell(row, col);
        originalValue = instance.getSourceDataAtCell(instance.runHooks('modifyRow', row), col);
        cellProperties = instance.getCellMeta(row, col);
        editorClass = instance.getCellEditor(cellProperties);
        if (editorClass) {
          activeEditor = (0, _editors.getEditorInstance)(editorClass, instance);
          activeEditor.prepare(row, col, prop, td, originalValue, cellProperties);
        } else {
          activeEditor = void 0;
        }
      };
      this.isEditorOpened = function () {
        return activeEditor && activeEditor.isOpened();
      };
      this.openEditor = function (initialValue, event) {
        if (activeEditor && !activeEditor.cellProperties.readOnly) {
          activeEditor.beginEditing(initialValue, event);
        } else if (activeEditor && activeEditor.cellProperties.readOnly) {
          if (event && event.keyCode === _unicode.KEY_CODES.ENTER) {
            moveSelectionAfterEnter();
          }
        }
      };
      this.closeEditor = function (restoreOriginalValue, ctrlDown, callback) {
        if (activeEditor) {
          activeEditor.finishEditing(restoreOriginalValue, ctrlDown, callback);
        } else if (callback) {
          callback(false);
        }
      };
      this.closeEditorAndSaveChanges = function (ctrlDown) {
        return this.closeEditor(false, ctrlDown);
      };
      this.closeEditorAndRestoreOriginalValue = function (ctrlDown) {
        return this.closeEditor(true, ctrlDown);
      };
      init();
    }
    exports.default = EditorManager;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _baseEditor = __webpack_require__(36);
    var _baseEditor2 = _interopRequireDefault(_baseEditor);
    var _element = __webpack_require__(0);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var CheckboxEditor = function (_BaseEditor) {
      _inherits(CheckboxEditor, _BaseEditor);

      function CheckboxEditor() {
        _classCallCheck(this, CheckboxEditor);
        return _possibleConstructorReturn(this, (CheckboxEditor.__proto__ || Object.getPrototypeOf(CheckboxEditor)).apply(this, arguments));
      }
      _createClass(CheckboxEditor, [{
        key: 'beginEditing',
        value: function beginEditing(initialValue, event) {
          if (event === void 0) {
            var checkbox = this.TD.querySelector('input[type="checkbox"]');
            if (!(0, _element.hasClass)(checkbox, 'htBadValue')) {
              checkbox.click();
            }
          }
        }
      }, {
        key: 'finishEditing',
        value: function finishEditing() { }
      }, {
        key: 'init',
        value: function init() { }
      }, {
        key: 'open',
        value: function open() { }
      }, {
        key: 'close',
        value: function close() { }
      }, {
        key: 'getValue',
        value: function getValue() { }
      }, {
        key: 'setValue',
        value: function setValue() { }
      }, {
        key: 'focus',
        value: function focus() { }
      }]);
      return CheckboxEditor;
    }(_baseEditor2.default);
    exports.default = CheckboxEditor;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _moment = __webpack_require__(42);
    var _moment2 = _interopRequireDefault(_moment);
    var _pikaday = __webpack_require__(410);
    var _pikaday2 = _interopRequireDefault(_pikaday);
    __webpack_require__(298);
    var _element = __webpack_require__(0);
    var _object = __webpack_require__(3);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _unicode = __webpack_require__(15);
    var _event = __webpack_require__(7);
    var _textEditor = __webpack_require__(44);
    var _textEditor2 = _interopRequireDefault(_textEditor);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var DateEditor = function (_TextEditor) {
      _inherits(DateEditor, _TextEditor);

      function DateEditor(hotInstance) {
        _classCallCheck(this, DateEditor);
        var _this = _possibleConstructorReturn(this, (DateEditor.__proto__ || Object.getPrototypeOf(DateEditor)).call(this, hotInstance));
        _this.defaultDateFormat = 'DD/MM/YYYY';
        _this.isCellEdited = false;
        _this.parentDestroyed = false;
        return _this;
      }
      _createClass(DateEditor, [{
        key: 'init',
        value: function init() {
          var _this2 = this;
          if (typeof _moment2.default !== 'function') {
            throw new Error('You need to include moment.js to your project.');
          }
          if (typeof _pikaday2.default !== 'function') {
            throw new Error('You need to include Pikaday to your project.');
          }
          _get(DateEditor.prototype.__proto__ || Object.getPrototypeOf(DateEditor.prototype), 'init', this).call(this);
          this.instance.addHook('afterDestroy', function () {
            _this2.parentDestroyed = true;
            _this2.destroyElements();
          });
        }
      }, {
        key: 'createElements',
        value: function createElements() {
          _get(DateEditor.prototype.__proto__ || Object.getPrototypeOf(DateEditor.prototype), 'createElements', this).call(this);
          this.datePicker = document.createElement('DIV');
          this.datePickerStyle = this.datePicker.style;
          this.datePickerStyle.position = 'absolute';
          this.datePickerStyle.top = 0;
          this.datePickerStyle.left = 0;
          this.datePickerStyle.zIndex = 9999;
          (0, _element.addClass)(this.datePicker, 'htDatepickerHolder');
          document.body.appendChild(this.datePicker);
          this.$datePicker = new _pikaday2.default(this.getDatePickerConfig());
          var eventManager = new _eventManager2.default(this);
          eventManager.addEventListener(this.datePicker, 'mousedown', function (event) {
            return (0, _event.stopPropagation)(event);
          });
          this.hideDatepicker();
        }
      }, {
        key: 'destroyElements',
        value: function destroyElements() {
          this.$datePicker.destroy();
        }
      }, {
        key: 'prepare',
        value: function prepare(row, col, prop, td, originalValue, cellProperties) {
          this._opened = false;
          _get(DateEditor.prototype.__proto__ || Object.getPrototypeOf(DateEditor.prototype), 'prepare', this).call(this, row, col, prop, td, originalValue, cellProperties);
        }
      }, {
        key: 'open',
        value: function open() {
          var event = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
          _get(DateEditor.prototype.__proto__ || Object.getPrototypeOf(DateEditor.prototype), 'open', this).call(this);
          this.showDatepicker(event);
        }
      }, {
        key: 'close',
        value: function close() {
          var _this3 = this;
          this._opened = false;
          this.instance._registerTimeout(setTimeout(function () {
            _this3.instance.selection.refreshBorders();
          }, 0));
          _get(DateEditor.prototype.__proto__ || Object.getPrototypeOf(DateEditor.prototype), 'close', this).call(this);
        }
      }, {
        key: 'finishEditing',
        value: function finishEditing() {
          var isCancelled = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
          var ctrlDown = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
          if (isCancelled) {
            var value = this.originalValue;
            if (value !== void 0) {
              this.setValue(value);
            }
          }
          this.hideDatepicker();
          _get(DateEditor.prototype.__proto__ || Object.getPrototypeOf(DateEditor.prototype), 'finishEditing', this).call(this, isCancelled, ctrlDown);
        }
      }, {
        key: 'showDatepicker',
        value: function showDatepicker(event) {
          this.$datePicker.config(this.getDatePickerConfig());
          var offset = this.TD.getBoundingClientRect();
          var dateFormat = this.cellProperties.dateFormat || this.defaultDateFormat;
          var datePickerConfig = this.$datePicker.config();
          var dateStr = void 0;
          var isMouseDown = this.instance.view.isMouseDown();
          var isMeta = event ? (0, _unicode.isMetaKey)(event.keyCode) : false;
          this.datePickerStyle.top = window.pageYOffset + offset.top + (0, _element.outerHeight)(this.TD) + 'px';
          this.datePickerStyle.left = window.pageXOffset + offset.left + 'px';
          this.$datePicker._onInputFocus = function () { };
          datePickerConfig.format = dateFormat;
          if (this.originalValue) {
            dateStr = this.originalValue;
            if ((0, _moment2.default)(dateStr, dateFormat, true).isValid()) {
              this.$datePicker.setMoment((0, _moment2.default)(dateStr, dateFormat), true);
            }
            if (this.getValue() !== this.originalValue) {
              this.setValue(this.originalValue);
            }
            if (!isMeta && !isMouseDown) {
              this.setValue('');
            }
          } else if (this.cellProperties.defaultDate) {
            dateStr = this.cellProperties.defaultDate;
            datePickerConfig.defaultDate = dateStr;
            if ((0, _moment2.default)(dateStr, dateFormat, true).isValid()) {
              this.$datePicker.setMoment((0, _moment2.default)(dateStr, dateFormat), true);
            }
            if (!isMeta && !isMouseDown) {
              this.setValue('');
            }
          } else {
            this.$datePicker.gotoToday();
          }
          this.datePickerStyle.display = 'block';
          this.$datePicker.show();
        }
      }, {
        key: 'hideDatepicker',
        value: function hideDatepicker() {
          this.datePickerStyle.display = 'none';
          this.$datePicker.hide();
        }
      }, {
        key: 'getDatePickerConfig',
        value: function getDatePickerConfig() {
          var _this4 = this;
          var htInput = this.TEXTAREA;
          var options = {};
          if (this.cellProperties && this.cellProperties.datePickerConfig) {
            (0, _object.deepExtend)(options, this.cellProperties.datePickerConfig);
          }
          var origOnSelect = options.onSelect;
          var origOnClose = options.onClose;
          options.field = htInput;
          options.trigger = htInput;
          options.container = this.datePicker;
          options.bound = false;
          options.format = options.format || this.defaultDateFormat;
          options.reposition = options.reposition || false;
          options.onSelect = function (dateStr) {
            if (!isNaN(dateStr.getTime())) {
              dateStr = (0, _moment2.default)(dateStr).format(_this4.cellProperties.dateFormat || _this4.defaultDateFormat);
            }
            _this4.setValue(dateStr);
            _this4.hideDatepicker();
            if (origOnSelect) {
              origOnSelect();
            }
          };
          options.onClose = function () {
            if (!_this4.parentDestroyed) {
              _this4.finishEditing(false);
            }
            if (origOnClose) {
              origOnClose();
            }
          };
          return options;
        }
      }]);
      return DateEditor;
    }(_textEditor2.default);
    exports.default = DateEditor;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _autocompleteEditor = __webpack_require__(263);
    var _autocompleteEditor2 = _interopRequireDefault(_autocompleteEditor);
    var _pluginHooks = __webpack_require__(11);
    var _pluginHooks2 = _interopRequireDefault(_pluginHooks);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var DropdownEditor = function (_AutocompleteEditor) {
      _inherits(DropdownEditor, _AutocompleteEditor);

      function DropdownEditor() {
        _classCallCheck(this, DropdownEditor);
        return _possibleConstructorReturn(this, (DropdownEditor.__proto__ || Object.getPrototypeOf(DropdownEditor)).apply(this, arguments));
      }
      _createClass(DropdownEditor, [{
        key: 'prepare',
        value: function prepare(row, col, prop, td, originalValue, cellProperties) {
          _get(DropdownEditor.prototype.__proto__ || Object.getPrototypeOf(DropdownEditor.prototype), 'prepare', this).call(this, row, col, prop, td, originalValue, cellProperties);
          this.cellProperties.filter = false;
          this.cellProperties.strict = true;
        }
      }]);
      return DropdownEditor;
    }(_autocompleteEditor2.default);
    _pluginHooks2.default.getSingleton().add('beforeValidate', function (value, row, col, source) {
      var cellMeta = this.getCellMeta(row, this.propToCol(col));
      if (cellMeta.editor === DropdownEditor) {
        if (cellMeta.strict === void 0) {
          cellMeta.filter = false;
          cellMeta.strict = true;
        }
      }
    });
    exports.default = DropdownEditor;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _unicode = __webpack_require__(15);
    var _event = __webpack_require__(7);
    var _element = __webpack_require__(0);
    var _baseEditor = __webpack_require__(36);
    var _baseEditor2 = _interopRequireDefault(_baseEditor);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }
    var MobileTextEditor = _baseEditor2.default.prototype.extend();
    var domDimensionsCache = {};
    var createControls = function createControls() {
      this.controls = {};
      this.controls.leftButton = document.createElement('DIV');
      this.controls.leftButton.className = 'leftButton';
      this.controls.rightButton = document.createElement('DIV');
      this.controls.rightButton.className = 'rightButton';
      this.controls.upButton = document.createElement('DIV');
      this.controls.upButton.className = 'upButton';
      this.controls.downButton = document.createElement('DIV');
      this.controls.downButton.className = 'downButton';
      for (var button in this.controls) {
        if (Object.prototype.hasOwnProperty.call(this.controls, button)) {
          this.positionControls.appendChild(this.controls[button]);
        }
      }
    };
    MobileTextEditor.prototype.valueChanged = function () {
      return this.initValue != this.getValue();
    };
    MobileTextEditor.prototype.init = function () {
      var that = this;
      this.eventManager = new _eventManager2.default(this.instance);
      this.createElements();
      this.bindEvents();
      this.instance.addHook('afterDestroy', function () {
        that.destroy();
      });
    };
    MobileTextEditor.prototype.getValue = function () {
      return this.TEXTAREA.value;
    };
    MobileTextEditor.prototype.setValue = function (newValue) {
      this.initValue = newValue;
      this.TEXTAREA.value = newValue;
    };
    MobileTextEditor.prototype.createElements = function () {
      this.editorContainer = document.createElement('DIV');
      this.editorContainer.className = 'htMobileEditorContainer';
      this.cellPointer = document.createElement('DIV');
      this.cellPointer.className = 'cellPointer';
      this.moveHandle = document.createElement('DIV');
      this.moveHandle.className = 'moveHandle';
      this.inputPane = document.createElement('DIV');
      this.inputPane.className = 'inputs';
      this.positionControls = document.createElement('DIV');
      this.positionControls.className = 'positionControls';
      this.TEXTAREA = document.createElement('TEXTAREA');
      (0, _element.addClass)(this.TEXTAREA, 'handsontableInput');
      this.inputPane.appendChild(this.TEXTAREA);
      this.editorContainer.appendChild(this.cellPointer);
      this.editorContainer.appendChild(this.moveHandle);
      this.editorContainer.appendChild(this.inputPane);
      this.editorContainer.appendChild(this.positionControls);
      createControls.call(this);
      document.body.appendChild(this.editorContainer);
    };
    MobileTextEditor.prototype.onBeforeKeyDown = function (event) {
      var instance = this;
      var that = instance.getActiveEditor();
      if (event.target !== that.TEXTAREA || (0, _event.isImmediatePropagationStopped)(event)) {
        return;
      }
      switch (event.keyCode) {
        case _unicode.KEY_CODES.ENTER:
          that.close();
          event.preventDefault();
          break;
        case _unicode.KEY_CODES.BACKSPACE:
          (0, _event.stopImmediatePropagation)(event);
          break;
        default:
          break;
      }
    };
    MobileTextEditor.prototype.open = function () {
      this.instance.addHook('beforeKeyDown', this.onBeforeKeyDown);
      (0, _element.addClass)(this.editorContainer, 'active');
      (0, _element.removeClass)(this.cellPointer, 'hidden');
      this.updateEditorPosition();
    };
    MobileTextEditor.prototype.focus = function () {
      this.TEXTAREA.focus();
      (0, _element.setCaretPosition)(this.TEXTAREA, this.TEXTAREA.value.length);
    };
    MobileTextEditor.prototype.close = function () {
      this.TEXTAREA.blur();
      this.instance.removeHook('beforeKeyDown', this.onBeforeKeyDown);
      (0, _element.removeClass)(this.editorContainer, 'active');
    };
    MobileTextEditor.prototype.scrollToView = function () {
      var coords = this.instance.getSelectedRange().highlight;
      this.instance.view.scrollViewport(coords);
    };
    MobileTextEditor.prototype.hideCellPointer = function () {
      if (!(0, _element.hasClass)(this.cellPointer, 'hidden')) {
        (0, _element.addClass)(this.cellPointer, 'hidden');
      }
    };
    MobileTextEditor.prototype.updateEditorPosition = function (x, y) {
      if (x && y) {
        x = parseInt(x, 10);
        y = parseInt(y, 10);
        this.editorContainer.style.top = y + 'px';
        this.editorContainer.style.left = x + 'px';
      } else {
        var selection = this.instance.getSelected(),
          selectedCell = this.instance.getCell(selection[0], selection[1]);
        if (!domDimensionsCache.cellPointer) {
          domDimensionsCache.cellPointer = {
            height: (0, _element.outerHeight)(this.cellPointer),
            width: (0, _element.outerWidth)(this.cellPointer)
          };
        }
        if (!domDimensionsCache.editorContainer) {
          domDimensionsCache.editorContainer = {
            width: (0, _element.outerWidth)(this.editorContainer)
          };
        }
        if (selectedCell !== undefined) {
          var scrollLeft = this.instance.view.wt.wtOverlays.leftOverlay.trimmingContainer == window ? 0 : (0, _element.getScrollLeft)(this.instance.view.wt.wtOverlays.leftOverlay.holder);
          var scrollTop = this.instance.view.wt.wtOverlays.topOverlay.trimmingContainer == window ? 0 : (0, _element.getScrollTop)(this.instance.view.wt.wtOverlays.topOverlay.holder);
          var selectedCellOffset = (0, _element.offset)(selectedCell),
            selectedCellWidth = (0, _element.outerWidth)(selectedCell),
            currentScrollPosition = {
              x: scrollLeft,
              y: scrollTop
            };
          this.editorContainer.style.top = parseInt(selectedCellOffset.top + (0, _element.outerHeight)(selectedCell) - currentScrollPosition.y + domDimensionsCache.cellPointer.height, 10) + 'px';
          this.editorContainer.style.left = parseInt(window.innerWidth / 2 - domDimensionsCache.editorContainer.width / 2, 10) + 'px';
          if (selectedCellOffset.left + selectedCellWidth / 2 > parseInt(this.editorContainer.style.left, 10) + domDimensionsCache.editorContainer.width) {
            this.editorContainer.style.left = window.innerWidth - domDimensionsCache.editorContainer.width + 'px';
          } else if (selectedCellOffset.left + selectedCellWidth / 2 < parseInt(this.editorContainer.style.left, 10) + 20) {
            this.editorContainer.style.left = 0 + 'px';
          }
          this.cellPointer.style.left = parseInt(selectedCellOffset.left - domDimensionsCache.cellPointer.width / 2 - (0, _element.offset)(this.editorContainer).left + selectedCellWidth / 2 - currentScrollPosition.x, 10) + 'px';
        }
      }
    };
    MobileTextEditor.prototype.updateEditorData = function () {
      var selected = this.instance.getSelected(),
        selectedValue = this.instance.getDataAtCell(selected[0], selected[1]);
      this.row = selected[0];
      this.col = selected[1];
      this.setValue(selectedValue);
      this.updateEditorPosition();
    };
    MobileTextEditor.prototype.prepareAndSave = function () {
      var val;
      if (!this.valueChanged()) {
        return;
      }
      if (this.instance.getSettings().trimWhitespace) {
        val = [
          [String.prototype.trim.call(this.getValue())]
        ];
      } else {
        val = [
          [this.getValue()]
        ];
      }
      this.saveValue(val);
    };
    MobileTextEditor.prototype.bindEvents = function () {
      var that = this;
      this.eventManager.addEventListener(this.controls.leftButton, 'touchend', function (event) {
        that.prepareAndSave();
        that.instance.selection.transformStart(0, -1, null, true);
        that.updateEditorData();
        event.preventDefault();
      });
      this.eventManager.addEventListener(this.controls.rightButton, 'touchend', function (event) {
        that.prepareAndSave();
        that.instance.selection.transformStart(0, 1, null, true);
        that.updateEditorData();
        event.preventDefault();
      });
      this.eventManager.addEventListener(this.controls.upButton, 'touchend', function (event) {
        that.prepareAndSave();
        that.instance.selection.transformStart(-1, 0, null, true);
        that.updateEditorData();
        event.preventDefault();
      });
      this.eventManager.addEventListener(this.controls.downButton, 'touchend', function (event) {
        that.prepareAndSave();
        that.instance.selection.transformStart(1, 0, null, true);
        that.updateEditorData();
        event.preventDefault();
      });
      this.eventManager.addEventListener(this.moveHandle, 'touchstart', function (event) {
        if (event.touches.length == 1) {
          var touch = event.touches[0];
          var onTouchPosition = {
            x: that.editorContainer.offsetLeft,
            y: that.editorContainer.offsetTop
          };
          var onTouchOffset = {
            x: touch.pageX - onTouchPosition.x,
            y: touch.pageY - onTouchPosition.y
          };
          that.eventManager.addEventListener(this, 'touchmove', function (event) {
            var touch = event.touches[0];
            that.updateEditorPosition(touch.pageX - onTouchOffset.x, touch.pageY - onTouchOffset.y);
            that.hideCellPointer();
            event.preventDefault();
          });
        }
      });
      this.eventManager.addEventListener(document.body, 'touchend', function (event) {
        if (!(0, _element.isChildOf)(event.target, that.editorContainer) && !(0, _element.isChildOf)(event.target, that.instance.rootElement)) {
          that.close();
        }
      });
      this.eventManager.addEventListener(this.instance.view.wt.wtOverlays.leftOverlay.holder, 'scroll', function (event) {
        if (that.instance.view.wt.wtOverlays.leftOverlay.trimmingContainer != window) {
          that.hideCellPointer();
        }
      });
      this.eventManager.addEventListener(this.instance.view.wt.wtOverlays.topOverlay.holder, 'scroll', function (event) {
        if (that.instance.view.wt.wtOverlays.topOverlay.trimmingContainer != window) {
          that.hideCellPointer();
        }
      });
    };
    MobileTextEditor.prototype.destroy = function () {
      this.eventManager.clear();
      this.editorContainer.parentNode.removeChild(this.editorContainer);
    };
    exports.default = MobileTextEditor;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _numbro = __webpack_require__(52);
    var _numbro2 = _interopRequireDefault(_numbro);
    var _textEditor = __webpack_require__(44);
    var _textEditor2 = _interopRequireDefault(_textEditor);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var NumericEditor = function (_TextEditor) {
      _inherits(NumericEditor, _TextEditor);

      function NumericEditor() {
        _classCallCheck(this, NumericEditor);
        return _possibleConstructorReturn(this, (NumericEditor.__proto__ || Object.getPrototypeOf(NumericEditor)).apply(this, arguments));
      }
      _createClass(NumericEditor, [{
        key: 'beginEditing',
        value: function beginEditing(initialValue) {
          if (typeof initialValue === 'undefined' && this.originalValue) {
            if (typeof this.cellProperties.language !== 'undefined') {
              _numbro2.default.culture(this.cellProperties.language);
            }
            var decimalDelimiter = _numbro2.default.cultureData().delimiters.decimal;
            initialValue = ('' + this.originalValue).replace('.', decimalDelimiter);
          }
          _get(NumericEditor.prototype.__proto__ || Object.getPrototypeOf(NumericEditor.prototype), 'beginEditing', this).call(this, initialValue);
        }
      }]);
      return NumericEditor;
    }(_textEditor2.default);
    exports.default = NumericEditor;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _element = __webpack_require__(0);
    var _textEditor = __webpack_require__(44);
    var _textEditor2 = _interopRequireDefault(_textEditor);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var PasswordEditor = function (_TextEditor) {
      _inherits(PasswordEditor, _TextEditor);

      function PasswordEditor() {
        _classCallCheck(this, PasswordEditor);
        return _possibleConstructorReturn(this, (PasswordEditor.__proto__ || Object.getPrototypeOf(PasswordEditor)).apply(this, arguments));
      }
      _createClass(PasswordEditor, [{
        key: 'createElements',
        value: function createElements() {
          _get(PasswordEditor.prototype.__proto__ || Object.getPrototypeOf(PasswordEditor.prototype), 'createElements', this).call(this);
          this.TEXTAREA = document.createElement('input');
          this.TEXTAREA.setAttribute('type', 'password');
          this.TEXTAREA.className = 'handsontableInput';
          this.textareaStyle = this.TEXTAREA.style;
          this.textareaStyle.width = 0;
          this.textareaStyle.height = 0;
          (0, _element.empty)(this.TEXTAREA_PARENT);
          this.TEXTAREA_PARENT.appendChild(this.TEXTAREA);
        }
      }]);
      return PasswordEditor;
    }(_textEditor2.default);
    exports.default = PasswordEditor;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
      return typeof obj;
    } : function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
    var _element = __webpack_require__(0);
    var _event = __webpack_require__(7);
    var _unicode = __webpack_require__(15);
    var _baseEditor = __webpack_require__(36);
    var _baseEditor2 = _interopRequireDefault(_baseEditor);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }
    var SelectEditor = _baseEditor2.default.prototype.extend();
    SelectEditor.prototype.init = function () {
      this.select = document.createElement('SELECT');
      (0, _element.addClass)(this.select, 'htSelectEditor');
      this.select.style.display = 'none';
      this.instance.rootElement.appendChild(this.select);
      this.registerHooks();
    };
    SelectEditor.prototype.registerHooks = function () {
      var _this = this;
      this.instance.addHook('afterScrollHorizontally', function () {
        return _this.refreshDimensions();
      });
      this.instance.addHook('afterScrollVertically', function () {
        return _this.refreshDimensions();
      });
      this.instance.addHook('afterColumnResize', function () {
        return _this.refreshDimensions();
      });
      this.instance.addHook('afterRowResize', function () {
        return _this.refreshDimensions();
      });
    };
    SelectEditor.prototype.prepare = function () {
      _baseEditor2.default.prototype.prepare.apply(this, arguments);
      var selectOptions = this.cellProperties.selectOptions;
      var options;
      if (typeof selectOptions == 'function') {
        options = this.prepareOptions(selectOptions(this.row, this.col, this.prop));
      } else {
        options = this.prepareOptions(selectOptions);
      } (0, _element.empty)(this.select);
      for (var option in options) {
        if (Object.prototype.hasOwnProperty.call(options, option)) {
          var optionElement = document.createElement('OPTION');
          optionElement.value = option;
          (0, _element.fastInnerHTML)(optionElement, options[option]);
          this.select.appendChild(optionElement);
        }
      }
    };
    SelectEditor.prototype.prepareOptions = function (optionsToPrepare) {
      var preparedOptions = {};
      if (Array.isArray(optionsToPrepare)) {
        for (var i = 0, len = optionsToPrepare.length; i < len; i++) {
          preparedOptions[optionsToPrepare[i]] = optionsToPrepare[i];
        }
      } else if ((typeof optionsToPrepare === 'undefined' ? 'undefined' : _typeof(optionsToPrepare)) == 'object') {
        preparedOptions = optionsToPrepare;
      }
      return preparedOptions;
    };
    SelectEditor.prototype.getValue = function () {
      return this.select.value;
    };
    SelectEditor.prototype.setValue = function (value) {
      this.select.value = value;
    };
    var onBeforeKeyDown = function onBeforeKeyDown(event) {
      var instance = this;
      var editor = instance.getActiveEditor();
      switch (event.keyCode) {
        case _unicode.KEY_CODES.ARROW_UP:
          var previousOptionIndex = editor.select.selectedIndex - 1;
          if (previousOptionIndex >= 0) {
            editor.select[previousOptionIndex].selected = true;
          } (0, _event.stopImmediatePropagation)(event);
          event.preventDefault();
          break;
        case _unicode.KEY_CODES.ARROW_DOWN:
          var nextOptionIndex = editor.select.selectedIndex + 1;
          if (nextOptionIndex <= editor.select.length - 1) {
            editor.select[nextOptionIndex].selected = true;
          } (0, _event.stopImmediatePropagation)(event);
          event.preventDefault();
          break;
        default:
          break;
      }
    };
    SelectEditor.prototype.open = function () {
      this._opened = true;
      this.refreshDimensions();
      this.select.style.display = '';
      this.instance.addHook('beforeKeyDown', onBeforeKeyDown);
    };
    SelectEditor.prototype.close = function () {
      this._opened = false;
      this.select.style.display = 'none';
      this.instance.removeHook('beforeKeyDown', onBeforeKeyDown);
    };
    SelectEditor.prototype.focus = function () {
      this.select.focus();
    };
    SelectEditor.prototype.refreshValue = function () {
      var sourceData = this.instance.getSourceDataAtCell(this.row, this.prop);
      this.originalValue = sourceData;
      this.setValue(sourceData);
      this.refreshDimensions();
    };
    SelectEditor.prototype.refreshDimensions = function () {
      if (this.state !== _baseEditor.EditorState.EDITING) {
        return;
      }
      this.TD = this.getEditedCell();
      if (!this.TD) {
        this.close();
        return;
      }
      var width = (0, _element.outerWidth)(this.TD) + 1,
        height = (0, _element.outerHeight)(this.TD) + 1,
        currentOffset = (0, _element.offset)(this.TD),
        containerOffset = (0, _element.offset)(this.instance.rootElement),
        scrollableContainer = (0, _element.getScrollableElement)(this.TD),
        editTop = currentOffset.top - containerOffset.top - 1 - (scrollableContainer.scrollTop || 0),
        editLeft = currentOffset.left - containerOffset.left - 1 - (scrollableContainer.scrollLeft || 0),
        editorSection = this.checkEditorSection(),
        cssTransformOffset;
      var settings = this.instance.getSettings();
      var rowHeadersCount = settings.rowHeaders ? 1 : 0;
      var colHeadersCount = settings.colHeaders ? 1 : 0;
      switch (editorSection) {
        case 'top':
          cssTransformOffset = (0, _element.getCssTransform)(this.instance.view.wt.wtOverlays.topOverlay.clone.wtTable.holder.parentNode);
          break;
        case 'left':
          cssTransformOffset = (0, _element.getCssTransform)(this.instance.view.wt.wtOverlays.leftOverlay.clone.wtTable.holder.parentNode);
          break;
        case 'top-left-corner':
          cssTransformOffset = (0, _element.getCssTransform)(this.instance.view.wt.wtOverlays.topLeftCornerOverlay.clone.wtTable.holder.parentNode);
          break;
        case 'bottom-left-corner':
          cssTransformOffset = (0, _element.getCssTransform)(this.instance.view.wt.wtOverlays.bottomLeftCornerOverlay.clone.wtTable.holder.parentNode);
          break;
        case 'bottom':
          cssTransformOffset = (0, _element.getCssTransform)(this.instance.view.wt.wtOverlays.bottomOverlay.clone.wtTable.holder.parentNode);
          break;
        default:
          break;
      }
      if (this.instance.getSelected()[0] === 0) {
        editTop += 1;
      }
      if (this.instance.getSelected()[1] === 0) {
        editLeft += 1;
      }
      var selectStyle = this.select.style;
      if (cssTransformOffset && cssTransformOffset != -1) {
        selectStyle[cssTransformOffset[0]] = cssTransformOffset[1];
      } else {
        (0, _element.resetCssTransform)(this.select);
      }
      var cellComputedStyle = (0, _element.getComputedStyle)(this.TD);
      if (parseInt(cellComputedStyle.borderTopWidth, 10) > 0) {
        height -= 1;
      }
      if (parseInt(cellComputedStyle.borderLeftWidth, 10) > 0) {
        width -= 1;
      }
      selectStyle.height = height + 'px';
      selectStyle.minWidth = width + 'px';
      selectStyle.top = editTop + 'px';
      selectStyle.left = editLeft + 'px';
      selectStyle.margin = '0px';
    };
    SelectEditor.prototype.getEditedCell = function () {
      var editorSection = this.checkEditorSection(),
        editedCell;
      switch (editorSection) {
        case 'top':
          editedCell = this.instance.view.wt.wtOverlays.topOverlay.clone.wtTable.getCell({
            row: this.row,
            col: this.col
          });
          this.select.style.zIndex = 101;
          break;
        case 'corner':
          editedCell = this.instance.view.wt.wtOverlays.topLeftCornerOverlay.clone.wtTable.getCell({
            row: this.row,
            col: this.col
          });
          this.select.style.zIndex = 103;
          break;
        case 'left':
          editedCell = this.instance.view.wt.wtOverlays.leftOverlay.clone.wtTable.getCell({
            row: this.row,
            col: this.col
          });
          this.select.style.zIndex = 102;
          break;
        default:
          editedCell = this.instance.getCell(this.row, this.col);
          this.select.style.zIndex = '';
          break;
      }
      return editedCell != -1 && editedCell != -2 ? editedCell : void 0;
    };
    exports.default = SelectEditor;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.toSingleLine = toSingleLine;
    var _array = __webpack_require__(2);

    function toSingleLine(strings) {
      for (var _len = arguments.length, expressions = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        expressions[_key - 1] = arguments[_key];
      }
      var result = (0, _array.arrayReduce)(strings, function (previousValue, currentValue, index) {
        var valueWithoutWhiteSpaces = currentValue.replace(/(?:\r?\n\s+)/g, '');
        var expressionForIndex = expressions[index] ? expressions[index] : '';
        return previousValue + valueWithoutWhiteSpaces + expressionForIndex;
      }, '');
      return result.trim();
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    __webpack_require__(98);
    __webpack_require__(115);
    __webpack_require__(124);
    __webpack_require__(125);
    __webpack_require__(109);
    __webpack_require__(123);
    __webpack_require__(106);
    __webpack_require__(107);
    __webpack_require__(108);
    __webpack_require__(97);
    __webpack_require__(120);
    __webpack_require__(118);
    __webpack_require__(116);
    __webpack_require__(121);
    __webpack_require__(122);
    __webpack_require__(117);
    __webpack_require__(119);
    __webpack_require__(110);
    __webpack_require__(111);
    __webpack_require__(112);
    __webpack_require__(114);
    __webpack_require__(113);
    __webpack_require__(95);
    __webpack_require__(96);
    __webpack_require__(91);
    __webpack_require__(94);
    __webpack_require__(93);
    __webpack_require__(92);
    __webpack_require__(70);
    __webpack_require__(100);
    __webpack_require__(101);
    __webpack_require__(103);
    __webpack_require__(102);
    __webpack_require__(99);
    __webpack_require__(105);
    __webpack_require__(104);
    __webpack_require__(126);
    __webpack_require__(129);
    __webpack_require__(127);
    __webpack_require__(128);
    __webpack_require__(131);
    __webpack_require__(130);
    __webpack_require__(133);
    __webpack_require__(132);
    __webpack_require__(293);
    __webpack_require__(294);
    __webpack_require__(295);
    var _editors = __webpack_require__(13);
    var _renderers = __webpack_require__(6);
    var _validators = __webpack_require__(24);
    var _cellTypes = __webpack_require__(65);
    var _core = __webpack_require__(66);
    var _core2 = _interopRequireDefault(_core);
    var _jquery = __webpack_require__(296);
    var _jquery2 = _interopRequireDefault(_jquery);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _pluginHooks = __webpack_require__(11);
    var _pluginHooks2 = _interopRequireDefault(_pluginHooks);
    var _ghostTable = __webpack_require__(69);
    var _ghostTable2 = _interopRequireDefault(_ghostTable);
    var _array = __webpack_require__(2);
    var arrayHelpers = _interopRequireWildcard(_array);
    var _browser = __webpack_require__(22);
    var browserHelpers = _interopRequireWildcard(_browser);
    var _data = __webpack_require__(67);
    var dataHelpers = _interopRequireWildcard(_data);
    var _date = __webpack_require__(89);
    var dateHelpers = _interopRequireWildcard(_date);
    var _feature = __webpack_require__(34);
    var featureHelpers = _interopRequireWildcard(_feature);
    var _function = __webpack_require__(35);
    var functionHelpers = _interopRequireWildcard(_function);
    var _mixed = __webpack_require__(23);
    var mixedHelpers = _interopRequireWildcard(_mixed);
    var _number = __webpack_require__(5);
    var numberHelpers = _interopRequireWildcard(_number);
    var _object = __webpack_require__(3);
    var objectHelpers = _interopRequireWildcard(_object);
    var _setting = __webpack_require__(68);
    var settingHelpers = _interopRequireWildcard(_setting);
    var _string = __webpack_require__(28);
    var stringHelpers = _interopRequireWildcard(_string);
    var _unicode = __webpack_require__(15);
    var unicodeHelpers = _interopRequireWildcard(_unicode);
    var _element = __webpack_require__(0);
    var domHelpers = _interopRequireWildcard(_element);
    var _event = __webpack_require__(7);
    var domEventHelpers = _interopRequireWildcard(_event);
    var _index = __webpack_require__(297);
    var plugins = _interopRequireWildcard(_index);
    var _plugins = __webpack_require__(9);
    var _defaultSettings = __webpack_require__(88);
    var _defaultSettings2 = _interopRequireDefault(_defaultSettings);
    var _rootInstance = __webpack_require__(90);

    function _interopRequireWildcard(obj) {
      if (obj && obj.__esModule) {
        return obj;
      } else {
        var newObj = {};
        if (obj != null) {
          for (var key in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
          }
        }
        newObj.default = obj;
        return newObj;
      }
    }

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function Handsontable(rootElement, userSettings) {
      var instance = new _core2.default(rootElement, userSettings || {}, _rootInstance.rootInstanceSymbol);
      instance.init();
      return instance;
    } (0, _jquery2.default)(Handsontable);
    Handsontable.Core = _core2.default;
    Handsontable.DefaultSettings = _defaultSettings2.default;
    Handsontable.EventManager = _eventManager2.default;
    Handsontable._getListenersCounter = _eventManager.getListenersCounter;
    Handsontable.buildDate = undefined;
    Handsontable.packageName = undefined;
    Handsontable.version = undefined;
    var baseVersion = undefined;
    if (baseVersion) {
      Handsontable.baseVersion = baseVersion;
    }
    Handsontable.hooks = _pluginHooks2.default.getSingleton();
    Handsontable.__GhostTable = _ghostTable2.default;
    var HELPERS = [arrayHelpers, browserHelpers, dataHelpers, dateHelpers, featureHelpers, functionHelpers, mixedHelpers, numberHelpers, objectHelpers, settingHelpers, stringHelpers, unicodeHelpers];
    var DOM = [domHelpers, domEventHelpers];
    Handsontable.helper = {};
    Handsontable.dom = {};
    arrayHelpers.arrayEach(HELPERS, function (helper) {
      arrayHelpers.arrayEach(Object.getOwnPropertyNames(helper), function (key) {
        if (key.charAt(0) !== '_') {
          Handsontable.helper[key] = helper[key];
        }
      });
    });
    arrayHelpers.arrayEach(DOM, function (helper) {
      arrayHelpers.arrayEach(Object.getOwnPropertyNames(helper), function (key) {
        if (key.charAt(0) !== '_') {
          Handsontable.dom[key] = helper[key];
        }
      });
    });
    Handsontable.cellTypes = {};
    arrayHelpers.arrayEach((0, _cellTypes.getRegisteredCellTypeNames)(), function (cellTypeName) {
      Handsontable.cellTypes[cellTypeName] = (0, _cellTypes.getCellType)(cellTypeName);
    });
    Handsontable.cellTypes.registerCellType = _cellTypes.registerCellType;
    Handsontable.cellTypes.getCellType = _cellTypes.getCellType;
    Handsontable.editors = {};
    arrayHelpers.arrayEach((0, _editors.getRegisteredEditorNames)(), function (editorName) {
      Handsontable.editors[stringHelpers.toUpperCaseFirst(editorName) + 'Editor'] = (0, _editors.getEditor)(editorName);
    });
    Handsontable.editors.registerEditor = _editors.registerEditor;
    Handsontable.editors.getEditor = _editors.getEditor;
    Handsontable.renderers = {};
    arrayHelpers.arrayEach((0, _renderers.getRegisteredRendererNames)(), function (rendererName) {
      var renderer = (0, _renderers.getRenderer)(rendererName);
      if (rendererName === 'base') {
        Handsontable.renderers.cellDecorator = renderer;
      }
      Handsontable.renderers[stringHelpers.toUpperCaseFirst(rendererName) + 'Renderer'] = renderer;
    });
    Handsontable.renderers.registerRenderer = _renderers.registerRenderer;
    Handsontable.renderers.getRenderer = _renderers.getRenderer;
    Handsontable.validators = {};
    arrayHelpers.arrayEach((0, _validators.getRegisteredValidatorNames)(), function (validatorName) {
      Handsontable.validators[stringHelpers.toUpperCaseFirst(validatorName) + 'Validator'] = (0, _validators.getValidator)(validatorName);
    });
    Handsontable.validators.registerValidator = _validators.registerValidator;
    Handsontable.validators.getValidator = _validators.getValidator;
    Handsontable.plugins = {};
    arrayHelpers.arrayEach(Object.getOwnPropertyNames(plugins), function (pluginName) {
      var plugin = plugins[pluginName];
      if (pluginName === 'Base') {
        Handsontable.plugins[pluginName + 'Plugin'] = plugin;
      } else {
        Handsontable.plugins[pluginName] = plugin;
      }
    });
    Handsontable.plugins.registerPlugin = _plugins.registerPlugin;
    module.exports = Handsontable;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _array = __webpack_require__(2);
    var _object = __webpack_require__(3);
    var MIXIN_NAME = 'localHooks';
    var localHooks = {
      _localHooks: Object.create(null),
      addLocalHook: function addLocalHook(key, callback) {
        if (!this._localHooks[key]) {
          this._localHooks[key] = [];
        }
        this._localHooks[key].push(callback);
      },
      runLocalHooks: function runLocalHooks(key) {
        var _this = this;
        for (var _len = arguments.length, params = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
          params[_key - 1] = arguments[_key];
        }
        if (this._localHooks[key]) {
          (0, _array.arrayEach)(this._localHooks[key], function (callback) {
            return callback.apply(_this, params);
          });
        }
      },
      clearLocalHooks: function clearLocalHooks() {
        this._localHooks = {};
      }
    };
    (0, _object.defineGetter)(localHooks, 'MIXIN_NAME', MIXIN_NAME, {
      writable: false,
      enumerable: false
    });
    exports.default = localHooks;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
      return typeof obj;
    } : function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };

    function MultiMap() {
      var map = {
        arrayMap: [],
        weakMap: new WeakMap()
      };
      return {
        get: function get(key) {
          if (canBeAnArrayMapKey(key)) {
            return map.arrayMap[key];
          } else if (canBeAWeakMapKey(key)) {
            return map.weakMap.get(key);
          }
        },
        set: function set(key, value) {
          if (canBeAnArrayMapKey(key)) {
            map.arrayMap[key] = value;
          } else if (canBeAWeakMapKey(key)) {
            map.weakMap.set(key, value);
          } else {
            throw new Error('Invalid key type');
          }
        },
        delete: function _delete(key) {
          if (canBeAnArrayMapKey(key)) {
            delete map.arrayMap[key];
          } else if (canBeAWeakMapKey(key)) {
            map.weakMap.delete(key);
          }
        }
      };

      function canBeAnArrayMapKey(obj) {
        return obj !== null && !isNaNSymbol(obj) && (typeof obj == 'string' || typeof obj == 'number');
      }

      function canBeAWeakMapKey(obj) {
        return obj !== null && ((typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) == 'object' || typeof obj == 'function');
      }

      function isNaNSymbol(obj) {
        return obj !== obj;
      }
    }
    exports.default = MultiMap;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _slicedToArray = function () {
      function sliceIterator(arr, i) {
        var _arr = [];
        var _n = true;
        var _d = false;
        var _e = undefined;
        try {
          for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
            _arr.push(_s.value);
            if (i && _arr.length === i) break;
          }
        } catch (err) {
          _d = true;
          _e = err;
        } finally {
          try {
            if (!_n && _i["return"]) _i["return"]();
          } finally {
            if (_d) throw _e;
          }
        }
        return _arr;
      }
      return function (arr, i) {
        if (Array.isArray(arr)) {
          return arr;
        } else if (Symbol.iterator in Object(arr)) {
          return sliceIterator(arr, i);
        } else {
          throw new TypeError("Invalid attempt to destructure non-iterable instance");
        }
      };
    }();
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _base = __webpack_require__(16);
    var _base2 = _interopRequireDefault(_base);
    var _array = __webpack_require__(2);
    var _feature = __webpack_require__(34);
    var _element = __webpack_require__(0);
    var _ghostTable = __webpack_require__(69);
    var _ghostTable2 = _interopRequireDefault(_ghostTable);
    var _object = __webpack_require__(3);
    var _number = __webpack_require__(5);
    var _plugins = __webpack_require__(9);
    var _samplesGenerator = __webpack_require__(269);
    var _samplesGenerator2 = _interopRequireDefault(_samplesGenerator);
    var _string = __webpack_require__(28);
    var _src = __webpack_require__(14);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var privatePool = new WeakMap();
    var AutoColumnSize = function (_BasePlugin) {
      _inherits(AutoColumnSize, _BasePlugin);
      _createClass(AutoColumnSize, null, [{
        key: 'CALCULATION_STEP',
        get: function get() {
          return 50;
        }
      }, {
        key: 'SYNC_CALCULATION_LIMIT',
        get: function get() {
          return 50;
        }
      }]);

      function AutoColumnSize(hotInstance) {
        _classCallCheck(this, AutoColumnSize);
        var _this = _possibleConstructorReturn(this, (AutoColumnSize.__proto__ || Object.getPrototypeOf(AutoColumnSize)).call(this, hotInstance));
        privatePool.set(_this, {
          cachedColumnHeaders: []
        });
        _this.widths = [];
        _this.ghostTable = new _ghostTable2.default(_this.hot);
        _this.samplesGenerator = new _samplesGenerator2.default(function (row, col) {
          return _this.hot.getDataAtCell(row, col);
        });
        _this.firstCalculation = true;
        _this.inProgress = false;
        _this.addHook('beforeColumnResize', function (col, size, isDblClick) {
          return _this.onBeforeColumnResize(col, size, isDblClick);
        });
        return _this;
      }
      _createClass(AutoColumnSize, [{
        key: 'isEnabled',
        value: function isEnabled() {
          return this.hot.getSettings().autoColumnSize !== false && !this.hot.getSettings().colWidths;
        }
      }, {
        key: 'enablePlugin',
        value: function enablePlugin() {
          var _this2 = this;
          if (this.enabled) {
            return;
          }
          var setting = this.hot.getSettings().autoColumnSize;
          if (setting && setting.useHeaders != null) {
            this.ghostTable.setSetting('useHeaders', setting.useHeaders);
          }
          this.addHook('afterLoadData', function () {
            return _this2.onAfterLoadData();
          });
          this.addHook('beforeChange', function (changes) {
            return _this2.onBeforeChange(changes);
          });
          this.addHook('beforeRender', function (force) {
            return _this2.onBeforeRender(force);
          });
          this.addHook('modifyColWidth', function (width, col) {
            return _this2.getColumnWidth(col, width);
          });
          this.addHook('afterInit', function () {
            return _this2.onAfterInit();
          });
          _get(AutoColumnSize.prototype.__proto__ || Object.getPrototypeOf(AutoColumnSize.prototype), 'enablePlugin', this).call(this);
        }
      }, {
        key: 'updatePlugin',
        value: function updatePlugin() {
          var changedColumns = this.findColumnsWhereHeaderWasChanged();
          if (changedColumns.length) {
            this.clearCache(changedColumns);
          }
          _get(AutoColumnSize.prototype.__proto__ || Object.getPrototypeOf(AutoColumnSize.prototype), 'updatePlugin', this).call(this);
        }
      }, {
        key: 'disablePlugin',
        value: function disablePlugin() {
          _get(AutoColumnSize.prototype.__proto__ || Object.getPrototypeOf(AutoColumnSize.prototype), 'disablePlugin', this).call(this);
        }
      }, {
        key: 'calculateColumnsWidth',
        value: function calculateColumnsWidth() {
          var colRange = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
            from: 0,
            to: this.hot.countCols() - 1
          };
          var _this3 = this;
          var rowRange = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
            from: 0,
            to: this.hot.countRows() - 1
          };
          var force = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
          if (typeof colRange === 'number') {
            colRange = {
              from: colRange,
              to: colRange
            };
          }
          if (typeof rowRange === 'number') {
            rowRange = {
              from: rowRange,
              to: rowRange
            };
          } (0, _number.rangeEach)(colRange.from, colRange.to, function (col) {
            if (force || _this3.widths[col] === void 0 && !_this3.hot._getColWidthFromSettings(col)) {
              var samples = _this3.samplesGenerator.generateColumnSamples(col, rowRange);
              samples.forEach(function (sample, col) {
                return _this3.ghostTable.addColumn(col, sample);
              });
            }
          });
          if (this.ghostTable.columns.length) {
            this.ghostTable.getWidths(function (col, width) {
              _this3.widths[col] = width;
            });
            this.ghostTable.clean();
          }
        }
      }, {
        key: 'calculateAllColumnsWidth',
        value: function calculateAllColumnsWidth() {
          var _this4 = this;
          var rowRange = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
            from: 0,
            to: this.hot.countRows() - 1
          };
          var current = 0;
          var length = this.hot.countCols() - 1;
          var timer = null;
          this.inProgress = true;
          var loop = function loop() {
            if (!_this4.hot) {
              (0, _feature.cancelAnimationFrame)(timer);
              _this4.inProgress = false;
              return;
            }
            _this4.calculateColumnsWidth({
              from: current,
              to: Math.min(current + AutoColumnSize.CALCULATION_STEP, length)
            }, rowRange);
            current = current + AutoColumnSize.CALCULATION_STEP + 1;
            if (current < length) {
              timer = (0, _feature.requestAnimationFrame)(loop);
            } else {
              (0, _feature.cancelAnimationFrame)(timer);
              _this4.inProgress = false;
              _this4.hot.view.wt.wtOverlays.adjustElementsSize(true);
              if (_this4.hot.view.wt.wtOverlays.leftOverlay.needFullRender) {
                _this4.hot.view.wt.wtOverlays.leftOverlay.clone.draw();
              }
            }
          };
          if (this.firstCalculation && this.getSyncCalculationLimit()) {
            this.calculateColumnsWidth({
              from: 0,
              to: this.getSyncCalculationLimit()
            }, rowRange);
            this.firstCalculation = false;
            current = this.getSyncCalculationLimit() + 1;
          }
          if (current < length) {
            loop();
          } else {
            this.inProgress = false;
          }
        }
      }, {
        key: 'setSamplingOptions',
        value: function setSamplingOptions() {
          var setting = this.hot.getSettings().autoColumnSize;
          var samplingRatio = setting && (0, _object.hasOwnProperty)(setting, 'samplingRatio') ? this.hot.getSettings().autoColumnSize.samplingRatio : void 0;
          var allowSampleDuplicates = setting && (0, _object.hasOwnProperty)(setting, 'allowSampleDuplicates') ? this.hot.getSettings().autoColumnSize.allowSampleDuplicates : void 0;
          if (samplingRatio && !isNaN(samplingRatio)) {
            this.samplesGenerator.setSampleCount(parseInt(samplingRatio, 10));
          }
          if (allowSampleDuplicates) {
            this.samplesGenerator.setAllowDuplicates(allowSampleDuplicates);
          }
        }
      }, {
        key: 'recalculateAllColumnsWidth',
        value: function recalculateAllColumnsWidth() {
          if (this.hot.view && (0, _element.isVisible)(this.hot.view.wt.wtTable.TABLE)) {
            this.clearCache();
            this.calculateAllColumnsWidth();
          }
        }
      }, {
        key: 'getSyncCalculationLimit',
        value: function getSyncCalculationLimit() {
          var limit = AutoColumnSize.SYNC_CALCULATION_LIMIT;
          var colsLimit = this.hot.countCols() - 1;
          if ((0, _object.isObject)(this.hot.getSettings().autoColumnSize)) {
            limit = this.hot.getSettings().autoColumnSize.syncLimit;
            if ((0, _string.isPercentValue)(limit)) {
              limit = (0, _number.valueAccordingPercent)(colsLimit, limit);
            } else {
              limit >>= 0;
            }
          }
          return Math.min(limit, colsLimit);
        }
      }, {
        key: 'getColumnWidth',
        value: function getColumnWidth(col) {
          var defaultWidth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : void 0;
          var keepMinimum = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
          var width = defaultWidth;
          if (width === void 0) {
            width = this.widths[col];
            if (keepMinimum && typeof width === 'number') {
              width = Math.max(width, _src.ViewportColumnsCalculator.DEFAULT_WIDTH);
            }
          }
          return width;
        }
      }, {
        key: 'getFirstVisibleColumn',
        value: function getFirstVisibleColumn() {
          var wot = this.hot.view.wt;
          if (wot.wtViewport.columnsVisibleCalculator) {
            return wot.wtTable.getFirstVisibleColumn();
          }
          if (wot.wtViewport.columnsRenderCalculator) {
            return wot.wtTable.getFirstRenderedColumn();
          }
          return -1;
        }
      }, {
        key: 'getLastVisibleColumn',
        value: function getLastVisibleColumn() {
          var wot = this.hot.view.wt;
          if (wot.wtViewport.columnsVisibleCalculator) {
            return wot.wtTable.getLastVisibleColumn();
          }
          if (wot.wtViewport.columnsRenderCalculator) {
            return wot.wtTable.getLastRenderedColumn();
          }
          return -1;
        }
      }, {
        key: 'findColumnsWhereHeaderWasChanged',
        value: function findColumnsWhereHeaderWasChanged() {
          var columnHeaders = this.hot.getColHeader();
          var _privatePool$get = privatePool.get(this),
            cachedColumnHeaders = _privatePool$get.cachedColumnHeaders;
          var changedColumns = (0, _array.arrayReduce)(columnHeaders, function (acc, columnTitle, physicalColumn) {
            var cachedColumnsLength = cachedColumnHeaders.length;
            if (cachedColumnsLength - 1 < physicalColumn || cachedColumnHeaders[physicalColumn] !== columnTitle) {
              acc.push(physicalColumn);
            }
            if (cachedColumnsLength - 1 < physicalColumn) {
              cachedColumnHeaders.push(columnTitle);
            } else {
              cachedColumnHeaders[physicalColumn] = columnTitle;
            }
            return acc;
          }, []);
          return changedColumns;
        }
      }, {
        key: 'clearCache',
        value: function clearCache() {
          var _this5 = this;
          var columns = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
          if (columns.length) {
            (0, _array.arrayEach)(columns, function (physicalIndex) {
              _this5.widths[physicalIndex] = void 0;
            });
          } else {
            this.widths.length = 0;
          }
        }
      }, {
        key: 'isNeedRecalculate',
        value: function isNeedRecalculate() {
          return !!(0, _array.arrayFilter)(this.widths, function (item) {
            return item === void 0;
          }).length;
        }
      }, {
        key: 'onBeforeRender',
        value: function onBeforeRender() {
          var force = this.hot.renderCall;
          var rowsCount = this.hot.countRows();
          if (!rowsCount) {
            return;
          }
          this.calculateColumnsWidth({
            from: this.getFirstVisibleColumn(),
            to: this.getLastVisibleColumn()
          }, void 0, force);
          if (this.isNeedRecalculate() && !this.inProgress) {
            this.calculateAllColumnsWidth();
          }
        }
      }, {
        key: 'onAfterLoadData',
        value: function onAfterLoadData() {
          var _this6 = this;
          if (this.hot.view) {
            this.recalculateAllColumnsWidth();
          } else {
            setTimeout(function () {
              if (_this6.hot) {
                _this6.recalculateAllColumnsWidth();
              }
            }, 0);
          }
        }
      }, {
        key: 'onBeforeChange',
        value: function onBeforeChange(changes) {
          var _this7 = this;
          var changedColumns = (0, _array.arrayMap)(changes, function (_ref) {
            var _ref2 = _slicedToArray(_ref, 2),
              row = _ref2[0],
              column = _ref2[1];
            return _this7.hot.propToCol(column);
          });
          this.clearCache(changedColumns);
        }
      }, {
        key: 'onBeforeColumnResize',
        value: function onBeforeColumnResize(col, size, isDblClick) {
          if (isDblClick) {
            this.calculateColumnsWidth(col, void 0, true);
            size = this.getColumnWidth(col, void 0, false);
          }
          return size;
        }
      }, {
        key: 'onAfterInit',
        value: function onAfterInit() {
          privatePool.get(this).cachedColumnHeaders = this.hot.getColHeader();
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          this.ghostTable.clean();
          _get(AutoColumnSize.prototype.__proto__ || Object.getPrototypeOf(AutoColumnSize.prototype), 'destroy', this).call(this);
        }
      }]);
      return AutoColumnSize;
    }(_base2.default);
    (0, _plugins.registerPlugin)('autoColumnSize', AutoColumnSize);
    exports.default = AutoColumnSize;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _base = __webpack_require__(16);
    var _base2 = _interopRequireDefault(_base);
    var _array = __webpack_require__(2);
    var _feature = __webpack_require__(34);
    var _element = __webpack_require__(0);
    var _ghostTable = __webpack_require__(69);
    var _ghostTable2 = _interopRequireDefault(_ghostTable);
    var _object = __webpack_require__(3);
    var _number = __webpack_require__(5);
    var _plugins = __webpack_require__(9);
    var _samplesGenerator = __webpack_require__(269);
    var _samplesGenerator2 = _interopRequireDefault(_samplesGenerator);
    var _string = __webpack_require__(28);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var AutoRowSize = function (_BasePlugin) {
      _inherits(AutoRowSize, _BasePlugin);
      _createClass(AutoRowSize, null, [{
        key: 'CALCULATION_STEP',
        get: function get() {
          return 50;
        }
      }, {
        key: 'SYNC_CALCULATION_LIMIT',
        get: function get() {
          return 500;
        }
      }]);

      function AutoRowSize(hotInstance) {
        _classCallCheck(this, AutoRowSize);
        var _this = _possibleConstructorReturn(this, (AutoRowSize.__proto__ || Object.getPrototypeOf(AutoRowSize)).call(this, hotInstance));
        _this.heights = [];
        _this.ghostTable = new _ghostTable2.default(_this.hot);
        _this.samplesGenerator = new _samplesGenerator2.default(function (row, col) {
          if (row >= 0) {
            return _this.hot.getDataAtCell(row, col);
          } else if (row === -1) {
            return _this.hot.getColHeader(col);
          }
          return null;
        });
        _this.firstCalculation = true;
        _this.inProgress = false;
        _this.addHook('beforeRowResize', function (row, size, isDblClick) {
          return _this.onBeforeRowResize(row, size, isDblClick);
        });
        return _this;
      }
      _createClass(AutoRowSize, [{
        key: 'isEnabled',
        value: function isEnabled() {
          return this.hot.getSettings().autoRowSize === true || (0, _object.isObject)(this.hot.getSettings().autoRowSize);
        }
      }, {
        key: 'enablePlugin',
        value: function enablePlugin() {
          var _this2 = this;
          if (this.enabled) {
            return;
          }
          this.setSamplingOptions();
          this.addHook('afterLoadData', function () {
            return _this2.onAfterLoadData();
          });
          this.addHook('beforeChange', function (changes) {
            return _this2.onBeforeChange(changes);
          });
          this.addHook('beforeColumnMove', function () {
            return _this2.recalculateAllRowsHeight();
          });
          this.addHook('beforeColumnResize', function () {
            return _this2.recalculateAllRowsHeight();
          });
          this.addHook('beforeColumnSort', function () {
            return _this2.clearCache();
          });
          this.addHook('beforeRender', function (force) {
            return _this2.onBeforeRender(force);
          });
          this.addHook('beforeRowMove', function (rowStart, rowEnd) {
            return _this2.onBeforeRowMove(rowStart, rowEnd);
          });
          this.addHook('modifyRowHeight', function (height, row) {
            return _this2.getRowHeight(row, height);
          });
          this.addHook('modifyColumnHeaderHeight', function () {
            return _this2.getColumnHeaderHeight();
          });
          _get(AutoRowSize.prototype.__proto__ || Object.getPrototypeOf(AutoRowSize.prototype), 'enablePlugin', this).call(this);
        }
      }, {
        key: 'disablePlugin',
        value: function disablePlugin() {
          _get(AutoRowSize.prototype.__proto__ || Object.getPrototypeOf(AutoRowSize.prototype), 'disablePlugin', this).call(this);
        }
      }, {
        key: 'calculateRowsHeight',
        value: function calculateRowsHeight() {
          var rowRange = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
            from: 0,
            to: this.hot.countRows() - 1
          };
          var _this3 = this;
          var colRange = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
            from: 0,
            to: this.hot.countCols() - 1
          };
          var force = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
          if (typeof rowRange === 'number') {
            rowRange = {
              from: rowRange,
              to: rowRange
            };
          }
          if (typeof colRange === 'number') {
            colRange = {
              from: colRange,
              to: colRange
            };
          }
          if (this.hot.getColHeader(0) !== null) {
            var samples = this.samplesGenerator.generateRowSamples(-1, colRange);
            this.ghostTable.addColumnHeadersRow(samples.get(-1));
          } (0, _number.rangeEach)(rowRange.from, rowRange.to, function (row) {
            if (force || _this3.heights[row] === void 0) {
              var _samples = _this3.samplesGenerator.generateRowSamples(row, colRange);
              _samples.forEach(function (sample, row) {
                _this3.ghostTable.addRow(row, sample);
              });
            }
          });
          if (this.ghostTable.rows.length) {
            this.ghostTable.getHeights(function (row, height) {
              _this3.heights[row] = height;
            });
            this.ghostTable.clean();
          }
        }
      }, {
        key: 'calculateAllRowsHeight',
        value: function calculateAllRowsHeight() {
          var _this4 = this;
          var colRange = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
            from: 0,
            to: this.hot.countCols() - 1
          };
          var current = 0;
          var length = this.hot.countRows() - 1;
          var timer = null;
          this.inProgress = true;
          var loop = function loop() {
            if (!_this4.hot) {
              (0, _feature.cancelAnimationFrame)(timer);
              _this4.inProgress = false;
              return;
            }
            _this4.calculateRowsHeight({
              from: current,
              to: Math.min(current + AutoRowSize.CALCULATION_STEP, length)
            }, colRange);
            current = current + AutoRowSize.CALCULATION_STEP + 1;
            if (current < length) {
              timer = (0, _feature.requestAnimationFrame)(loop);
            } else {
              (0, _feature.cancelAnimationFrame)(timer);
              _this4.inProgress = false;
              _this4.hot.view.wt.wtOverlays.adjustElementsSize(true);
              if (_this4.hot.view.wt.wtOverlays.leftOverlay.needFullRender) {
                _this4.hot.view.wt.wtOverlays.leftOverlay.clone.draw();
              }
            }
          };
          if (this.firstCalculation && this.getSyncCalculationLimit()) {
            this.calculateRowsHeight({
              from: 0,
              to: this.getSyncCalculationLimit()
            }, colRange);
            this.firstCalculation = false;
            current = this.getSyncCalculationLimit() + 1;
          }
          if (current < length) {
            loop();
          } else {
            this.inProgress = false;
            this.hot.view.wt.wtOverlays.adjustElementsSize(false);
          }
        }
      }, {
        key: 'setSamplingOptions',
        value: function setSamplingOptions() {
          var setting = this.hot.getSettings().autoRowSize;
          var samplingRatio = setting && (0, _object.hasOwnProperty)(setting, 'samplingRatio') ? this.hot.getSettings().autoRowSize.samplingRatio : void 0;
          var allowSampleDuplicates = setting && (0, _object.hasOwnProperty)(setting, 'allowSampleDuplicates') ? this.hot.getSettings().autoRowSize.allowSampleDuplicates : void 0;
          if (samplingRatio && !isNaN(samplingRatio)) {
            this.samplesGenerator.setSampleCount(parseInt(samplingRatio, 10));
          }
          if (allowSampleDuplicates) {
            this.samplesGenerator.setAllowDuplicates(allowSampleDuplicates);
          }
        }
      }, {
        key: 'recalculateAllRowsHeight',
        value: function recalculateAllRowsHeight() {
          if ((0, _element.isVisible)(this.hot.view.wt.wtTable.TABLE)) {
            this.clearCache();
            this.calculateAllRowsHeight();
          }
        }
      }, {
        key: 'getSyncCalculationLimit',
        value: function getSyncCalculationLimit() {
          var limit = AutoRowSize.SYNC_CALCULATION_LIMIT;
          var rowsLimit = this.hot.countRows() - 1;
          if ((0, _object.isObject)(this.hot.getSettings().autoRowSize)) {
            limit = this.hot.getSettings().autoRowSize.syncLimit;
            if ((0, _string.isPercentValue)(limit)) {
              limit = (0, _number.valueAccordingPercent)(rowsLimit, limit);
            } else {
              limit >>= 0;
            }
          }
          return Math.min(limit, rowsLimit);
        }
      }, {
        key: 'getRowHeight',
        value: function getRowHeight(row) {
          var defaultHeight = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : void 0;
          var height = defaultHeight;
          if (this.heights[row] !== void 0 && this.heights[row] > (defaultHeight || 0)) {
            height = this.heights[row];
          }
          return height;
        }
      }, {
        key: 'getColumnHeaderHeight',
        value: function getColumnHeaderHeight() {
          return this.heights[-1];
        }
      }, {
        key: 'getFirstVisibleRow',
        value: function getFirstVisibleRow() {
          var wot = this.hot.view.wt;
          if (wot.wtViewport.rowsVisibleCalculator) {
            return wot.wtTable.getFirstVisibleRow();
          }
          if (wot.wtViewport.rowsRenderCalculator) {
            return wot.wtTable.getFirstRenderedRow();
          }
          return -1;
        }
      }, {
        key: 'getLastVisibleRow',
        value: function getLastVisibleRow() {
          var wot = this.hot.view.wt;
          if (wot.wtViewport.rowsVisibleCalculator) {
            return wot.wtTable.getLastVisibleRow();
          }
          if (wot.wtViewport.rowsRenderCalculator) {
            return wot.wtTable.getLastRenderedRow();
          }
          return -1;
        }
      }, {
        key: 'clearCache',
        value: function clearCache() {
          this.heights.length = 0;
          this.heights[-1] = void 0;
        }
      }, {
        key: 'clearCacheByRange',
        value: function clearCacheByRange(range) {
          var _this5 = this;
          if (typeof range === 'number') {
            range = {
              from: range,
              to: range
            };
          } (0, _number.rangeEach)(Math.min(range.from, range.to), Math.max(range.from, range.to), function (row) {
            _this5.heights[row] = void 0;
          });
        }
      }, {
        key: 'isNeedRecalculate',
        value: function isNeedRecalculate() {
          return !!(0, _array.arrayFilter)(this.heights, function (item) {
            return item === void 0;
          }).length;
        }
      }, {
        key: 'onBeforeRender',
        value: function onBeforeRender() {
          var force = this.hot.renderCall;
          this.calculateRowsHeight({
            from: this.getFirstVisibleRow(),
            to: this.getLastVisibleRow()
          }, void 0, force);
          var fixedRowsBottom = this.hot.getSettings().fixedRowsBottom;
          if (fixedRowsBottom) {
            var totalRows = this.hot.countRows() - 1;
            this.calculateRowsHeight({
              from: totalRows - fixedRowsBottom,
              to: totalRows
            });
          }
          if (this.isNeedRecalculate() && !this.inProgress) {
            this.calculateAllRowsHeight();
          }
        }
      }, {
        key: 'onBeforeRowMove',
        value: function onBeforeRowMove(from, to) {
          this.clearCacheByRange({
            from: from,
            to: to
          });
          this.calculateAllRowsHeight();
        }
      }, {
        key: 'onBeforeRowResize',
        value: function onBeforeRowResize(row, size, isDblClick) {
          if (isDblClick) {
            this.calculateRowsHeight(row, void 0, true);
            size = this.getRowHeight(row);
          }
          return size;
        }
      }, {
        key: 'onAfterLoadData',
        value: function onAfterLoadData() {
          var _this6 = this;
          if (this.hot.view) {
            this.recalculateAllRowsHeight();
          } else {
            setTimeout(function () {
              if (_this6.hot) {
                _this6.recalculateAllRowsHeight();
              }
            }, 0);
          }
        }
      }, {
        key: 'onBeforeChange',
        value: function onBeforeChange(changes) {
          var range = null;
          if (changes.length === 1) {
            range = changes[0][0];
          } else if (changes.length > 1) {
            range = {
              from: changes[0][0],
              to: changes[changes.length - 1][0]
            };
          }
          if (range !== null) {
            this.clearCacheByRange(range);
          }
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          this.ghostTable.clean();
          _get(AutoRowSize.prototype.__proto__ || Object.getPrototypeOf(AutoRowSize.prototype), 'destroy', this).call(this);
        }
      }]);
      return AutoRowSize;
    }(_base2.default);
    (0, _plugins.registerPlugin)('autoRowSize', AutoRowSize);
    exports.default = AutoRowSize;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _base = __webpack_require__(16);
    var _base2 = _interopRequireDefault(_base);
    var _pluginHooks = __webpack_require__(11);
    var _pluginHooks2 = _interopRequireDefault(_pluginHooks);
    var _element = __webpack_require__(0);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _plugins = __webpack_require__(9);
    var _src = __webpack_require__(14);
    var _utils = __webpack_require__(338);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    _pluginHooks2.default.getSingleton().register('modifyAutofillRange');
    _pluginHooks2.default.getSingleton().register('beforeAutofill');
    var INSERT_ROW_ALTER_ACTION_NAME = 'insert_row';
    var INSERT_COLUMN_ALTER_ACTION_NAME = 'insert_col';
    var INTERVAL_FOR_ADDING_ROW = 200;
    var Autofill = function (_BasePlugin) {
      _inherits(Autofill, _BasePlugin);

      function Autofill(hotInstance) {
        _classCallCheck(this, Autofill);
        var _this = _possibleConstructorReturn(this, (Autofill.__proto__ || Object.getPrototypeOf(Autofill)).call(this, hotInstance));
        _this.eventManager = new _eventManager2.default(_this);
        _this.addingStarted = false;
        _this.mouseDownOnCellCorner = false;
        _this.mouseDragOutside = false;
        _this.handleDraggedCells = 0;
        _this.directions = [];
        _this.autoInsertRow = false;
        return _this;
      }
      _createClass(Autofill, [{
        key: 'isEnabled',
        value: function isEnabled() {
          return this.hot.getSettings().fillHandle;
        }
      }, {
        key: 'enablePlugin',
        value: function enablePlugin() {
          var _this2 = this;
          if (this.enabled) {
            return;
          }
          this.mapSettings();
          this.registerEvents();
          this.addHook('afterOnCellCornerMouseDown', function (event) {
            return _this2.onAfterCellCornerMouseDown(event);
          });
          this.addHook('afterOnCellCornerDblClick', function (event) {
            return _this2.onCellCornerDblClick(event);
          });
          this.addHook('beforeOnCellMouseOver', function (event, coords, TD) {
            return _this2.onBeforeCellMouseOver(coords);
          });
          _get(Autofill.prototype.__proto__ || Object.getPrototypeOf(Autofill.prototype), 'enablePlugin', this).call(this);
        }
      }, {
        key: 'updatePlugin',
        value: function updatePlugin() {
          this.disablePlugin();
          this.enablePlugin();
          _get(Autofill.prototype.__proto__ || Object.getPrototypeOf(Autofill.prototype), 'updatePlugin', this).call(this);
        }
      }, {
        key: 'disablePlugin',
        value: function disablePlugin() {
          this.clearMappedSettings();
          _get(Autofill.prototype.__proto__ || Object.getPrototypeOf(Autofill.prototype), 'disablePlugin', this).call(this);
        }
      }, {
        key: 'getSelectionData',
        value: function getSelectionData() {
          var selRange = {
            from: this.hot.getSelectedRange().from,
            to: this.hot.getSelectedRange().to
          };
          return this.hot.getData(selRange.from.row, selRange.from.col, selRange.to.row, selRange.to.col);
        }
      }, {
        key: 'fillIn',
        value: function fillIn() {
          if (this.hot.view.wt.selections.fill.isEmpty()) {
            return false;
          }
          var cornersOfSelectionAndDragAreas = this.hot.view.wt.selections.fill.getCorners();
          this.resetSelectionOfDraggedArea();
          var cornersOfSelectedCells = this.getCornersOfSelectedCells();
          var _getDragDirectionAndR = (0, _utils.getDragDirectionAndRange)(cornersOfSelectedCells, cornersOfSelectionAndDragAreas),
            directionOfDrag = _getDragDirectionAndR.directionOfDrag,
            startOfDragCoords = _getDragDirectionAndR.startOfDragCoords,
            endOfDragCoords = _getDragDirectionAndR.endOfDragCoords;
          this.hot.runHooks('modifyAutofillRange', cornersOfSelectedCells, cornersOfSelectionAndDragAreas);
          if (startOfDragCoords && startOfDragCoords.row > -1 && startOfDragCoords.col > -1) {
            var selectionData = this.getSelectionData();
            var deltas = (0, _utils.getDeltas)(startOfDragCoords, endOfDragCoords, selectionData, directionOfDrag);
            var fillData = selectionData;
            this.hot.runHooks('beforeAutofill', startOfDragCoords, endOfDragCoords, selectionData);
            if (['up', 'left'].indexOf(directionOfDrag) > -1) {
              fillData = [];
              var dragLength = null;
              var fillOffset = null;
              if (directionOfDrag === 'up') {
                dragLength = endOfDragCoords.row - startOfDragCoords.row + 1;
                fillOffset = dragLength % selectionData.length;
                for (var i = 0; i < dragLength; i++) {
                  fillData.push(selectionData[(i + (selectionData.length - fillOffset)) % selectionData.length]);
                }
              } else {
                dragLength = endOfDragCoords.col - startOfDragCoords.col + 1;
                fillOffset = dragLength % selectionData[0].length;
                for (var _i = 0; _i < selectionData.length; _i++) {
                  fillData.push([]);
                  for (var j = 0; j < dragLength; j++) {
                    fillData[_i].push(selectionData[_i][(j + (selectionData[_i].length - fillOffset)) % selectionData[_i].length]);
                  }
                }
              }
            }
            this.hot.populateFromArray(startOfDragCoords.row, startOfDragCoords.col, fillData, endOfDragCoords.row, endOfDragCoords.col, this.pluginName + '.fill', null, directionOfDrag, deltas);
            this.setSelection(cornersOfSelectionAndDragAreas);
          } else {
            this.hot.selection.refreshBorders();
          }
          return true;
        }
      }, {
        key: 'reduceSelectionAreaIfNeeded',
        value: function reduceSelectionAreaIfNeeded(coords) {
          if (coords.row < 0) {
            coords.row = 0;
          }
          if (coords.col < 0) {
            coords.col = 0;
          }
          return coords;
        }
      }, {
        key: 'getCoordsOfDragAndDropBorders',
        value: function getCoordsOfDragAndDropBorders(coordsOfSelection) {
          var topLeftCorner = this.hot.getSelectedRange().getTopLeftCorner();
          var bottomRightCorner = this.hot.getSelectedRange().getBottomRightCorner();
          var coords = void 0;
          if (this.directions.includes(_utils.DIRECTIONS.vertical) && (bottomRightCorner.row < coordsOfSelection.row || topLeftCorner.row > coordsOfSelection.row)) {
            coords = new _src.CellCoords(coordsOfSelection.row, bottomRightCorner.col);
          } else if (this.directions.includes(_utils.DIRECTIONS.horizontal)) {
            coords = new _src.CellCoords(bottomRightCorner.row, coordsOfSelection.col);
          } else {
            return;
          }
          return this.reduceSelectionAreaIfNeeded(coords);
        }
      }, {
        key: 'showBorder',
        value: function showBorder(coordsOfSelection) {
          var coordsOfDragAndDropBorders = this.getCoordsOfDragAndDropBorders(coordsOfSelection);
          if (coordsOfDragAndDropBorders) {
            this.redrawBorders(coordsOfDragAndDropBorders);
          }
        }
      }, {
        key: 'addRow',
        value: function addRow() {
          var _this3 = this;
          this.hot._registerTimeout(setTimeout(function () {
            _this3.hot.alter(INSERT_ROW_ALTER_ACTION_NAME, void 0, 1, _this3.pluginName + '.fill');
            _this3.addingStarted = false;
          }, INTERVAL_FOR_ADDING_ROW));
        }
      }, {
        key: 'addColumn',
        value: function addColumn() {
          var _this4 = this;
          this.hot._registerTimeout(setTimeout(function () {
            _this4.hot.alter(INSERT_COLUMN_ALTER_ACTION_NAME, void 0, 1, _this4.pluginName + '.fill');
            _this4.addingStarted = false;
          }, INTERVAL_FOR_ADDING_ROW));
        }
      }, {
        key: 'addNewRowIfNeeded',
        value: function addNewRowIfNeeded() {
          if (this.hot.view.wt.selections.fill.cellRange && this.addingStarted === false && this.autoInsertRow) {
            var cornersOfSelectedCells = this.hot.getSelected();
            var cornersOfSelectedDragArea = this.hot.view.wt.selections.fill.getCorners();
            var nrOfTableRows = this.hot.countRows();
            if (cornersOfSelectedCells[2] < nrOfTableRows - 1 && cornersOfSelectedDragArea[2] === nrOfTableRows - 1) {
              this.addingStarted = true;
              this.addRow();
            }
          }
        }
      }, {
        key: 'addNewColumnIfNeeded',
        value: function addNewColumnIfNeeded() {
          if (this.hot.view.wt.selections.fill.cellRange && this.addingStarted === false && this.autoInsertRow) {
            var cornersOfSelectedCells = this.hot.getSelected();
            var cornersOfSelectedDragArea = this.hot.view.wt.selections.fill.getCorners();
            var nrOfTableCols = this.hot.countCols();
            if (cornersOfSelectedCells[3] < nrOfTableCols - 1 && cornersOfSelectedDragArea[3] === nrOfTableCols - 1) {
              this.addingStarted = true;
              this.addColumn();
            }
          }
        }
      }, {
        key: 'getCornersOfSelectedCells',
        value: function getCornersOfSelectedCells() {
          if (this.hot.selection.isMultiple()) {
            return this.hot.view.wt.selections.area.getCorners();
          }
          return this.hot.view.wt.selections.current.getCorners();
        }
      }, {
        key: 'getIndexOfLastAdjacentFilledInRow',
        value: function getIndexOfLastAdjacentFilledInRow(cornersOfSelectedCells) {
          var data = this.hot.getData();
          var nrOfTableRows = this.hot.countRows();
          var lastFilledInRowIndex = void 0;
          for (var rowIndex = cornersOfSelectedCells[2] + 1; rowIndex < nrOfTableRows; rowIndex++) {
            for (var columnIndex = cornersOfSelectedCells[1]; columnIndex <= cornersOfSelectedCells[3]; columnIndex++) {
              var dataInCell = data[rowIndex][columnIndex];
              if (dataInCell) {
                return -1;
              }
            }
            var dataInNextLeftCell = data[rowIndex][cornersOfSelectedCells[1] - 1];
            var dataInNextRightCell = data[rowIndex][cornersOfSelectedCells[3] + 1];
            if (!!dataInNextLeftCell || !!dataInNextRightCell) {
              lastFilledInRowIndex = rowIndex;
            }
          }
          return lastFilledInRowIndex;
        }
      }, {
        key: 'addSelectionFromStartAreaToSpecificRowIndex',
        value: function addSelectionFromStartAreaToSpecificRowIndex(selectStartArea, rowIndex) {
          this.hot.view.wt.selections.fill.clear();
          this.hot.view.wt.selections.fill.add(new _src.CellCoords(selectStartArea[0], selectStartArea[1]));
          this.hot.view.wt.selections.fill.add(new _src.CellCoords(rowIndex, selectStartArea[3]));
        }
      }, {
        key: 'setSelection',
        value: function setSelection(cornersOfArea) {
          this.hot.selection.setRangeStart(new _src.CellCoords(cornersOfArea[0], cornersOfArea[1]));
          this.hot.selection.setRangeEnd(new _src.CellCoords(cornersOfArea[2], cornersOfArea[3]));
        }
      }, {
        key: 'selectAdjacent',
        value: function selectAdjacent() {
          var cornersOfSelectedCells = this.getCornersOfSelectedCells();
          var lastFilledInRowIndex = this.getIndexOfLastAdjacentFilledInRow(cornersOfSelectedCells);
          if (lastFilledInRowIndex === -1) {
            return false;
          }
          this.addSelectionFromStartAreaToSpecificRowIndex(cornersOfSelectedCells, lastFilledInRowIndex);
          return true;
        }
      }, {
        key: 'resetSelectionOfDraggedArea',
        value: function resetSelectionOfDraggedArea() {
          this.handleDraggedCells = 0;
          this.hot.view.wt.selections.fill.clear();
        }
      }, {
        key: 'redrawBorders',
        value: function redrawBorders(coords) {
          this.hot.view.wt.selections.fill.clear();
          this.hot.view.wt.selections.fill.add(this.hot.getSelectedRange().from);
          this.hot.view.wt.selections.fill.add(this.hot.getSelectedRange().to);
          this.hot.view.wt.selections.fill.add(coords);
          this.hot.view.render();
        }
      }, {
        key: 'getIfMouseWasDraggedOutside',
        value: function getIfMouseWasDraggedOutside(event) {
          var tableBottom = (0, _element.offset)(this.hot.table).top - (window.pageYOffset || document.documentElement.scrollTop) + (0, _element.outerHeight)(this.hot.table);
          var tableRight = (0, _element.offset)(this.hot.table).left - (window.pageXOffset || document.documentElement.scrollLeft) + (0, _element.outerWidth)(this.hot.table);
          return event.clientY > tableBottom && event.clientX <= tableRight;
        }
      }, {
        key: 'registerEvents',
        value: function registerEvents() {
          var _this5 = this;
          this.eventManager.addEventListener(document.documentElement, 'mouseup', function () {
            return _this5.onMouseUp();
          });
          this.eventManager.addEventListener(document.documentElement, 'mousemove', function (event) {
            return _this5.onMouseMove(event);
          });
        }
      }, {
        key: 'onCellCornerDblClick',
        value: function onCellCornerDblClick() {
          var selectionApplied = this.selectAdjacent();
          if (selectionApplied) {
            this.fillIn();
          }
        }
      }, {
        key: 'onAfterCellCornerMouseDown',
        value: function onAfterCellCornerMouseDown() {
          this.handleDraggedCells = 1;
          this.mouseDownOnCellCorner = true;
        }
      }, {
        key: 'onBeforeCellMouseOver',
        value: function onBeforeCellMouseOver(coords) {
          if (this.mouseDownOnCellCorner && !this.hot.view.isMouseDown() && this.handleDraggedCells) {
            this.handleDraggedCells++;
            this.showBorder(coords);
            this.addNewRowIfNeeded();
            this.addNewColumnIfNeeded();
          }
        }
      }, {
        key: 'onMouseUp',
        value: function onMouseUp() {
          if (this.handleDraggedCells) {
            if (this.handleDraggedCells > 1) {
              this.fillIn();
            }
            this.handleDraggedCells = 0;
            this.mouseDownOnCellCorner = false;
          }
        }
      }, {
        key: 'onMouseMove',
        value: function onMouseMove(event) {
          var mouseWasDraggedOutside = this.getIfMouseWasDraggedOutside(event);
          if (this.addingStarted === false && this.handleDraggedCells > 0 && mouseWasDraggedOutside) {
            this.mouseDragOutside = true;
            this.addingStarted = true;
          } else {
            this.mouseDragOutside = false;
          }
          if (this.mouseDragOutside && this.autoInsertRow) {
            this.addRow();
          }
        }
      }, {
        key: 'clearMappedSettings',
        value: function clearMappedSettings() {
          this.directions.length = 0;
          this.autoInsertRow = false;
        }
      }, {
        key: 'mapSettings',
        value: function mapSettings() {
          var mappedSettings = (0, _utils.getMappedFillHandleSetting)(this.hot.getSettings().fillHandle);
          this.directions = mappedSettings.directions;
          this.autoInsertRow = mappedSettings.autoInsertRow;
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          _get(Autofill.prototype.__proto__ || Object.getPrototypeOf(Autofill.prototype), 'destroy', this).call(this);
        }
      }]);
      return Autofill;
    }(_base2.default);
    (0, _plugins.registerPlugin)('autofill', Autofill);
    exports.default = Autofill;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.DIRECTIONS = undefined;
    exports.getDeltas = getDeltas;
    exports.getDragDirectionAndRange = getDragDirectionAndRange;
    exports.getMappedFillHandleSetting = getMappedFillHandleSetting;
    var _object = __webpack_require__(3);
    var _mixed = __webpack_require__(23);
    var _src = __webpack_require__(14);
    var DIRECTIONS = exports.DIRECTIONS = {
      horizontal: 'horizontal',
      vertical: 'vertical'
    };

    function getDeltas(start, end, data, direction) {
      var rowsLength = data.length;
      var columnsLength = data ? data[0].length : 0;
      var deltas = [];
      var diffRow = end.row - start.row;
      var diffCol = end.col - start.col;
      if (['down', 'up'].indexOf(direction) !== -1) {
        var arr = [];
        for (var col = 0; col <= diffCol; col++) {
          var startValue = parseInt(data[0][col], 10);
          var endValue = parseInt(data[rowsLength - 1][col], 10);
          var delta = (direction === 'down' ? endValue - startValue : startValue - endValue) / (rowsLength - 1) || 0;
          arr.push(delta);
        }
        deltas.push(arr);
      }
      if (['right', 'left'].indexOf(direction) !== -1) {
        for (var row = 0; row <= diffRow; row++) {
          var _startValue = parseInt(data[row][0], 10);
          var _endValue = parseInt(data[row][columnsLength - 1], 10);
          var _delta = (direction === 'right' ? _endValue - _startValue : _startValue - _endValue) / (columnsLength - 1) || 0;
          deltas.push([_delta]);
        }
      }
      return deltas;
    }

    function getDragDirectionAndRange(startSelection, endSelection) {
      var startOfDragCoords = void 0,
        endOfDragCoords = void 0,
        directionOfDrag = void 0;
      if (endSelection[0] === startSelection[0] && endSelection[1] < startSelection[1]) {
        directionOfDrag = 'left';
        startOfDragCoords = new _src.CellCoords(endSelection[0], endSelection[1]);
        endOfDragCoords = new _src.CellCoords(endSelection[2], startSelection[1] - 1);
      } else if (endSelection[0] === startSelection[0] && endSelection[3] > startSelection[3]) {
        directionOfDrag = 'right';
        startOfDragCoords = new _src.CellCoords(endSelection[0], startSelection[3] + 1);
        endOfDragCoords = new _src.CellCoords(endSelection[2], endSelection[3]);
      } else if (endSelection[0] < startSelection[0] && endSelection[1] === startSelection[1]) {
        directionOfDrag = 'up';
        startOfDragCoords = new _src.CellCoords(endSelection[0], endSelection[1]);
        endOfDragCoords = new _src.CellCoords(startSelection[0] - 1, endSelection[3]);
      } else if (endSelection[2] > startSelection[2] && endSelection[1] === startSelection[1]) {
        directionOfDrag = 'down';
        startOfDragCoords = new _src.CellCoords(startSelection[2] + 1, endSelection[1]);
        endOfDragCoords = new _src.CellCoords(endSelection[2], endSelection[3]);
      }
      return {
        directionOfDrag: directionOfDrag,
        startOfDragCoords: startOfDragCoords,
        endOfDragCoords: endOfDragCoords
      };
    }

    function getMappedFillHandleSetting(fillHandle) {
      var mappedSettings = {};
      if (fillHandle === true) {
        mappedSettings.directions = Object.keys(DIRECTIONS);
        mappedSettings.autoInsertRow = true;
      } else if ((0, _object.isObject)(fillHandle)) {
        if ((0, _mixed.isDefined)(fillHandle.autoInsertRow)) {
          if (fillHandle.direction === DIRECTIONS.horizontal) {
            mappedSettings.autoInsertRow = false;
          } else {
            mappedSettings.autoInsertRow = fillHandle.autoInsertRow;
          }
        } else {
          mappedSettings.autoInsertRow = false;
        }
        if ((0, _mixed.isDefined)(fillHandle.direction)) {
          mappedSettings.directions = [fillHandle.direction];
        } else {
          mappedSettings.directions = Object.keys(DIRECTIONS);
        }
      } else if (typeof fillHandle === 'string') {
        mappedSettings.directions = [fillHandle];
        mappedSettings.autoInsertRow = true;
      } else {
        mappedSettings.directions = [];
        mappedSettings.autoInsertRow = false;
      }
      return mappedSettings;
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _array = __webpack_require__(2);
    var _object = __webpack_require__(3);

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var CommandExecutor = function () {
      function CommandExecutor(hotInstance) {
        _classCallCheck(this, CommandExecutor);
        this.hot = hotInstance;
        this.commands = {};
        this.commonCallback = null;
      }
      _createClass(CommandExecutor, [{
        key: 'registerCommand',
        value: function registerCommand(name, commandDescriptor) {
          this.commands[name] = commandDescriptor;
        }
      }, {
        key: 'setCommonCallback',
        value: function setCommonCallback(callback) {
          this.commonCallback = callback;
        }
      }, {
        key: 'execute',
        value: function execute(commandName) {
          var _this = this;
          for (var _len = arguments.length, params = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
            params[_key - 1] = arguments[_key];
          }
          var commandSplit = commandName.split(':');
          commandName = commandSplit[0];
          var subCommandName = commandSplit.length === 2 ? commandSplit[1] : null;
          var command = this.commands[commandName];
          if (!command) {
            throw new Error('Menu command \'' + commandName + '\' not exists.');
          }
          if (subCommandName && command.submenu) {
            command = findSubCommand(subCommandName, command.submenu.items);
          }
          if (command.disabled === true) {
            return;
          }
          if (typeof command.disabled == 'function' && command.disabled.call(this.hot) === true) {
            return;
          }
          if ((0, _object.hasOwnProperty)(command, 'submenu')) {
            return;
          }
          var callbacks = [];
          if (typeof command.callback === 'function') {
            callbacks.push(command.callback);
          }
          if (typeof this.commonCallback === 'function') {
            callbacks.push(this.commonCallback);
          }
          params.unshift(commandSplit.join(':'));
          (0, _array.arrayEach)(callbacks, function (callback) {
            return callback.apply(_this.hot, params);
          });
        }
      }]);
      return CommandExecutor;
    }();

    function findSubCommand(subCommandName, subCommands) {
      var command = void 0;
      (0, _array.arrayEach)(subCommands, function (cmd) {
        var cmds = cmd.key ? cmd.key.split(':') : null;
        if (Array.isArray(cmds) && cmds[1] === subCommandName) {
          command = cmd;
          return false;
        }
      });
      return command;
    }
    exports.default = CommandExecutor;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _base = __webpack_require__(16);
    var _base2 = _interopRequireDefault(_base);
    var _pluginHooks = __webpack_require__(11);
    var _pluginHooks2 = _interopRequireDefault(_pluginHooks);
    var _array = __webpack_require__(2);
    var _commandExecutor = __webpack_require__(339);
    var _commandExecutor2 = _interopRequireDefault(_commandExecutor);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _itemsFactory = __webpack_require__(342);
    var _itemsFactory2 = _interopRequireDefault(_itemsFactory);
    var _menu = __webpack_require__(343);
    var _menu2 = _interopRequireDefault(_menu);
    var _plugins = __webpack_require__(9);
    var _event = __webpack_require__(7);
    var _element = __webpack_require__(0);
    var _predefinedItems = __webpack_require__(72);
    __webpack_require__(299);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    _pluginHooks2.default.getSingleton().register('afterContextMenuDefaultOptions');
    _pluginHooks2.default.getSingleton().register('afterContextMenuShow');
    _pluginHooks2.default.getSingleton().register('afterContextMenuHide');
    _pluginHooks2.default.getSingleton().register('afterContextMenuExecute');
    var ContextMenu = function (_BasePlugin) {
      _inherits(ContextMenu, _BasePlugin);
      _createClass(ContextMenu, null, [{
        key: 'DEFAULT_ITEMS',
        get: function get() {
          return [_predefinedItems.ROW_ABOVE, _predefinedItems.ROW_BELOW, _predefinedItems.SEPARATOR, _predefinedItems.COLUMN_LEFT, _predefinedItems.COLUMN_RIGHT, _predefinedItems.SEPARATOR, _predefinedItems.REMOVE_ROW, _predefinedItems.REMOVE_COLUMN, _predefinedItems.SEPARATOR, _predefinedItems.UNDO, _predefinedItems.REDO, _predefinedItems.SEPARATOR, _predefinedItems.READ_ONLY, _predefinedItems.SEPARATOR, _predefinedItems.ALIGNMENT];
        }
      }]);

      function ContextMenu(hotInstance) {
        _classCallCheck(this, ContextMenu);
        var _this = _possibleConstructorReturn(this, (ContextMenu.__proto__ || Object.getPrototypeOf(ContextMenu)).call(this, hotInstance));
        _this.eventManager = new _eventManager2.default(_this);
        _this.commandExecutor = new _commandExecutor2.default(_this.hot);
        _this.itemsFactory = null;
        _this.menu = null;
        return _this;
      }
      _createClass(ContextMenu, [{
        key: 'isEnabled',
        value: function isEnabled() {
          return this.hot.getSettings().contextMenu;
        }
      }, {
        key: 'enablePlugin',
        value: function enablePlugin() {
          var _this2 = this;
          if (this.enabled) {
            return;
          }
          this.itemsFactory = new _itemsFactory2.default(this.hot, ContextMenu.DEFAULT_ITEMS);
          var settings = this.hot.getSettings().contextMenu;
          var predefinedItems = {
            items: this.itemsFactory.getItems(settings)
          };
          this.registerEvents();
          if (typeof settings.callback === 'function') {
            this.commandExecutor.setCommonCallback(settings.callback);
          }
          _get(ContextMenu.prototype.__proto__ || Object.getPrototypeOf(ContextMenu.prototype), 'enablePlugin', this).call(this);
          this.callOnPluginsReady(function () {
            _this2.hot.runHooks('afterContextMenuDefaultOptions', predefinedItems);
            _this2.itemsFactory.setPredefinedItems(predefinedItems.items);
            var menuItems = _this2.itemsFactory.getItems(settings);
            _this2.menu = new _menu2.default(_this2.hot, {
              className: 'htContextMenu',
              keepInViewport: true
            });
            _this2.hot.runHooks('beforeContextMenuSetItems', menuItems);
            _this2.menu.setMenuItems(menuItems);
            _this2.menu.addLocalHook('afterOpen', function () {
              return _this2.onMenuAfterOpen();
            });
            _this2.menu.addLocalHook('afterClose', function () {
              return _this2.onMenuAfterClose();
            });
            _this2.menu.addLocalHook('executeCommand', function () {
              for (var _len = arguments.length, params = Array(_len), _key = 0; _key < _len; _key++) {
                params[_key] = arguments[_key];
              }
              return _this2.executeCommand.apply(_this2, params);
            });
            (0, _array.arrayEach)(menuItems, function (command) {
              return _this2.commandExecutor.registerCommand(command.key, command);
            });
          });
        }
      }, {
        key: 'updatePlugin',
        value: function updatePlugin() {
          this.disablePlugin();
          this.enablePlugin();
          _get(ContextMenu.prototype.__proto__ || Object.getPrototypeOf(ContextMenu.prototype), 'updatePlugin', this).call(this);
        }
      }, {
        key: 'disablePlugin',
        value: function disablePlugin() {
          this.close();
          if (this.menu) {
            this.menu.destroy();
            this.menu = null;
          }
          _get(ContextMenu.prototype.__proto__ || Object.getPrototypeOf(ContextMenu.prototype), 'disablePlugin', this).call(this);
        }
      }, {
        key: 'registerEvents',
        value: function registerEvents() {
          var _this3 = this;
          this.eventManager.addEventListener(this.hot.rootElement, 'contextmenu', function (event) {
            return _this3.onContextMenu(event);
          });
        }
      }, {
        key: 'open',
        value: function open(event) {
          if (!this.menu) {
            return;
          }
          this.menu.open();
          this.menu.setPosition({
            top: parseInt((0, _event.pageY)(event), 10) - (0, _element.getWindowScrollTop)(),
            left: parseInt((0, _event.pageX)(event), 10) - (0, _element.getWindowScrollLeft)()
          });
          this.menu.hotMenu.isHotTableEnv = this.hot.isHotTableEnv;
        }
      }, {
        key: 'close',
        value: function close() {
          if (!this.menu) {
            return;
          }
          this.menu.close();
        }
      }, {
        key: 'executeCommand',
        value: function executeCommand() {
          for (var _len2 = arguments.length, params = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
            params[_key2] = arguments[_key2];
          }
          this.commandExecutor.execute.apply(this.commandExecutor, params);
        }
      }, {
        key: 'onContextMenu',
        value: function onContextMenu(event) {
          var settings = this.hot.getSettings();
          var showRowHeaders = settings.rowHeaders;
          var showColHeaders = settings.colHeaders;

          function isValidElement(element) {
            return element.nodeName === 'TD' || element.parentNode.nodeName === 'TD';
          }
          var element = event.realTarget;
          this.close();
          if ((0, _element.hasClass)(element, 'handsontableInput')) {
            return;
          }
          event.preventDefault();
          (0, _event.stopPropagation)(event);
          if (!(showRowHeaders || showColHeaders)) {
            if (!isValidElement(element) && !((0, _element.hasClass)(element, 'current') && (0, _element.hasClass)(element, 'wtBorder'))) {
              return;
            }
          }
          this.open(event);
        }
      }, {
        key: 'onMenuAfterOpen',
        value: function onMenuAfterOpen() {
          this.hot.runHooks('afterContextMenuShow', this);
        }
      }, {
        key: 'onMenuAfterClose',
        value: function onMenuAfterClose() {
          this.hot.listen();
          this.hot.runHooks('afterContextMenuHide', this);
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          this.close();
          if (this.menu) {
            this.menu.destroy();
          }
          _get(ContextMenu.prototype.__proto__ || Object.getPrototypeOf(ContextMenu.prototype), 'destroy', this).call(this);
        }
      }]);
      return ContextMenu;
    }(_base2.default);
    ContextMenu.SEPARATOR = {
      name: _predefinedItems.SEPARATOR
    };
    (0, _plugins.registerPlugin)('contextMenu', ContextMenu);
    exports.default = ContextMenu;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _element = __webpack_require__(0);
    var _event = __webpack_require__(7);

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var Cursor = function () {
      function Cursor(object) {
        _classCallCheck(this, Cursor);
        var windowScrollTop = (0, _element.getWindowScrollTop)();
        var windowScrollLeft = (0, _element.getWindowScrollLeft)();
        var top = void 0,
          topRelative = void 0;
        var left = void 0,
          leftRelative = void 0;
        var cellHeight = void 0,
          cellWidth = void 0;
        this.type = this.getSourceType(object);
        if (this.type === 'literal') {
          top = parseInt(object.top, 10);
          left = parseInt(object.left, 10);
          cellHeight = object.height || 0;
          cellWidth = object.width || 0;
          topRelative = top;
          leftRelative = left;
          top += windowScrollTop;
          left += windowScrollLeft;
        } else if (this.type === 'event') {
          top = parseInt((0, _event.pageY)(object), 10);
          left = parseInt((0, _event.pageX)(object), 10);
          cellHeight = object.target.clientHeight;
          cellWidth = object.target.clientWidth;
          topRelative = top - windowScrollTop;
          leftRelative = left - windowScrollLeft;
        }
        this.top = top;
        this.topRelative = topRelative;
        this.left = left;
        this.leftRelative = leftRelative;
        this.scrollTop = windowScrollTop;
        this.scrollLeft = windowScrollLeft;
        this.cellHeight = cellHeight;
        this.cellWidth = cellWidth;
      }
      _createClass(Cursor, [{
        key: 'getSourceType',
        value: function getSourceType(object) {
          var type = 'literal';
          if (object instanceof Event) {
            type = 'event';
          }
          return type;
        }
      }, {
        key: 'fitsAbove',
        value: function fitsAbove(element) {
          return this.topRelative >= element.offsetHeight;
        }
      }, {
        key: 'fitsBelow',
        value: function fitsBelow(element) {
          var viewportHeight = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : window.innerHeight;
          return this.topRelative + element.offsetHeight <= viewportHeight;
        }
      }, {
        key: 'fitsOnRight',
        value: function fitsOnRight(element) {
          var viewportWidth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : window.innerWidth;
          return this.leftRelative + this.cellWidth + element.offsetWidth <= viewportWidth;
        }
      }, {
        key: 'fitsOnLeft',
        value: function fitsOnLeft(element) {
          return this.leftRelative >= element.offsetWidth;
        }
      }]);
      return Cursor;
    }();
    exports.default = Cursor;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _object = __webpack_require__(3);
    var _array = __webpack_require__(2);
    var _predefinedItems = __webpack_require__(72);

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var ItemsFactory = function () {
      function ItemsFactory(hotInstance) {
        var orderPattern = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
        _classCallCheck(this, ItemsFactory);
        this.hot = hotInstance;
        this.predefinedItems = (0, _predefinedItems.predefinedItems)();
        this.defaultOrderPattern = orderPattern;
      }
      _createClass(ItemsFactory, [{
        key: 'setPredefinedItems',
        value: function setPredefinedItems(predefinedItems) {
          var _this = this;
          var items = {};
          this.defaultOrderPattern.length = 0;
          (0, _object.objectEach)(predefinedItems, function (value, key) {
            var menuItemKey = '';
            if (value.name === _predefinedItems.SEPARATOR) {
              items[_predefinedItems.SEPARATOR] = value;
              menuItemKey = _predefinedItems.SEPARATOR;
            } else if (isNaN(parseInt(key, 10))) {
              value.key = value.key === void 0 ? key : value.key;
              items[key] = value;
              menuItemKey = value.key;
            } else {
              items[value.key] = value;
              menuItemKey = value.key;
            }
            _this.defaultOrderPattern.push(menuItemKey);
          });
          this.predefinedItems = items;
        }
      }, {
        key: 'getItems',
        value: function getItems() {
          var pattern = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
          return _getItems(pattern, this.defaultOrderPattern, this.predefinedItems);
        }
      }]);
      return ItemsFactory;
    }();

    function _getItems() {
      var pattern = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
      var defaultPattern = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
      var items = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
      var result = [];
      if (pattern && pattern.items) {
        pattern = pattern.items;
      } else if (!Array.isArray(pattern)) {
        pattern = defaultPattern;
      }
      if ((0, _object.isObject)(pattern)) {
        (0, _object.objectEach)(pattern, function (value, key) {
          var item = items[typeof value === 'string' ? value : key];
          if (!item) {
            item = value;
          }
          if ((0, _object.isObject)(value)) {
            (0, _object.extend)(item, value);
          } else if (typeof item === 'string') {
            item = {
              name: item
            };
          }
          if (item.key === void 0) {
            item.key = key;
          }
          result.push(item);
        });
      } else {
        (0, _array.arrayEach)(pattern, function (name, key) {
          var item = items[name];
          if (!item && _predefinedItems.ITEMS.indexOf(name) >= 0) {
            return;
          }
          if (!item) {
            item = {
              name: name,
              key: '' + key
            };
          }
          if ((0, _object.isObject)(name)) {
            (0, _object.extend)(item, name);
          }
          if (item.key === void 0) {
            item.key = key;
          }
          result.push(item);
        });
      }
      return result;
    }
    exports.default = ItemsFactory;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _core = __webpack_require__(66);
    var _core2 = _interopRequireDefault(_core);
    var _element = __webpack_require__(0);
    var _array = __webpack_require__(2);
    var _cursor = __webpack_require__(341);
    var _cursor2 = _interopRequireDefault(_cursor);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _object = __webpack_require__(3);
    var _function = __webpack_require__(35);
    var _utils = __webpack_require__(19);
    var _unicode = __webpack_require__(15);
    var _localHooks = __webpack_require__(333);
    var _localHooks2 = _interopRequireDefault(_localHooks);
    var _predefinedItems = __webpack_require__(72);
    var _event = __webpack_require__(7);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var Menu = function () {
      function Menu(hotInstance, options) {
        _classCallCheck(this, Menu);
        this.hot = hotInstance;
        this.options = options || {
          parent: null,
          name: null,
          className: '',
          keepInViewport: true,
          standalone: false
        };
        this.eventManager = new _eventManager2.default(this);
        this.container = this.createContainer(this.options.name);
        this.hotMenu = null;
        this.hotSubMenus = {};
        this.parentMenu = this.options.parent || null;
        this.menuItems = null;
        this.origOutsideClickDeselects = null;
        this.keyEvent = false;
        this.offset = {
          above: 0,
          below: 0,
          left: 0,
          right: 0
        };
        this._afterScrollCallback = null;
        this.registerEvents();
      }
      _createClass(Menu, [{
        key: 'registerEvents',
        value: function registerEvents() {
          var _this = this;
          this.eventManager.addEventListener(document.documentElement, 'mousedown', function (event) {
            return _this.onDocumentMouseDown(event);
          });
        }
      }, {
        key: 'setMenuItems',
        value: function setMenuItems(menuItems) {
          this.menuItems = menuItems;
        }
      }, {
        key: 'setOffset',
        value: function setOffset(area) {
          var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
          this.offset[area] = offset;
        }
      }, {
        key: 'isSubMenu',
        value: function isSubMenu() {
          return this.parentMenu !== null;
        }
      }, {
        key: 'open',
        value: function open() {
          var _this2 = this;
          this.container.removeAttribute('style');
          this.container.style.display = 'block';
          var delayedOpenSubMenu = (0, _function.debounce)(function (row) {
            return _this2.openSubMenu(row);
          }, 300);
          var filteredItems = (0, _array.arrayFilter)(this.menuItems, function (item) {
            return (0, _utils.isItemHidden)(item, _this2.hot);
          });
          filteredItems = (0, _utils.filterSeparators)(filteredItems, _predefinedItems.SEPARATOR);
          var settings = {
            data: filteredItems,
            colHeaders: false,
            colWidths: [200],
            autoRowSize: false,
            readOnly: true,
            copyPaste: false,
            columns: [{
              data: 'name',
              renderer: function renderer(hot, TD, row, col, prop, value) {
                return _this2.menuItemRenderer(hot, TD, row, col, prop, value);
              }
            }],
            renderAllRows: true,
            fragmentSelection: 'cell',
            disableVisualSelection: 'area',
            beforeKeyDown: function beforeKeyDown(event) {
              return _this2.onBeforeKeyDown(event);
            },
            afterOnCellMouseOver: function afterOnCellMouseOver(event, coords, TD) {
              if (_this2.isAllSubMenusClosed()) {
                delayedOpenSubMenu(coords.row);
              } else {
                _this2.openSubMenu(coords.row);
              }
            },
            rowHeights: function rowHeights(row) {
              return filteredItems[row].name === _predefinedItems.SEPARATOR ? 1 : 23;
            }
          };
          this.origOutsideClickDeselects = this.hot.getSettings().outsideClickDeselects;
          this.hot.getSettings().outsideClickDeselects = false;
          this.hotMenu = new _core2.default(this.container, settings);
          this.hotMenu.addHook('afterInit', function () {
            return _this2.onAfterInit();
          });
          this.hotMenu.addHook('afterSelection', function (r, c, r2, c2, preventScrolling) {
            return _this2.onAfterSelection(r, c, r2, c2, preventScrolling);
          });
          this.hotMenu.init();
          this.hotMenu.listen();
          this.blockMainTableCallbacks();
          this.runLocalHooks('afterOpen');
        }
      }, {
        key: 'close',
        value: function close() {
          var closeParent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
          if (!this.isOpened()) {
            return;
          }
          if (closeParent && this.parentMenu) {
            this.parentMenu.close();
          } else {
            this.closeAllSubMenus();
            this.container.style.display = 'none';
            this.releaseMainTableCallbacks();
            this.hotMenu.destroy();
            this.hotMenu = null;
            this.hot.getSettings().outsideClickDeselects = this.origOutsideClickDeselects;
            this.runLocalHooks('afterClose');
            if (this.parentMenu) {
              this.parentMenu.hotMenu.listen();
            }
          }
        }
      }, {
        key: 'openSubMenu',
        value: function openSubMenu(row) {
          if (!this.hotMenu) {
            return false;
          }
          var cell = this.hotMenu.getCell(row, 0);
          this.closeAllSubMenus();
          if (!cell || !(0, _utils.hasSubMenu)(cell)) {
            return false;
          }
          var dataItem = this.hotMenu.getSourceDataAtRow(row);
          var subMenu = new Menu(this.hot, {
            parent: this,
            name: dataItem.name,
            className: this.options.className,
            keepInViewport: true
          });
          subMenu.setMenuItems(dataItem.submenu.items);
          subMenu.open();
          subMenu.setPosition(cell.getBoundingClientRect());
          this.hotSubMenus[dataItem.key] = subMenu;
          return subMenu;
        }
      }, {
        key: 'closeSubMenu',
        value: function closeSubMenu(row) {
          var dataItem = this.hotMenu.getSourceDataAtRow(row);
          var menus = this.hotSubMenus[dataItem.key];
          if (menus) {
            menus.destroy();
            delete this.hotSubMenus[dataItem.key];
          }
        }
      }, {
        key: 'closeAllSubMenus',
        value: function closeAllSubMenus() {
          var _this3 = this;
          (0, _array.arrayEach)(this.hotMenu.getData(), function (value, row) {
            return _this3.closeSubMenu(row);
          });
        }
      }, {
        key: 'isAllSubMenusClosed',
        value: function isAllSubMenusClosed() {
          return Object.keys(this.hotSubMenus).length === 0;
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          this.clearLocalHooks();
          this.close();
          this.parentMenu = null;
          this.eventManager.destroy();
        }
      }, {
        key: 'isOpened',
        value: function isOpened() {
          return this.hotMenu !== null;
        }
      }, {
        key: 'executeCommand',
        value: function executeCommand(event) {
          if (!this.isOpened() || !this.hotMenu.getSelected()) {
            return;
          }
          var selectedItem = this.hotMenu.getSourceDataAtRow(this.hotMenu.getSelected()[0]);
          this.runLocalHooks('select', selectedItem, event);
          if (selectedItem.isCommand === false || selectedItem.name === _predefinedItems.SEPARATOR) {
            return;
          }
          var selRange = this.hot.getSelectedRange();
          var normalizedSelection = selRange ? (0, _utils.normalizeSelection)(selRange) : {};
          var autoClose = true;
          if (selectedItem.disabled === true || typeof selectedItem.disabled === 'function' && selectedItem.disabled.call(this.hot) === true || selectedItem.submenu) {
            autoClose = false;
          }
          this.runLocalHooks('executeCommand', selectedItem.key, normalizedSelection, event);
          if (this.isSubMenu()) {
            this.parentMenu.runLocalHooks('executeCommand', selectedItem.key, normalizedSelection, event);
          }
          if (autoClose) {
            this.close(true);
          }
        }
      }, {
        key: 'setPosition',
        value: function setPosition(coords) {
          var cursor = new _cursor2.default(coords);
          if (this.options.keepInViewport) {
            if (cursor.fitsBelow(this.container)) {
              this.setPositionBelowCursor(cursor);
            } else if (cursor.fitsAbove(this.container)) {
              this.setPositionAboveCursor(cursor);
            } else {
              this.setPositionBelowCursor(cursor);
            }
            if (cursor.fitsOnRight(this.container)) {
              this.setPositionOnRightOfCursor(cursor);
            } else {
              this.setPositionOnLeftOfCursor(cursor);
            }
          } else {
            this.setPositionBelowCursor(cursor);
            this.setPositionOnRightOfCursor(cursor);
          }
        }
      }, {
        key: 'setPositionAboveCursor',
        value: function setPositionAboveCursor(cursor) {
          var top = this.offset.above + cursor.top - this.container.offsetHeight;
          if (this.isSubMenu()) {
            top = cursor.top + cursor.cellHeight - this.container.offsetHeight + 3;
          }
          this.container.style.top = top + 'px';
        }
      }, {
        key: 'setPositionBelowCursor',
        value: function setPositionBelowCursor(cursor) {
          var top = this.offset.below + cursor.top;
          if (this.isSubMenu()) {
            top = cursor.top - 1;
          }
          this.container.style.top = top + 'px';
        }
      }, {
        key: 'setPositionOnRightOfCursor',
        value: function setPositionOnRightOfCursor(cursor) {
          var left = void 0;
          if (this.isSubMenu()) {
            left = 1 + cursor.left + cursor.cellWidth;
          } else {
            left = this.offset.right + 1 + cursor.left;
          }
          this.container.style.left = left + 'px';
        }
      }, {
        key: 'setPositionOnLeftOfCursor',
        value: function setPositionOnLeftOfCursor(cursor) {
          var left = this.offset.left + cursor.left - this.container.offsetWidth + (0, _element.getScrollbarWidth)() + 4;
          this.container.style.left = left + 'px';
        }
      }, {
        key: 'selectFirstCell',
        value: function selectFirstCell() {
          var cell = this.hotMenu.getCell(0, 0);
          if ((0, _utils.isSeparator)(cell) || (0, _utils.isDisabled)(cell) || (0, _utils.isSelectionDisabled)(cell)) {
            this.selectNextCell(0, 0);
          } else {
            this.hotMenu.selectCell(0, 0);
          }
        }
      }, {
        key: 'selectLastCell',
        value: function selectLastCell() {
          var lastRow = this.hotMenu.countRows() - 1;
          var cell = this.hotMenu.getCell(lastRow, 0);
          if ((0, _utils.isSeparator)(cell) || (0, _utils.isDisabled)(cell) || (0, _utils.isSelectionDisabled)(cell)) {
            this.selectPrevCell(lastRow, 0);
          } else {
            this.hotMenu.selectCell(lastRow, 0);
          }
        }
      }, {
        key: 'selectNextCell',
        value: function selectNextCell(row, col) {
          var nextRow = row + 1;
          var cell = nextRow < this.hotMenu.countRows() ? this.hotMenu.getCell(nextRow, col) : null;
          if (!cell) {
            return;
          }
          if ((0, _utils.isSeparator)(cell) || (0, _utils.isDisabled)(cell) || (0, _utils.isSelectionDisabled)(cell)) {
            this.selectNextCell(nextRow, col);
          } else {
            this.hotMenu.selectCell(nextRow, col);
          }
        }
      }, {
        key: 'selectPrevCell',
        value: function selectPrevCell(row, col) {
          var prevRow = row - 1;
          var cell = prevRow >= 0 ? this.hotMenu.getCell(prevRow, col) : null;
          if (!cell) {
            return;
          }
          if ((0, _utils.isSeparator)(cell) || (0, _utils.isDisabled)(cell) || (0, _utils.isSelectionDisabled)(cell)) {
            this.selectPrevCell(prevRow, col);
          } else {
            this.hotMenu.selectCell(prevRow, col);
          }
        }
      }, {
        key: 'menuItemRenderer',
        value: function menuItemRenderer(hot, TD, row, col, prop, value) {
          var _this4 = this;
          var item = hot.getSourceDataAtRow(row);
          var wrapper = document.createElement('div');
          var isSubMenu = function isSubMenu(item) {
            return (0, _object.hasOwnProperty)(item, 'submenu');
          };
          var itemIsSeparator = function itemIsSeparator(item) {
            return new RegExp(_predefinedItems.SEPARATOR, 'i').test(item.name);
          };
          var itemIsDisabled = function itemIsDisabled(item) {
            return item.disabled === true || typeof item.disabled == 'function' && item.disabled.call(_this4.hot) === true;
          };
          var itemIsSelectionDisabled = function itemIsSelectionDisabled(item) {
            return item.disableSelection;
          };
          if (typeof value === 'function') {
            value = value.call(this.hot);
          } (0, _element.empty)(TD);
          (0, _element.addClass)(wrapper, 'htItemWrapper');
          (0, _element.addClass)(wrapper, item.key);
          TD.appendChild(wrapper);
          if (itemIsSeparator(item)) {
            (0, _element.addClass)(TD, 'htSeparator');
          } else if (typeof item.renderer === 'function') {
            (0, _element.addClass)(TD, 'htCustomMenuRenderer');
            TD.appendChild(item.renderer(hot, wrapper, row, col, prop, value));
          } else {
            (0, _element.fastInnerHTML)(wrapper, value);
          }
          if (itemIsDisabled(item)) {
            (0, _element.addClass)(TD, 'htDisabled');
            this.eventManager.addEventListener(TD, 'mouseenter', function () {
              return hot.deselectCell();
            });
          } else if (itemIsSelectionDisabled(item)) {
            (0, _element.addClass)(TD, 'htSelectionDisabled');
            this.eventManager.addEventListener(TD, 'mouseenter', function () {
              return hot.deselectCell();
            });
          } else if (isSubMenu(item)) {
            (0, _element.addClass)(TD, 'htSubmenu');
            if (itemIsSelectionDisabled(item)) {
              this.eventManager.addEventListener(TD, 'mouseenter', function () {
                return hot.deselectCell();
              });
            } else {
              this.eventManager.addEventListener(TD, 'mouseenter', function () {
                return hot.selectCell(row, col, void 0, void 0, false, false);
              });
            }
          } else {
            (0, _element.removeClass)(TD, 'htSubmenu');
            (0, _element.removeClass)(TD, 'htDisabled');
            if (itemIsSelectionDisabled(item)) {
              this.eventManager.addEventListener(TD, 'mouseenter', function () {
                return hot.deselectCell();
              });
            } else {
              this.eventManager.addEventListener(TD, 'mouseenter', function () {
                return hot.selectCell(row, col, void 0, void 0, false, false);
              });
            }
          }
        }
      }, {
        key: 'createContainer',
        value: function createContainer() {
          var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
          if (name) {
            name = name.replace(/[^A-z0-9]/g, '_');
            name = this.options.className + 'Sub_' + name;
          }
          var container = void 0;
          if (name) {
            container = document.querySelector('.' + this.options.className + '.' + name);
          } else {
            container = document.querySelector('.' + this.options.className);
          }
          if (!container) {
            container = document.createElement('div');
            (0, _element.addClass)(container, 'htMenu ' + this.options.className);
            if (name) {
              (0, _element.addClass)(container, name);
            }
            document.getElementsByTagName('body')[0].appendChild(container);
          }
          return container;
        }
      }, {
        key: 'blockMainTableCallbacks',
        value: function blockMainTableCallbacks() {
          this._afterScrollCallback = function () { };
          this.hot.addHook('afterScrollVertically', this._afterScrollCallback);
          this.hot.addHook('afterScrollHorizontally', this._afterScrollCallback);
        }
      }, {
        key: 'releaseMainTableCallbacks',
        value: function releaseMainTableCallbacks() {
          if (this._afterScrollCallback) {
            this.hot.removeHook('afterScrollVertically', this._afterScrollCallback);
            this.hot.removeHook('afterScrollHorizontally', this._afterScrollCallback);
            this._afterScrollCallback = null;
          }
        }
      }, {
        key: 'onBeforeKeyDown',
        value: function onBeforeKeyDown(event) {
          var selection = this.hotMenu.getSelected();
          var stopEvent = false;
          this.keyEvent = true;
          switch (event.keyCode) {
            case _unicode.KEY_CODES.ESCAPE:
              this.close();
              stopEvent = true;
              break;
            case _unicode.KEY_CODES.ENTER:
              if (selection) {
                if (this.hotMenu.getSourceDataAtRow(selection[0]).submenu) {
                  stopEvent = true;
                } else {
                  this.executeCommand(event);
                  this.close(true);
                }
              }
              break;
            case _unicode.KEY_CODES.ARROW_DOWN:
              if (selection) {
                this.selectNextCell(selection[0], selection[1]);
              } else {
                this.selectFirstCell();
              }
              stopEvent = true;
              break;
            case _unicode.KEY_CODES.ARROW_UP:
              if (selection) {
                this.selectPrevCell(selection[0], selection[1]);
              } else {
                this.selectLastCell();
              }
              stopEvent = true;
              break;
            case _unicode.KEY_CODES.ARROW_RIGHT:
              if (selection) {
                var menu = this.openSubMenu(selection[0]);
                if (menu) {
                  menu.selectFirstCell();
                }
              }
              stopEvent = true;
              break;
            case _unicode.KEY_CODES.ARROW_LEFT:
              if (selection && this.isSubMenu()) {
                this.close();
                if (this.parentMenu) {
                  this.parentMenu.hotMenu.listen();
                }
                stopEvent = true;
              }
              break;
            default:
              break;
          }
          if (stopEvent) {
            event.preventDefault();
            (0, _event.stopImmediatePropagation)(event);
          }
          this.keyEvent = false;
        }
      }, {
        key: 'onAfterInit',
        value: function onAfterInit() {
          var data = this.hotMenu.getSettings().data;
          var hiderStyle = this.hotMenu.view.wt.wtTable.hider.style;
          var holderStyle = this.hotMenu.view.wt.wtTable.holder.style;
          var currentHiderWidth = parseInt(hiderStyle.width, 10);
          var realHeight = (0, _array.arrayReduce)(data, function (accumulator, value) {
            return accumulator + (value.name === _predefinedItems.SEPARATOR ? 1 : 26);
          }, 0);
          holderStyle.width = currentHiderWidth + 22 + 'px';
          holderStyle.height = realHeight + 4 + 'px';
          hiderStyle.height = holderStyle.height;
        }
      }, {
        key: 'onAfterSelection',
        value: function onAfterSelection(r, c, r2, c2, preventScrolling) {
          if (this.keyEvent === false) {
            preventScrolling.value = true;
          }
        }
      }, {
        key: 'onDocumentMouseDown',
        value: function onDocumentMouseDown(event) {
          if (!this.isOpened()) {
            return;
          }
          if (this.container && (0, _element.isChildOf)(event.target, this.container)) {
            this.executeCommand(event);
          }
          if (this.options.standalone && this.hotMenu && !(0, _element.isChildOf)(event.target, this.hotMenu.rootElement)) {
            this.close(true);
          } else if ((this.isAllSubMenusClosed() || this.isSubMenu()) && !(0, _element.isChildOf)(event.target, '.htMenu') && (0, _element.isChildOf)(event.target, document)) {
            this.close(true);
          }
        }
      }]);
      return Menu;
    }();
    (0, _object.mixin)(Menu, _localHooks2.default);
    exports.default = Menu;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.KEY = undefined;
    exports.default = alignmentItem;
    var _utils = __webpack_require__(19);
    var _separator = __webpack_require__(73);
    var KEY = exports.KEY = 'alignment';

    function alignmentItem() {
      return {
        key: KEY,
        name: 'Alignment',
        disabled: function disabled() {
          return !(this.getSelectedRange() && !this.selection.selectedHeader.corner);
        },
        submenu: {
          items: [{
            key: KEY + ':left',
            name: function name() {
              var _this = this;
              var label = 'Left';
              var hasClass = (0, _utils.checkSelectionConsistency)(this.getSelectedRange(), function (row, col) {
                var className = _this.getCellMeta(row, col).className;
                if (className && className.indexOf('htLeft') !== -1) {
                  return true;
                }
              });
              if (hasClass) {
                label = (0, _utils.markLabelAsSelected)(label);
              }
              return label;
            },
            callback: function callback() {
              var _this2 = this;
              var range = this.getSelectedRange();
              var stateBefore = (0, _utils.getAlignmentClasses)(range, function (row, col) {
                return _this2.getCellMeta(row, col).className;
              });
              var type = 'horizontal';
              var alignment = 'htLeft';
              this.runHooks('beforeCellAlignment', stateBefore, range, type, alignment);
              (0, _utils.align)(range, type, alignment, function (row, col) {
                return _this2.getCellMeta(row, col);
              }, function (row, col, key, value) {
                return _this2.setCellMeta(row, col, key, value);
              });
              this.render();
            },
            disabled: false
          }, {
            key: KEY + ':center',
            name: function name() {
              var _this3 = this;
              var label = 'Center';
              var hasClass = (0, _utils.checkSelectionConsistency)(this.getSelectedRange(), function (row, col) {
                var className = _this3.getCellMeta(row, col).className;
                if (className && className.indexOf('htCenter') !== -1) {
                  return true;
                }
              });
              if (hasClass) {
                label = (0, _utils.markLabelAsSelected)(label);
              }
              return label;
            },
            callback: function callback() {
              var _this4 = this;
              var range = this.getSelectedRange();
              var stateBefore = (0, _utils.getAlignmentClasses)(range, function (row, col) {
                return _this4.getCellMeta(row, col).className;
              });
              var type = 'horizontal';
              var alignment = 'htCenter';
              this.runHooks('beforeCellAlignment', stateBefore, range, type, alignment);
              (0, _utils.align)(range, type, alignment, function (row, col) {
                return _this4.getCellMeta(row, col);
              }, function (row, col, key, value) {
                return _this4.setCellMeta(row, col, key, value);
              });
              this.render();
            },
            disabled: false
          }, {
            key: KEY + ':right',
            name: function name() {
              var _this5 = this;
              var label = 'Right';
              var hasClass = (0, _utils.checkSelectionConsistency)(this.getSelectedRange(), function (row, col) {
                var className = _this5.getCellMeta(row, col).className;
                if (className && className.indexOf('htRight') !== -1) {
                  return true;
                }
              });
              if (hasClass) {
                label = (0, _utils.markLabelAsSelected)(label);
              }
              return label;
            },
            callback: function callback() {
              var _this6 = this;
              var range = this.getSelectedRange();
              var stateBefore = (0, _utils.getAlignmentClasses)(range, function (row, col) {
                return _this6.getCellMeta(row, col).className;
              });
              var type = 'horizontal';
              var alignment = 'htRight';
              this.runHooks('beforeCellAlignment', stateBefore, range, type, alignment);
              (0, _utils.align)(range, type, alignment, function (row, col) {
                return _this6.getCellMeta(row, col);
              }, function (row, col, key, value) {
                return _this6.setCellMeta(row, col, key, value);
              });
              this.render();
            },
            disabled: false
          }, {
            key: KEY + ':justify',
            name: function name() {
              var _this7 = this;
              var label = 'Justify';
              var hasClass = (0, _utils.checkSelectionConsistency)(this.getSelectedRange(), function (row, col) {
                var className = _this7.getCellMeta(row, col).className;
                if (className && className.indexOf('htJustify') !== -1) {
                  return true;
                }
              });
              if (hasClass) {
                label = (0, _utils.markLabelAsSelected)(label);
              }
              return label;
            },
            callback: function callback() {
              var _this8 = this;
              var range = this.getSelectedRange();
              var stateBefore = (0, _utils.getAlignmentClasses)(range, function (row, col) {
                return _this8.getCellMeta(row, col).className;
              });
              var type = 'horizontal';
              var alignment = 'htJustify';
              this.runHooks('beforeCellAlignment', stateBefore, range, type, alignment);
              (0, _utils.align)(range, type, alignment, function (row, col) {
                return _this8.getCellMeta(row, col);
              }, function (row, col, key, value) {
                return _this8.setCellMeta(row, col, key, value);
              });
              this.render();
            },
            disabled: false
          }, {
            name: _separator.KEY
          }, {
            key: KEY + ':top',
            name: function name() {
              var _this9 = this;
              var label = 'Top';
              var hasClass = (0, _utils.checkSelectionConsistency)(this.getSelectedRange(), function (row, col) {
                var className = _this9.getCellMeta(row, col).className;
                if (className && className.indexOf('htTop') !== -1) {
                  return true;
                }
              });
              if (hasClass) {
                label = (0, _utils.markLabelAsSelected)(label);
              }
              return label;
            },
            callback: function callback() {
              var _this10 = this;
              var range = this.getSelectedRange();
              var stateBefore = (0, _utils.getAlignmentClasses)(range, function (row, col) {
                return _this10.getCellMeta(row, col).className;
              });
              var type = 'vertical';
              var alignment = 'htTop';
              this.runHooks('beforeCellAlignment', stateBefore, range, type, alignment);
              (0, _utils.align)(range, type, alignment, function (row, col) {
                return _this10.getCellMeta(row, col);
              }, function (row, col, key, value) {
                return _this10.setCellMeta(row, col, key, value);
              });
              this.render();
            },
            disabled: false
          }, {
            key: KEY + ':middle',
            name: function name() {
              var _this11 = this;
              var label = 'Middle';
              var hasClass = (0, _utils.checkSelectionConsistency)(this.getSelectedRange(), function (row, col) {
                var className = _this11.getCellMeta(row, col).className;
                if (className && className.indexOf('htMiddle') !== -1) {
                  return true;
                }
              });
              if (hasClass) {
                label = (0, _utils.markLabelAsSelected)(label);
              }
              return label;
            },
            callback: function callback() {
              var _this12 = this;
              var range = this.getSelectedRange();
              var stateBefore = (0, _utils.getAlignmentClasses)(range, function (row, col) {
                return _this12.getCellMeta(row, col).className;
              });
              var type = 'vertical';
              var alignment = 'htMiddle';
              this.runHooks('beforeCellAlignment', stateBefore, range, type, alignment);
              (0, _utils.align)(range, type, alignment, function (row, col) {
                return _this12.getCellMeta(row, col);
              }, function (row, col, key, value) {
                return _this12.setCellMeta(row, col, key, value);
              });
              this.render();
            },
            disabled: false
          }, {
            key: KEY + ':bottom',
            name: function name() {
              var _this13 = this;
              var label = 'Bottom';
              var hasClass = (0, _utils.checkSelectionConsistency)(this.getSelectedRange(), function (row, col) {
                var className = _this13.getCellMeta(row, col).className;
                if (className && className.indexOf('htBottom') !== -1) {
                  return true;
                }
              });
              if (hasClass) {
                label = (0, _utils.markLabelAsSelected)(label);
              }
              return label;
            },
            callback: function callback() {
              var _this14 = this;
              var range = this.getSelectedRange();
              var stateBefore = (0, _utils.getAlignmentClasses)(range, function (row, col) {
                return _this14.getCellMeta(row, col).className;
              });
              var type = 'vertical';
              var alignment = 'htBottom';
              this.runHooks('beforeCellAlignment', stateBefore, range, type, alignment);
              (0, _utils.align)(range, type, alignment, function (row, col) {
                return _this14.getCellMeta(row, col);
              }, function (row, col, key, value) {
                return _this14.setCellMeta(row, col, key, value);
              });
              this.render();
            },
            disabled: false
          }]
        }
      };
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.KEY = undefined;
    exports.default = clearColumnItem;
    var _utils = __webpack_require__(19);
    var KEY = exports.KEY = 'clear_column';

    function clearColumnItem() {
      return {
        key: KEY,
        name: 'Clear column',
        callback: function callback(key, selection) {
          var column = selection.start.col;
          if (this.countRows()) {
            this.populateFromArray(0, column, [
              [null]
            ], Math.max(selection.start.row, selection.end.row), column, 'ContextMenu.clearColumn');
          }
        },
        disabled: function disabled() {
          var selected = (0, _utils.getValidSelection)(this);
          if (!selected) {
            return true;
          }
          var entireRowSelection = [selected[0], 0, selected[0], this.countCols() - 1];
          var rowSelected = entireRowSelection.join(',') == selected.join(',');
          return selected[1] < 0 || this.countCols() >= this.getSettings().maxCols || rowSelected;
        }
      };
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.KEY = undefined;
    exports.default = columnLeftItem;
    var _utils = __webpack_require__(19);
    var KEY = exports.KEY = 'col_left';

    function columnLeftItem() {
      return {
        key: KEY,
        name: 'Insert column on the left',
        callback: function callback(key, selection) {
          this.alter('insert_col', selection.start.col, 1, 'ContextMenu.columnLeft');
        },
        disabled: function disabled() {
          var selected = (0, _utils.getValidSelection)(this);
          if (!selected) {
            return true;
          }
          if (!this.isColumnModificationAllowed()) {
            return true;
          }
          var entireRowSelection = [selected[0], 0, selected[0], this.countCols() - 1];
          var rowSelected = entireRowSelection.join(',') == selected.join(',');
          var onlyOneColumn = this.countCols() === 1;
          return selected[1] < 0 || this.countCols() >= this.getSettings().maxCols || !onlyOneColumn && rowSelected;
        },
        hidden: function hidden() {
          return !this.getSettings().allowInsertColumn;
        }
      };
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.KEY = undefined;
    exports.default = columnRightItem;
    var _utils = __webpack_require__(19);
    var KEY = exports.KEY = 'col_right';

    function columnRightItem() {
      return {
        key: KEY,
        name: 'Insert column on the right',
        callback: function callback(key, selection) {
          this.alter('insert_col', selection.end.col + 1, 1, 'ContextMenu.columnRight');
        },
        disabled: function disabled() {
          var selected = (0, _utils.getValidSelection)(this);
          if (!selected) {
            return true;
          }
          if (!this.isColumnModificationAllowed()) {
            return true;
          }
          var entireRowSelection = [selected[0], 0, selected[0], this.countCols() - 1];
          var rowSelected = entireRowSelection.join(',') == selected.join(',');
          var onlyOneColumn = this.countCols() === 1;
          return selected[1] < 0 || this.countCols() >= this.getSettings().maxCols || !onlyOneColumn && rowSelected;
        },
        hidden: function hidden() {
          return !this.getSettings().allowInsertColumn;
        }
      };
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.KEY = undefined;
    exports.default = readOnlyItem;
    var _utils = __webpack_require__(19);
    var KEY = exports.KEY = 'make_read_only';

    function readOnlyItem() {
      return {
        key: KEY,
        name: function name() {
          var _this = this;
          var label = 'Read only';
          var atLeastOneReadOnly = (0, _utils.checkSelectionConsistency)(this.getSelectedRange(), function (row, col) {
            return _this.getCellMeta(row, col).readOnly;
          });
          if (atLeastOneReadOnly) {
            label = (0, _utils.markLabelAsSelected)(label);
          }
          return label;
        },
        callback: function callback() {
          var _this2 = this;
          var range = this.getSelectedRange();
          var atLeastOneReadOnly = (0, _utils.checkSelectionConsistency)(range, function (row, col) {
            return _this2.getCellMeta(row, col).readOnly;
          });
          range.forAll(function (row, col) {
            _this2.setCellMeta(row, col, 'readOnly', !atLeastOneReadOnly);
          });
          this.render();
        },
        disabled: function disabled() {
          return !(this.getSelectedRange() && !this.selection.selectedHeader.corner);
        }
      };
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.default = redoItem;
    var KEY = exports.KEY = 'redo';

    function redoItem() {
      return {
        key: KEY,
        name: 'Redo',
        callback: function callback() {
          this.redo();
        },
        disabled: function disabled() {
          return this.undoRedo && !this.undoRedo.isRedoAvailable();
        }
      };
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.KEY = undefined;
    exports.default = removeColumnItem;
    var _utils = __webpack_require__(19);
    var KEY = exports.KEY = 'remove_col';

    function removeColumnItem() {
      return {
        key: KEY,
        name: 'Remove column',
        callback: function callback(key, selection) {
          var amount = selection.end.col - selection.start.col + 1;
          this.alter('remove_col', selection.start.col, amount, 'ContextMenu.removeColumn');
        },
        disabled: function disabled() {
          var selected = (0, _utils.getValidSelection)(this);
          var totalColumns = this.countCols();
          return !selected || this.selection.selectedHeader.rows || this.selection.selectedHeader.corner || !this.isColumnModificationAllowed() || !totalColumns;
        },
        hidden: function hidden() {
          return !this.getSettings().allowRemoveColumn;
        }
      };
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.KEY = undefined;
    exports.default = removeRowItem;
    var _utils = __webpack_require__(19);
    var KEY = exports.KEY = 'remove_row';

    function removeRowItem() {
      return {
        key: KEY,
        name: 'Remove row',
        callback: function callback(key, selection) {
          var amount = selection.end.row - selection.start.row + 1;
          this.alter('remove_row', selection.start.row, amount, 'ContextMenu.removeRow');
        },
        disabled: function disabled() {
          var selected = (0, _utils.getValidSelection)(this);
          var totalRows = this.countRows();
          return !selected || this.selection.selectedHeader.cols || this.selection.selectedHeader.corner || !totalRows;
        },
        hidden: function hidden() {
          return !this.getSettings().allowRemoveRow;
        }
      };
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.KEY = undefined;
    exports.default = rowAboveItem;
    var _utils = __webpack_require__(19);
    var KEY = exports.KEY = 'row_above';

    function rowAboveItem() {
      return {
        key: KEY,
        name: 'Insert row above',
        callback: function callback(key, selection) {
          this.alter('insert_row', selection.start.row, 1, 'ContextMenu.rowAbove');
        },
        disabled: function disabled() {
          var selected = (0, _utils.getValidSelection)(this);
          return !selected || this.selection.selectedHeader.cols || this.countRows() >= this.getSettings().maxRows;
        },
        hidden: function hidden() {
          return !this.getSettings().allowInsertRow;
        }
      };
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.KEY = undefined;
    exports.default = rowBelowItem;
    var _utils = __webpack_require__(19);
    var KEY = exports.KEY = 'row_below';

    function rowBelowItem() {
      return {
        key: KEY,
        name: 'Insert row below',
        callback: function callback(key, selection) {
          this.alter('insert_row', selection.end.row + 1, 1, 'ContextMenu.rowBelow');
        },
        disabled: function disabled() {
          var selected = (0, _utils.getValidSelection)(this);
          return !selected || this.selection.selectedHeader.cols || this.countRows() >= this.getSettings().maxRows;
        },
        hidden: function hidden() {
          return !this.getSettings().allowInsertRow;
        }
      };
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.default = undoItem;
    var KEY = exports.KEY = 'undo';

    function undoItem() {
      return {
        key: KEY,
        name: 'Undo',
        callback: function callback() {
          this.undo();
        },
        disabled: function disabled() {
          return this.undoRedo && !this.undoRedo.isUndoAvailable();
        }
      };
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.default = copyItem;

    function copyItem(copyPastePlugin) {
      return {
        key: 'copy',
        name: 'Copy',
        callback: function callback() {
          copyPastePlugin.setCopyableText();
          copyPastePlugin.copy(true);
        },
        disabled: function disabled() {
          return !copyPastePlugin.hot.getSelected();
        },
        hidden: false
      };
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.default = cutItem;

    function cutItem(copyPastePlugin) {
      return {
        key: 'cut',
        name: 'Cut',
        callback: function callback() {
          copyPastePlugin.setCopyableText();
          copyPastePlugin.cut(true);
        },
        disabled: function disabled() {
          return !copyPastePlugin.hot.getSelected();
        },
        hidden: false
      };
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
      return typeof obj;
    } : function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _base = __webpack_require__(16);
    var _base2 = _interopRequireDefault(_base);
    var _pluginHooks = __webpack_require__(11);
    var _pluginHooks2 = _interopRequireDefault(_pluginHooks);
    var _SheetClip = __webpack_require__(249);
    var _SheetClip2 = _interopRequireDefault(_SheetClip);
    var _src = __webpack_require__(14);
    var _unicode = __webpack_require__(15);
    var _element = __webpack_require__(0);
    var _array = __webpack_require__(2);
    var _number = __webpack_require__(5);
    var _event = __webpack_require__(7);
    var _plugins = __webpack_require__(9);
    var _textarea = __webpack_require__(358);
    var _textarea2 = _interopRequireDefault(_textarea);
    var _copy = __webpack_require__(355);
    var _copy2 = _interopRequireDefault(_copy);
    var _cut = __webpack_require__(356);
    var _cut2 = _interopRequireDefault(_cut);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    __webpack_require__(300);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    _pluginHooks2.default.getSingleton().register('afterCopyLimit');
    _pluginHooks2.default.getSingleton().register('modifyCopyableRange');
    _pluginHooks2.default.getSingleton().register('beforeCut');
    _pluginHooks2.default.getSingleton().register('afterCut');
    _pluginHooks2.default.getSingleton().register('beforePaste');
    _pluginHooks2.default.getSingleton().register('afterPaste');
    _pluginHooks2.default.getSingleton().register('beforeCopy');
    _pluginHooks2.default.getSingleton().register('afterCopy');
    var ROWS_LIMIT = 1000;
    var COLUMNS_LIMIT = 1000;
    var privatePool = new WeakMap();
    var CopyPaste = function (_BasePlugin) {
      _inherits(CopyPaste, _BasePlugin);

      function CopyPaste(hotInstance) {
        _classCallCheck(this, CopyPaste);
        var _this = _possibleConstructorReturn(this, (CopyPaste.__proto__ || Object.getPrototypeOf(CopyPaste)).call(this, hotInstance));
        _this.eventManager = new _eventManager2.default(_this);
        _this.columnsLimit = COLUMNS_LIMIT;
        _this.copyableRanges = [];
        _this.pasteMode = 'overwrite';
        _this.rowsLimit = ROWS_LIMIT;
        _this.textarea = void 0;
        privatePool.set(_this, {
          isTriggeredByPaste: false
        });
        return _this;
      }
      _createClass(CopyPaste, [{
        key: 'isEnabled',
        value: function isEnabled() {
          return !!this.hot.getSettings().copyPaste;
        }
      }, {
        key: 'enablePlugin',
        value: function enablePlugin() {
          var _this2 = this;
          if (this.enabled) {
            return;
          }
          var settings = this.hot.getSettings();
          this.textarea = _textarea2.default.getSingleton();
          if (_typeof(settings.copyPaste) === 'object') {
            this.pasteMode = settings.copyPaste.pasteMode || this.pasteMode;
            this.rowsLimit = settings.copyPaste.rowsLimit || this.rowsLimit;
            this.columnsLimit = settings.copyPaste.columnsLimit || this.columnsLimit;
          }
          this.addHook('afterContextMenuDefaultOptions', function (options) {
            return _this2.onAfterContextMenuDefaultOptions(options);
          });
          this.addHook('beforeKeyDown', function (event) {
            return _this2.onBeforeKeyDown(event);
          });
          this.registerEvents();
          _get(CopyPaste.prototype.__proto__ || Object.getPrototypeOf(CopyPaste.prototype), 'enablePlugin', this).call(this);
        }
      }, {
        key: 'updatePlugin',
        value: function updatePlugin() {
          this.disablePlugin();
          this.enablePlugin();
          _get(CopyPaste.prototype.__proto__ || Object.getPrototypeOf(CopyPaste.prototype), 'updatePlugin', this).call(this);
        }
      }, {
        key: 'disablePlugin',
        value: function disablePlugin() {
          if (this.textarea) {
            this.textarea.destroy();
          }
          _get(CopyPaste.prototype.__proto__ || Object.getPrototypeOf(CopyPaste.prototype), 'disablePlugin', this).call(this);
        }
      }, {
        key: 'setCopyableText',
        value: function setCopyableText() {
          var selRange = this.hot.getSelectedRange();
          if (!selRange) {
            return;
          }
          var topLeft = selRange.getTopLeftCorner();
          var bottomRight = selRange.getBottomRightCorner();
          var startRow = topLeft.row;
          var startCol = topLeft.col;
          var endRow = bottomRight.row;
          var endCol = bottomRight.col;
          var finalEndRow = Math.min(endRow, startRow + this.rowsLimit - 1);
          var finalEndCol = Math.min(endCol, startCol + this.columnsLimit - 1);
          this.copyableRanges.length = 0;
          this.copyableRanges.push({
            startRow: startRow,
            startCol: startCol,
            endRow: finalEndRow,
            endCol: finalEndCol
          });
          this.copyableRanges = this.hot.runHooks('modifyCopyableRange', this.copyableRanges);
          var copyableData = this.getRangedCopyableData(this.copyableRanges);
          this.textarea.setValue(copyableData);
          if (endRow !== finalEndRow || endCol !== finalEndCol) {
            this.hot.runHooks('afterCopyLimit', endRow - startRow + 1, endCol - startCol + 1, this.rowsLimit, this.columnsLimit);
          }
        }
      }, {
        key: 'getRangedCopyableData',
        value: function getRangedCopyableData(ranges) {
          var _this3 = this;
          var dataSet = [];
          var copyableRows = [];
          var copyableColumns = [];
          (0, _array.arrayEach)(ranges, function (range) {
            (0, _number.rangeEach)(range.startRow, range.endRow, function (row) {
              if (copyableRows.indexOf(row) === -1) {
                copyableRows.push(row);
              }
            });
            (0, _number.rangeEach)(range.startCol, range.endCol, function (column) {
              if (copyableColumns.indexOf(column) === -1) {
                copyableColumns.push(column);
              }
            });
          });
          (0, _array.arrayEach)(copyableRows, function (row) {
            var rowSet = [];
            (0, _array.arrayEach)(copyableColumns, function (column) {
              rowSet.push(_this3.hot.getCopyableData(row, column));
            });
            dataSet.push(rowSet);
          });
          return _SheetClip2.default.stringify(dataSet);
        }
      }, {
        key: 'getRangedData',
        value: function getRangedData(ranges) {
          var _this4 = this;
          var dataSet = [];
          var copyableRows = [];
          var copyableColumns = [];
          (0, _array.arrayEach)(ranges, function (range) {
            (0, _number.rangeEach)(range.startRow, range.endRow, function (row) {
              if (copyableRows.indexOf(row) === -1) {
                copyableRows.push(row);
              }
            });
            (0, _number.rangeEach)(range.startCol, range.endCol, function (column) {
              if (copyableColumns.indexOf(column) === -1) {
                copyableColumns.push(column);
              }
            });
          });
          (0, _array.arrayEach)(copyableRows, function (row) {
            var rowSet = [];
            (0, _array.arrayEach)(copyableColumns, function (column) {
              rowSet.push(_this4.hot.getCopyableData(row, column));
            });
            dataSet.push(rowSet);
          });
          return dataSet;
        }
      }, {
        key: 'copy',
        value: function copy(isTriggeredByClick) {
          var rangedData = this.getRangedData(this.copyableRanges);
          var allowCopying = !!this.hot.runHooks('beforeCopy', rangedData, this.copyableRanges);
          if (allowCopying) {
            this.textarea.setValue(_SheetClip2.default.stringify(rangedData));
            this.textarea.select();
            if (isTriggeredByClick) {
              document.execCommand('copy');
            }
            this.hot.runHooks('afterCopy', rangedData, this.copyableRanges);
          } else {
            this.textarea.setValue('');
          }
        }
      }, {
        key: 'cut',
        value: function cut(isTriggeredByClick) {
          var rangedData = this.getRangedData(this.copyableRanges);
          var allowCuttingOut = !!this.hot.runHooks('beforeCut', rangedData, this.copyableRanges);
          if (allowCuttingOut) {
            this.textarea.setValue(_SheetClip2.default.stringify(rangedData));
            this.hot.selection.empty();
            this.textarea.select();
            if (isTriggeredByClick) {
              document.execCommand('cut');
            }
            this.hot.runHooks('afterCut', rangedData, this.copyableRanges);
          } else {
            this.textarea.setValue('');
          }
        }
      }, {
        key: 'paste',
        value: function paste() {
          var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
          this.textarea.setValue(value);
          this.onPaste();
          this.onInput();
        }
      }, {
        key: 'registerEvents',
        value: function registerEvents() {
          var _this5 = this;
          this.eventManager.addEventListener(this.textarea.element, 'paste', function (event) {
            return _this5.onPaste(event);
          });
          this.eventManager.addEventListener(this.textarea.element, 'input', function (event) {
            return _this5.onInput(event);
          });
        }
      }, {
        key: 'triggerPaste',
        value: function triggerPaste() {
          this.textarea.select();
          this.onPaste();
        }
      }, {
        key: 'onPaste',
        value: function onPaste() {
          var priv = privatePool.get(this);
          priv.isTriggeredByPaste = true;
        }
      }, {
        key: 'onInput',
        value: function onInput() {
          var _this6 = this;
          var priv = privatePool.get(this);
          if (!this.hot.isListening() || !priv.isTriggeredByPaste) {
            return;
          }
          priv.isTriggeredByPaste = false;
          var input = void 0,
            inputArray = void 0,
            selected = void 0,
            coordsFrom = void 0,
            coordsTo = void 0,
            cellRange = void 0,
            topLeftCorner = void 0,
            bottomRightCorner = void 0,
            areaStart = void 0,
            areaEnd = void 0;
          input = this.textarea.getValue();
          inputArray = _SheetClip2.default.parse(input);
          var allowPasting = !!this.hot.runHooks('beforePaste', inputArray, this.copyableRanges);
          if (!allowPasting) {
            return;
          }
          selected = this.hot.getSelected();
          coordsFrom = new _src.CellCoords(selected[0], selected[1]);
          coordsTo = new _src.CellCoords(selected[2], selected[3]);
          cellRange = new _src.CellRange(coordsFrom, coordsFrom, coordsTo);
          topLeftCorner = cellRange.getTopLeftCorner();
          bottomRightCorner = cellRange.getBottomRightCorner();
          areaStart = topLeftCorner;
          areaEnd = new _src.CellCoords(Math.max(bottomRightCorner.row, inputArray.length - 1 + topLeftCorner.row), Math.max(bottomRightCorner.col, inputArray[0].length - 1 + topLeftCorner.col));
          var isSelRowAreaCoverInputValue = coordsTo.row - coordsFrom.row >= inputArray.length - 1;
          var isSelColAreaCoverInputValue = coordsTo.col - coordsFrom.col >= inputArray[0].length - 1;
          this.hot.addHookOnce('afterChange', function (changes, source) {
            var changesLength = changes ? changes.length : 0;
            if (changesLength) {
              var offset = {
                row: 0,
                col: 0
              };
              var highestColumnIndex = -1;
              (0, _array.arrayEach)(changes, function (change, index) {
                var nextChange = changesLength > index + 1 ? changes[index + 1] : null;
                if (nextChange) {
                  if (!isSelRowAreaCoverInputValue) {
                    offset.row += Math.max(nextChange[0] - change[0] - 1, 0);
                  }
                  if (!isSelColAreaCoverInputValue && change[1] > highestColumnIndex) {
                    highestColumnIndex = change[1];
                    offset.col += Math.max(nextChange[1] - change[1] - 1, 0);
                  }
                }
              });
              _this6.hot.selectCell(areaStart.row, areaStart.col, areaEnd.row + offset.row, areaEnd.col + offset.col);
            }
          });
          this.hot.populateFromArray(areaStart.row, areaStart.col, inputArray, areaEnd.row, areaEnd.col, 'CopyPaste.paste', this.pasteMode);
          this.hot.runHooks('afterPaste', inputArray, this.copyableRanges);
        }
      }, {
        key: 'onAfterContextMenuDefaultOptions',
        value: function onAfterContextMenuDefaultOptions(options) {
          options.items.push({
            name: '---------'
          }, (0, _copy2.default)(this), (0, _cut2.default)(this));
        }
      }, {
        key: 'onBeforeKeyDown',
        value: function onBeforeKeyDown(event) {
          var _this7 = this;
          if (!this.hot.getSelected()) {
            return;
          }
          if (this.hot.getActiveEditor() && this.hot.getActiveEditor().isOpened()) {
            return;
          }
          if ((0, _event.isImmediatePropagationStopped)(event)) {
            return;
          }
          if (!this.textarea.isActive() && (0, _element.getSelectionText)()) {
            return;
          }
          if ((0, _unicode.isCtrlKey)(event.keyCode)) {
            if (this.hot.getSettings().fragmentSelection && (0, _element.getSelectionText)()) {
              return;
            }
            this.setCopyableText();
            (0, _event.stopImmediatePropagation)(event);
            return;
          }
          var ctrlDown = (event.ctrlKey || event.metaKey) && !event.altKey;
          if (ctrlDown) {
            if (event.keyCode == _unicode.KEY_CODES.A) {
              setTimeout(function () {
                _this7.setCopyableText();
              }, 0);
            }
            if (event.keyCode == _unicode.KEY_CODES.X) {
              this.cut();
            }
            if (event.keyCode == _unicode.KEY_CODES.C) {
              this.copy();
            }
            if (event.keyCode == _unicode.KEY_CODES.V) {
              this.triggerPaste();
            }
          }
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          if (this.textarea) {
            this.textarea.destroy();
          }
          _get(CopyPaste.prototype.__proto__ || Object.getPrototypeOf(CopyPaste.prototype), 'destroy', this).call(this);
        }
      }]);
      return CopyPaste;
    }(_base2.default);
    (0, _plugins.registerPlugin)('CopyPaste', CopyPaste);
    exports.default = CopyPaste;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var Textarea = function () {
      _createClass(Textarea, null, [{
        key: 'getSingleton',
        value: function getSingleton() {
          globalSingleton.append();
          return globalSingleton;
        }
      }]);

      function Textarea() {
        _classCallCheck(this, Textarea);
        this.element = void 0;
        this.isAppended = false;
        this.refCounter = 0;
      }
      _createClass(Textarea, [{
        key: 'append',
        value: function append() {
          if (this.hasBeenDestroyed()) {
            this.create();
          }
          this.refCounter++;
          if (!this.isAppended && document.body) {
            if (document.body) {
              this.isAppended = true;
              document.body.appendChild(this.element);
            }
          }
        }
      }, {
        key: 'create',
        value: function create() {
          this.element = document.createElement('textarea');
          this.element.id = 'HandsontableCopyPaste';
          this.element.className = 'copyPaste';
          this.element.tabIndex = -1;
          this.element.autocomplete = 'off';
          this.element.wrap = 'off';
        }
      }, {
        key: 'deselect',
        value: function deselect() {
          if (this.element === document.activeElement) {
            document.activeElement.blur();
          }
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          this.refCounter--;
          this.refCounter = this.refCounter < 0 ? 0 : this.refCounter;
          if (this.hasBeenDestroyed() && this.element && this.element.parentNode) {
            this.element.parentNode.removeChild(this.element);
            this.element = null;
            this.isAppended = false;
          }
        }
      }, {
        key: 'getValue',
        value: function getValue() {
          return this.element.value;
        }
      }, {
        key: 'hasBeenDestroyed',
        value: function hasBeenDestroyed() {
          return this.refCounter < 1;
        }
      }, {
        key: 'isActive',
        value: function isActive() {
          return this.element === document.activeElement;
        }
      }, {
        key: 'select',
        value: function select() {
          this.element.focus();
          this.element.select();
        }
      }, {
        key: 'setValue',
        value: function setValue(data) {
          this.element.value = data;
        }
      }]);
      return Textarea;
    }();
    var globalSingleton = new Textarea();
    exports.default = Textarea;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _pluginHooks = __webpack_require__(11);
    var _pluginHooks2 = _interopRequireDefault(_pluginHooks);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _plugins = __webpack_require__(9);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function DragToScroll() {
      this.boundaries = null;
      this.callback = null;
    }
    DragToScroll.prototype.setBoundaries = function (boundaries) {
      this.boundaries = boundaries;
    };
    DragToScroll.prototype.setCallback = function (callback) {
      this.callback = callback;
    };
    DragToScroll.prototype.check = function (x, y) {
      var diffX = 0;
      var diffY = 0;
      if (y < this.boundaries.top) {
        diffY = y - this.boundaries.top;
      } else if (y > this.boundaries.bottom) {
        diffY = y - this.boundaries.bottom;
      }
      if (x < this.boundaries.left) {
        diffX = x - this.boundaries.left;
      } else if (x > this.boundaries.right) {
        diffX = x - this.boundaries.right;
      }
      this.callback(diffX, diffY);
    };
    var dragToScroll;
    var instance;
    var setupListening = function setupListening(instance) {
      instance.dragToScrollListening = false;
      var scrollHandler = instance.view.wt.wtTable.holder;
      dragToScroll = new DragToScroll();
      if (scrollHandler === window) {
        return;
      }
      dragToScroll.setBoundaries(scrollHandler.getBoundingClientRect());
      dragToScroll.setCallback(function (scrollX, scrollY) {
        if (scrollX < 0) {
          scrollHandler.scrollLeft -= 50;
        } else if (scrollX > 0) {
          scrollHandler.scrollLeft += 50;
        }
        if (scrollY < 0) {
          scrollHandler.scrollTop -= 20;
        } else if (scrollY > 0) {
          scrollHandler.scrollTop += 20;
        }
      });
      instance.dragToScrollListening = true;
    };
    _pluginHooks2.default.getSingleton().add('afterInit', function () {
      var instance = this;
      var eventManager = new _eventManager2.default(this);
      eventManager.addEventListener(document, 'mouseup', function () {
        instance.dragToScrollListening = false;
      });
      eventManager.addEventListener(document, 'mousemove', function (event) {
        if (instance.dragToScrollListening) {
          dragToScroll.check(event.clientX, event.clientY);
        }
      });
    });
    _pluginHooks2.default.getSingleton().add('afterDestroy', function () {
      new _eventManager2.default(this).clear();
    });
    _pluginHooks2.default.getSingleton().add('afterOnCellMouseDown', function () {
      setupListening(this);
    });
    _pluginHooks2.default.getSingleton().add('afterOnCellCornerMouseDown', function () {
      setupListening(this);
    });
    exports.default = DragToScroll;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.default = freezeColumnItem;

    function freezeColumnItem(manualColumnFreezePlugin) {
      return {
        key: 'freeze_column',
        name: 'Freeze this column',
        callback: function callback() {
          var selectedColumn = this.getSelectedRange().from.col;
          manualColumnFreezePlugin.freezeColumn(selectedColumn);
          this.render();
          this.view.wt.wtOverlays.adjustElementsSize(true);
        },
        hidden: function hidden() {
          var selection = this.getSelectedRange();
          var hide = false;
          if (selection === void 0) {
            hide = true;
          } else if (selection.from.col !== selection.to.col || selection.from.col <= this.getSettings().fixedColumnsLeft - 1) {
            hide = true;
          }
          return hide;
        }
      };
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.default = unfreezeColumnItem;

    function unfreezeColumnItem(manualColumnFreezePlugin) {
      return {
        key: 'unfreeze_column',
        name: 'Unfreeze this column',
        callback: function callback() {
          var selectedColumn = this.getSelectedRange().from.col;
          manualColumnFreezePlugin.unfreezeColumn(selectedColumn);
          this.render();
          this.view.wt.wtOverlays.adjustElementsSize(true);
        },
        hidden: function hidden() {
          var selection = this.getSelectedRange();
          var hide = false;
          if (selection === void 0) {
            hide = true;
          } else if (selection.from.col !== selection.to.col || selection.from.col >= this.getSettings().fixedColumnsLeft) {
            hide = true;
          }
          return hide;
        }
      };
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _base = __webpack_require__(16);
    var _base2 = _interopRequireDefault(_base);
    var _plugins = __webpack_require__(9);
    var _array = __webpack_require__(2);
    var _freezeColumn = __webpack_require__(360);
    var _freezeColumn2 = _interopRequireDefault(_freezeColumn);
    var _unfreezeColumn = __webpack_require__(361);
    var _unfreezeColumn2 = _interopRequireDefault(_unfreezeColumn);
    __webpack_require__(301);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var privatePool = new WeakMap();
    var ManualColumnFreeze = function (_BasePlugin) {
      _inherits(ManualColumnFreeze, _BasePlugin);

      function ManualColumnFreeze(hotInstance) {
        _classCallCheck(this, ManualColumnFreeze);
        var _this = _possibleConstructorReturn(this, (ManualColumnFreeze.__proto__ || Object.getPrototypeOf(ManualColumnFreeze)).call(this, hotInstance));
        privatePool.set(_this, {
          moveByFreeze: false,
          afterFirstUse: false
        });
        _this.frozenColumnsBasePositions = [];
        _this.manualColumnMovePlugin = void 0;
        return _this;
      }
      _createClass(ManualColumnFreeze, [{
        key: 'isEnabled',
        value: function isEnabled() {
          return !!this.hot.getSettings().manualColumnFreeze;
        }
      }, {
        key: 'enablePlugin',
        value: function enablePlugin() {
          var _this2 = this;
          if (this.enabled) {
            return;
          }
          this.addHook('afterContextMenuDefaultOptions', function (options) {
            return _this2.addContextMenuEntry(options);
          });
          this.addHook('afterInit', function () {
            return _this2.onAfterInit();
          });
          this.addHook('beforeColumnMove', function (rows, target) {
            return _this2.onBeforeColumnMove(rows, target);
          });
          _get(ManualColumnFreeze.prototype.__proto__ || Object.getPrototypeOf(ManualColumnFreeze.prototype), 'enablePlugin', this).call(this);
        }
      }, {
        key: 'disablePlugin',
        value: function disablePlugin() {
          var priv = privatePool.get(this);
          priv.afterFirstUse = false;
          priv.moveByFreeze = false;
          _get(ManualColumnFreeze.prototype.__proto__ || Object.getPrototypeOf(ManualColumnFreeze.prototype), 'disablePlugin', this).call(this);
        }
      }, {
        key: 'updatePlugin',
        value: function updatePlugin() {
          this.disablePlugin();
          this.enablePlugin();
          _get(ManualColumnFreeze.prototype.__proto__ || Object.getPrototypeOf(ManualColumnFreeze.prototype), 'updatePlugin', this).call(this);
        }
      }, {
        key: 'freezeColumn',
        value: function freezeColumn(column) {
          var priv = privatePool.get(this);
          var settings = this.hot.getSettings();
          if (!priv.afterFirstUse) {
            priv.afterFirstUse = true;
          }
          if (settings.fixedColumnsLeft === this.hot.countCols() || column <= settings.fixedColumnsLeft - 1) {
            return;
          }
          priv.moveByFreeze = true;
          if (column !== this.getMovePlugin().columnsMapper.getValueByIndex(column)) {
            this.frozenColumnsBasePositions[settings.fixedColumnsLeft] = column;
          }
          this.getMovePlugin().moveColumn(column, settings.fixedColumnsLeft++);
        }
      }, {
        key: 'unfreezeColumn',
        value: function unfreezeColumn(column) {
          var priv = privatePool.get(this);
          var settings = this.hot.getSettings();
          if (!priv.afterFirstUse) {
            priv.afterFirstUse = true;
          }
          if (settings.fixedColumnsLeft <= 0 || column > settings.fixedColumnsLeft - 1) {
            return;
          }
          var returnCol = this.getBestColumnReturnPosition(column);
          priv.moveByFreeze = true;
          settings.fixedColumnsLeft--;
          this.getMovePlugin().moveColumn(column, returnCol + 1);
        }
      }, {
        key: 'getMovePlugin',
        value: function getMovePlugin() {
          if (!this.manualColumnMovePlugin) {
            this.manualColumnMovePlugin = this.hot.getPlugin('manualColumnMove');
          }
          return this.manualColumnMovePlugin;
        }
      }, {
        key: 'getBestColumnReturnPosition',
        value: function getBestColumnReturnPosition(column) {
          var movePlugin = this.getMovePlugin();
          var settings = this.hot.getSettings();
          var i = settings.fixedColumnsLeft;
          var j = movePlugin.columnsMapper.getValueByIndex(i);
          var initialCol = void 0;
          if (this.frozenColumnsBasePositions[column] == null) {
            initialCol = movePlugin.columnsMapper.getValueByIndex(column);
            while (j < initialCol) {
              i++;
              j = movePlugin.columnsMapper.getValueByIndex(i);
            }
          } else {
            initialCol = this.frozenColumnsBasePositions[column];
            this.frozenColumnsBasePositions[column] = void 0;
            while (j <= initialCol) {
              i++;
              j = movePlugin.columnsMapper.getValueByIndex(i);
            }
            i = j;
          }
          return i - 1;
        }
      }, {
        key: 'addContextMenuEntry',
        value: function addContextMenuEntry(options) {
          options.items.push({
            name: '---------'
          }, (0, _freezeColumn2.default)(this), (0, _unfreezeColumn2.default)(this));
        }
      }, {
        key: 'onAfterInit',
        value: function onAfterInit() {
          if (!this.getMovePlugin().isEnabled()) {
            this.getMovePlugin().enablePlugin();
          }
        }
      }, {
        key: 'onBeforeColumnMove',
        value: function onBeforeColumnMove(rows, target) {
          var priv = privatePool.get(this);
          if (priv.afterFirstUse && !priv.moveByFreeze) {
            var frozenLen = this.hot.getSettings().fixedColumnsLeft;
            var disallowMoving = target < frozenLen;
            if (!disallowMoving) {
              (0, _array.arrayEach)(rows, function (value, index, array) {
                if (value < frozenLen) {
                  disallowMoving = true;
                  return false;
                }
              });
            }
            if (disallowMoving) {
              return false;
            }
          }
          if (priv.moveByFreeze) {
            priv.moveByFreeze = false;
          }
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          _get(ManualColumnFreeze.prototype.__proto__ || Object.getPrototypeOf(ManualColumnFreeze.prototype), 'destroy', this).call(this);
        }
      }]);
      return ManualColumnFreeze;
    }(_base2.default);
    (0, _plugins.registerPlugin)('manualColumnFreeze', ManualColumnFreeze);
    exports.default = ManualColumnFreeze;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _arrayMapper = __webpack_require__(265);
    var _arrayMapper2 = _interopRequireDefault(_arrayMapper);
    var _array = __webpack_require__(2);
    var _object = __webpack_require__(3);
    var _number = __webpack_require__(5);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var ColumnsMapper = function () {
      function ColumnsMapper(manualColumnMove) {
        _classCallCheck(this, ColumnsMapper);
        this.manualColumnMove = manualColumnMove;
      }
      _createClass(ColumnsMapper, [{
        key: 'createMap',
        value: function createMap(length) {
          var _this = this;
          var originLength = length === void 0 ? this._arrayMap.length : length;
          this._arrayMap.length = 0;
          (0, _number.rangeEach)(originLength - 1, function (itemIndex) {
            _this._arrayMap[itemIndex] = itemIndex;
          });
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          this._arrayMap = null;
        }
      }, {
        key: 'moveColumn',
        value: function moveColumn(from, to) {
          var indexToMove = this._arrayMap[from];
          this._arrayMap[from] = null;
          this._arrayMap.splice(to, 0, indexToMove);
        }
      }, {
        key: 'clearNull',
        value: function clearNull() {
          this._arrayMap = (0, _array.arrayFilter)(this._arrayMap, function (i) {
            return i !== null;
          });
        }
      }]);
      return ColumnsMapper;
    }();
    (0, _object.mixin)(ColumnsMapper, _arrayMapper2.default);
    exports.default = ColumnsMapper;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _base = __webpack_require__(16);
    var _base2 = _interopRequireDefault(_base);
    var _pluginHooks = __webpack_require__(11);
    var _pluginHooks2 = _interopRequireDefault(_pluginHooks);
    var _array = __webpack_require__(2);
    var _element = __webpack_require__(0);
    var _number = __webpack_require__(5);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _plugins = __webpack_require__(9);
    var _columnsMapper = __webpack_require__(363);
    var _columnsMapper2 = _interopRequireDefault(_columnsMapper);
    var _backlight = __webpack_require__(365);
    var _backlight2 = _interopRequireDefault(_backlight);
    var _guideline = __webpack_require__(366);
    var _guideline2 = _interopRequireDefault(_guideline);
    var _src = __webpack_require__(14);
    __webpack_require__(302);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    _pluginHooks2.default.getSingleton().register('beforeColumnMove');
    _pluginHooks2.default.getSingleton().register('afterColumnMove');
    _pluginHooks2.default.getSingleton().register('unmodifyCol');
    var privatePool = new WeakMap();
    var CSS_PLUGIN = 'ht__manualColumnMove';
    var CSS_SHOW_UI = 'show-ui';
    var CSS_ON_MOVING = 'on-moving--columns';
    var CSS_AFTER_SELECTION = 'after-selection--columns';
    var ManualColumnMove = function (_BasePlugin) {
      _inherits(ManualColumnMove, _BasePlugin);

      function ManualColumnMove(hotInstance) {
        _classCallCheck(this, ManualColumnMove);
        var _this = _possibleConstructorReturn(this, (ManualColumnMove.__proto__ || Object.getPrototypeOf(ManualColumnMove)).call(this, hotInstance));
        privatePool.set(_this, {
          columnsToMove: [],
          countCols: 0,
          fixedColumns: 0,
          pressed: void 0,
          disallowMoving: void 0,
          target: {
            eventPageX: void 0,
            coords: void 0,
            TD: void 0,
            col: void 0
          }
        });
        _this.removedColumns = [];
        _this.columnsMapper = new _columnsMapper2.default(_this);
        _this.eventManager = new _eventManager2.default(_this);
        _this.backlight = new _backlight2.default(hotInstance);
        _this.guideline = new _guideline2.default(hotInstance);
        return _this;
      }
      _createClass(ManualColumnMove, [{
        key: 'isEnabled',
        value: function isEnabled() {
          return !!this.hot.getSettings().manualColumnMove;
        }
      }, {
        key: 'enablePlugin',
        value: function enablePlugin() {
          var _this2 = this;
          if (this.enabled) {
            return;
          }
          this.addHook('beforeOnCellMouseDown', function (event, coords, TD, blockCalculations) {
            return _this2.onBeforeOnCellMouseDown(event, coords, TD, blockCalculations);
          });
          this.addHook('beforeOnCellMouseOver', function (event, coords, TD, blockCalculations) {
            return _this2.onBeforeOnCellMouseOver(event, coords, TD, blockCalculations);
          });
          this.addHook('afterScrollVertically', function () {
            return _this2.onAfterScrollVertically();
          });
          this.addHook('modifyCol', function (row, source) {
            return _this2.onModifyCol(row, source);
          });
          this.addHook('beforeRemoveCol', function (index, amount) {
            return _this2.onBeforeRemoveCol(index, amount);
          });
          this.addHook('afterRemoveCol', function (index, amount) {
            return _this2.onAfterRemoveCol(index, amount);
          });
          this.addHook('afterCreateCol', function (index, amount) {
            return _this2.onAfterCreateCol(index, amount);
          });
          this.addHook('afterLoadData', function (firstTime) {
            return _this2.onAfterLoadData(firstTime);
          });
          this.addHook('unmodifyCol', function (column) {
            return _this2.onUnmodifyCol(column);
          });
          this.registerEvents();
          (0, _element.addClass)(this.hot.rootElement, CSS_PLUGIN);
          _get(ManualColumnMove.prototype.__proto__ || Object.getPrototypeOf(ManualColumnMove.prototype), 'enablePlugin', this).call(this);
        }
      }, {
        key: 'updatePlugin',
        value: function updatePlugin() {
          this.disablePlugin();
          this.enablePlugin();
          this.onAfterPluginsInitialized();
          _get(ManualColumnMove.prototype.__proto__ || Object.getPrototypeOf(ManualColumnMove.prototype), 'updatePlugin', this).call(this);
        }
      }, {
        key: 'disablePlugin',
        value: function disablePlugin() {
          var pluginSettings = this.hot.getSettings().manualColumnMove;
          if (Array.isArray(pluginSettings)) {
            this.columnsMapper.clearMap();
          } (0, _element.removeClass)(this.hot.rootElement, CSS_PLUGIN);
          this.unregisterEvents();
          this.backlight.destroy();
          this.guideline.destroy();
          _get(ManualColumnMove.prototype.__proto__ || Object.getPrototypeOf(ManualColumnMove.prototype), 'disablePlugin', this).call(this);
        }
      }, {
        key: 'moveColumn',
        value: function moveColumn(column, target) {
          this.moveColumns([column], target);
        }
      }, {
        key: 'moveColumns',
        value: function moveColumns(columns, target) {
          var _this3 = this;
          var priv = privatePool.get(this);
          var beforeColumnHook = this.hot.runHooks('beforeColumnMove', columns, target);
          priv.disallowMoving = !beforeColumnHook;
          if (beforeColumnHook !== false) {
            (0, _array.arrayEach)(columns, function (column, index, array) {
              array[index] = _this3.columnsMapper.getValueByIndex(column);
            });
            (0, _array.arrayEach)(columns, function (column, index) {
              var actualPosition = _this3.columnsMapper.getIndexByValue(column);
              if (actualPosition !== target) {
                _this3.columnsMapper.moveColumn(actualPosition, target + index);
              }
            });
            this.columnsMapper.clearNull();
          }
          this.hot.runHooks('afterColumnMove', columns, target);
        }
      }, {
        key: 'changeSelection',
        value: function changeSelection(startColumn, endColumn) {
          var selection = this.hot.selection;
          var lastRowIndex = this.hot.countRows() - 1;
          selection.setRangeStartOnly(new _src.CellCoords(0, startColumn));
          selection.setRangeEnd(new _src.CellCoords(lastRowIndex, endColumn), false);
        }
      }, {
        key: 'getColumnsWidth',
        value: function getColumnsWidth(from, to) {
          var width = 0;
          for (var i = from; i < to; i++) {
            var columnWidth = 0;
            if (i < 0) {
              columnWidth = this.hot.view.wt.wtTable.getColumnWidth(i) || 0;
            } else {
              columnWidth = this.hot.view.wt.wtTable.getStretchedColumnWidth(i) || 0;
            }
            width += columnWidth;
          }
          return width;
        }
      }, {
        key: 'initialSettings',
        value: function initialSettings() {
          var pluginSettings = this.hot.getSettings().manualColumnMove;
          if (Array.isArray(pluginSettings)) {
            this.moveColumns(pluginSettings, 0);
          } else if (pluginSettings !== void 0) {
            this.persistentStateLoad();
          }
        }
      }, {
        key: 'isFixedColumnsLeft',
        value: function isFixedColumnsLeft(column) {
          return column < this.hot.getSettings().fixedColumnsLeft;
        }
      }, {
        key: 'persistentStateSave',
        value: function persistentStateSave() {
          this.hot.runHooks('persistentStateSave', 'manualColumnMove', this.columnsMapper._arrayMap);
        }
      }, {
        key: 'persistentStateLoad',
        value: function persistentStateLoad() {
          var storedState = {};
          this.hot.runHooks('persistentStateLoad', 'manualColumnMove', storedState);
          if (storedState.value) {
            this.columnsMapper._arrayMap = storedState.value;
          }
        }
      }, {
        key: 'prepareColumnsToMoving',
        value: function prepareColumnsToMoving(start, end) {
          var selectedColumns = [];
          (0, _number.rangeEach)(start, end, function (i) {
            selectedColumns.push(i);
          });
          return selectedColumns;
        }
      }, {
        key: 'refreshPositions',
        value: function refreshPositions() {
          var priv = privatePool.get(this);
          var firstVisible = this.hot.view.wt.wtTable.getFirstVisibleColumn();
          var lastVisible = this.hot.view.wt.wtTable.getLastVisibleColumn();
          var wtTable = this.hot.view.wt.wtTable;
          var scrollableElement = this.hot.view.wt.wtOverlays.scrollableElement;
          var scrollLeft = typeof scrollableElement.scrollX === 'number' ? scrollableElement.scrollX : scrollableElement.scrollLeft;
          var tdOffsetLeft = this.hot.view.THEAD.offsetLeft + this.getColumnsWidth(0, priv.coordsColumn);
          var mouseOffsetLeft = priv.target.eventPageX - (priv.rootElementOffset - (scrollableElement.scrollX === void 0 ? scrollLeft : 0));
          var hiderWidth = wtTable.hider.offsetWidth;
          var tbodyOffsetLeft = wtTable.TBODY.offsetLeft;
          var backlightElemMarginLeft = this.backlight.getOffset().left;
          var backlightElemWidth = this.backlight.getSize().width;
          var rowHeaderWidth = 0;
          if (priv.rootElementOffset + wtTable.holder.offsetWidth + scrollLeft < priv.target.eventPageX) {
            if (priv.coordsColumn < priv.countCols) {
              priv.coordsColumn++;
            }
          }
          if (priv.hasRowHeaders) {
            rowHeaderWidth = this.hot.view.wt.wtOverlays.leftOverlay.clone.wtTable.getColumnHeader(-1).offsetWidth;
          }
          if (this.isFixedColumnsLeft(priv.coordsColumn)) {
            tdOffsetLeft += scrollLeft;
          }
          tdOffsetLeft += rowHeaderWidth;
          if (priv.coordsColumn < 0) {
            if (priv.fixedColumns > 0) {
              priv.target.col = 0;
            } else {
              priv.target.col = firstVisible > 0 ? firstVisible - 1 : firstVisible;
            }
          } else if (priv.target.TD.offsetWidth / 2 + tdOffsetLeft <= mouseOffsetLeft) {
            var newCoordsCol = priv.coordsColumn >= priv.countCols ? priv.countCols - 1 : priv.coordsColumn;
            priv.target.col = newCoordsCol + 1;
            tdOffsetLeft += priv.target.TD.offsetWidth;
            if (priv.target.col > lastVisible) {
              this.hot.scrollViewportTo(void 0, lastVisible + 1, void 0, true);
            }
          } else {
            priv.target.col = priv.coordsColumn;
            if (priv.target.col <= firstVisible && priv.target.col >= priv.fixedColumns) {
              this.hot.scrollViewportTo(void 0, firstVisible - 1);
            }
          }
          if (priv.target.col <= firstVisible && priv.target.col >= priv.fixedColumns) {
            this.hot.scrollViewportTo(void 0, firstVisible - 1);
          }
          var backlightLeft = mouseOffsetLeft;
          var guidelineLeft = tdOffsetLeft;
          if (mouseOffsetLeft + backlightElemWidth + backlightElemMarginLeft >= hiderWidth) {
            backlightLeft = hiderWidth - backlightElemWidth - backlightElemMarginLeft;
          } else if (mouseOffsetLeft + backlightElemMarginLeft < tbodyOffsetLeft + rowHeaderWidth) {
            backlightLeft = tbodyOffsetLeft + rowHeaderWidth + Math.abs(backlightElemMarginLeft);
          }
          if (tdOffsetLeft >= hiderWidth - 1) {
            guidelineLeft = hiderWidth - 1;
          } else if (guidelineLeft === 0) {
            guidelineLeft = 1;
          } else if (scrollableElement.scrollX !== void 0 && priv.coordsColumn < priv.fixedColumns) {
            guidelineLeft -= priv.rootElementOffset <= scrollableElement.scrollX ? priv.rootElementOffset : 0;
          }
          this.backlight.setPosition(null, backlightLeft);
          this.guideline.setPosition(null, guidelineLeft);
        }
      }, {
        key: 'updateColumnsMapper',
        value: function updateColumnsMapper() {
          var countCols = this.hot.countSourceCols();
          var columnsMapperLen = this.columnsMapper._arrayMap.length;
          if (columnsMapperLen === 0) {
            this.columnsMapper.createMap(countCols || this.hot.getSettings().startCols);
          } else if (columnsMapperLen < countCols) {
            var diff = countCols - columnsMapperLen;
            this.columnsMapper.insertItems(columnsMapperLen, diff);
          } else if (columnsMapperLen > countCols) {
            var maxIndex = countCols - 1;
            var columnsToRemove = [];
            (0, _array.arrayEach)(this.columnsMapper._arrayMap, function (value, index, array) {
              if (value > maxIndex) {
                columnsToRemove.push(index);
              }
            });
            this.columnsMapper.removeItems(columnsToRemove);
          }
        }
      }, {
        key: 'registerEvents',
        value: function registerEvents() {
          var _this4 = this;
          this.eventManager.addEventListener(document.documentElement, 'mousemove', function (event) {
            return _this4.onMouseMove(event);
          });
          this.eventManager.addEventListener(document.documentElement, 'mouseup', function () {
            return _this4.onMouseUp();
          });
        }
      }, {
        key: 'unregisterEvents',
        value: function unregisterEvents() {
          this.eventManager.clear();
        }
      }, {
        key: 'onBeforeOnCellMouseDown',
        value: function onBeforeOnCellMouseDown(event, coords, TD, blockCalculations) {
          var wtTable = this.hot.view.wt.wtTable;
          var isHeaderSelection = this.hot.selection.selectedHeader.cols;
          var selection = this.hot.getSelectedRange();
          var priv = privatePool.get(this);
          var isSortingElement = event.realTarget.className.indexOf('columnSorting') > -1;
          if (!selection || !isHeaderSelection || priv.pressed || event.button !== 0 || isSortingElement) {
            priv.pressed = false;
            priv.columnsToMove.length = 0;
            (0, _element.removeClass)(this.hot.rootElement, [CSS_ON_MOVING, CSS_SHOW_UI]);
            return;
          }
          var guidelineIsNotReady = this.guideline.isBuilt() && !this.guideline.isAppended();
          var backlightIsNotReady = this.backlight.isBuilt() && !this.backlight.isAppended();
          if (guidelineIsNotReady && backlightIsNotReady) {
            this.guideline.appendTo(wtTable.hider);
            this.backlight.appendTo(wtTable.hider);
          }
          var from = selection.from,
            to = selection.to;
          var start = Math.min(from.col, to.col);
          var end = Math.max(from.col, to.col);
          if (coords.row < 0 && coords.col >= start && coords.col <= end) {
            blockCalculations.column = true;
            priv.pressed = true;
            priv.target.eventPageX = event.pageX;
            priv.coordsColumn = coords.col;
            priv.target.TD = TD;
            priv.target.col = coords.col;
            priv.columnsToMove = this.prepareColumnsToMoving(start, end);
            priv.hasRowHeaders = !!this.hot.getSettings().rowHeaders;
            priv.countCols = this.hot.countCols();
            priv.fixedColumns = this.hot.getSettings().fixedColumnsLeft;
            priv.rootElementOffset = (0, _element.offset)(this.hot.rootElement).left;
            var countColumnsFrom = priv.hasRowHeaders ? -1 : 0;
            var topPos = wtTable.holder.scrollTop + wtTable.getColumnHeaderHeight(0) + 1;
            var fixedColumns = coords.col < priv.fixedColumns;
            var scrollableElement = this.hot.view.wt.wtOverlays.scrollableElement;
            var wrapperIsWindow = scrollableElement.scrollX ? scrollableElement.scrollX - priv.rootElementOffset : 0;
            var mouseOffset = event.layerX - (fixedColumns ? wrapperIsWindow : 0);
            var leftOffset = Math.abs(this.getColumnsWidth(start, coords.col) + mouseOffset);
            this.backlight.setPosition(topPos, this.getColumnsWidth(countColumnsFrom, start) + leftOffset);
            this.backlight.setSize(this.getColumnsWidth(start, end + 1), wtTable.hider.offsetHeight - topPos);
            this.backlight.setOffset(null, leftOffset * -1);
            (0, _element.addClass)(this.hot.rootElement, CSS_ON_MOVING);
          } else {
            (0, _element.removeClass)(this.hot.rootElement, CSS_AFTER_SELECTION);
            priv.pressed = false;
            priv.columnsToMove.length = 0;
          }
        }
      }, {
        key: 'onMouseMove',
        value: function onMouseMove(event) {
          var priv = privatePool.get(this);
          if (!priv.pressed) {
            return;
          }
          if (event.realTarget === this.backlight.element) {
            var width = this.backlight.getSize().width;
            this.backlight.setSize(0);
            setTimeout(function () {
              this.backlight.setPosition(width);
            });
          }
          priv.target.eventPageX = event.pageX;
          this.refreshPositions();
        }
      }, {
        key: 'onBeforeOnCellMouseOver',
        value: function onBeforeOnCellMouseOver(event, coords, TD, blockCalculations) {
          var selectedRange = this.hot.getSelectedRange();
          var priv = privatePool.get(this);
          if (!selectedRange || !priv.pressed) {
            return;
          }
          if (priv.columnsToMove.indexOf(coords.col) > -1) {
            (0, _element.removeClass)(this.hot.rootElement, CSS_SHOW_UI);
          } else {
            (0, _element.addClass)(this.hot.rootElement, CSS_SHOW_UI);
          }
          blockCalculations.row = true;
          blockCalculations.column = true;
          blockCalculations.cell = true;
          priv.coordsColumn = coords.col;
          priv.target.TD = TD;
        }
      }, {
        key: 'onMouseUp',
        value: function onMouseUp() {
          var priv = privatePool.get(this);
          priv.coordsColumn = void 0;
          priv.pressed = false;
          priv.backlightWidth = 0;
          (0, _element.removeClass)(this.hot.rootElement, [CSS_ON_MOVING, CSS_SHOW_UI, CSS_AFTER_SELECTION]);
          if (this.hot.selection.selectedHeader.cols) {
            (0, _element.addClass)(this.hot.rootElement, CSS_AFTER_SELECTION);
          }
          if (priv.columnsToMove.length < 1 || priv.target.col === void 0 || priv.columnsToMove.indexOf(priv.target.col) > -1) {
            return;
          }
          this.moveColumns(priv.columnsToMove, priv.target.col);
          this.persistentStateSave();
          this.hot.render();
          this.hot.view.wt.wtOverlays.adjustElementsSize(true);
          if (!priv.disallowMoving) {
            var selectionStart = this.columnsMapper.getIndexByValue(priv.columnsToMove[0]);
            var selectionEnd = this.columnsMapper.getIndexByValue(priv.columnsToMove[priv.columnsToMove.length - 1]);
            this.changeSelection(selectionStart, selectionEnd);
          }
          priv.columnsToMove.length = 0;
        }
      }, {
        key: 'onAfterScrollVertically',
        value: function onAfterScrollVertically() {
          var wtTable = this.hot.view.wt.wtTable;
          var headerHeight = wtTable.getColumnHeaderHeight(0) + 1;
          var scrollTop = wtTable.holder.scrollTop;
          var posTop = headerHeight + scrollTop;
          this.backlight.setPosition(posTop);
          this.backlight.setSize(null, wtTable.hider.offsetHeight - posTop);
        }
      }, {
        key: 'onAfterCreateCol',
        value: function onAfterCreateCol(index, amount) {
          this.columnsMapper.shiftItems(index, amount);
        }
      }, {
        key: 'onBeforeRemoveCol',
        value: function onBeforeRemoveCol(index, amount) {
          var _this5 = this;
          this.removedColumns.length = 0;
          if (index !== false) {
            (0, _number.rangeEach)(index, index + amount - 1, function (removedIndex) {
              _this5.removedColumns.push(_this5.hot.runHooks('modifyCol', removedIndex, _this5.pluginName));
            });
          }
        }
      }, {
        key: 'onAfterRemoveCol',
        value: function onAfterRemoveCol(index, amount) {
          this.columnsMapper.unshiftItems(this.removedColumns);
        }
      }, {
        key: 'onAfterLoadData',
        value: function onAfterLoadData(firstTime) {
          this.updateColumnsMapper();
        }
      }, {
        key: 'onModifyCol',
        value: function onModifyCol(column, source) {
          if (source !== this.pluginName) {
            var columnInMapper = this.columnsMapper.getValueByIndex(column);
            column = columnInMapper === null ? column : columnInMapper;
          }
          return column;
        }
      }, {
        key: 'onUnmodifyCol',
        value: function onUnmodifyCol(column) {
          var indexInMapper = this.columnsMapper.getIndexByValue(column);
          return indexInMapper === null ? column : indexInMapper;
        }
      }, {
        key: 'onAfterPluginsInitialized',
        value: function onAfterPluginsInitialized() {
          this.updateColumnsMapper();
          this.initialSettings();
          this.backlight.build();
          this.guideline.build();
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          this.backlight.destroy();
          this.guideline.destroy();
          _get(ManualColumnMove.prototype.__proto__ || Object.getPrototypeOf(ManualColumnMove.prototype), 'destroy', this).call(this);
        }
      }]);
      return ManualColumnMove;
    }(_base2.default);
    (0, _plugins.registerPlugin)('ManualColumnMove', ManualColumnMove);
    exports.default = ManualColumnMove;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _base = __webpack_require__(266);
    var _base2 = _interopRequireDefault(_base);
    var _element = __webpack_require__(0);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var CSS_CLASSNAME = 'ht__manualColumnMove--backlight';
    var BacklightUI = function (_BaseUI) {
      _inherits(BacklightUI, _BaseUI);

      function BacklightUI() {
        _classCallCheck(this, BacklightUI);
        return _possibleConstructorReturn(this, (BacklightUI.__proto__ || Object.getPrototypeOf(BacklightUI)).apply(this, arguments));
      }
      _createClass(BacklightUI, [{
        key: 'build',
        value: function build() {
          _get(BacklightUI.prototype.__proto__ || Object.getPrototypeOf(BacklightUI.prototype), 'build', this).call(this);
          (0, _element.addClass)(this._element, CSS_CLASSNAME);
        }
      }]);
      return BacklightUI;
    }(_base2.default);
    exports.default = BacklightUI;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _base = __webpack_require__(266);
    var _base2 = _interopRequireDefault(_base);
    var _element = __webpack_require__(0);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var CSS_CLASSNAME = 'ht__manualColumnMove--guideline';
    var GuidelineUI = function (_BaseUI) {
      _inherits(GuidelineUI, _BaseUI);

      function GuidelineUI() {
        _classCallCheck(this, GuidelineUI);
        return _possibleConstructorReturn(this, (GuidelineUI.__proto__ || Object.getPrototypeOf(GuidelineUI)).apply(this, arguments));
      }
      _createClass(GuidelineUI, [{
        key: 'build',
        value: function build() {
          _get(GuidelineUI.prototype.__proto__ || Object.getPrototypeOf(GuidelineUI.prototype), 'build', this).call(this);
          (0, _element.addClass)(this._element, CSS_CLASSNAME);
        }
      }]);
      return GuidelineUI;
    }(_base2.default);
    exports.default = GuidelineUI;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _base = __webpack_require__(16);
    var _base2 = _interopRequireDefault(_base);
    var _element = __webpack_require__(0);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _event = __webpack_require__(7);
    var _array = __webpack_require__(2);
    var _number = __webpack_require__(5);
    var _plugins = __webpack_require__(9);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var ManualColumnResize = function (_BasePlugin) {
      _inherits(ManualColumnResize, _BasePlugin);

      function ManualColumnResize(hotInstance) {
        _classCallCheck(this, ManualColumnResize);
        var _this = _possibleConstructorReturn(this, (ManualColumnResize.__proto__ || Object.getPrototypeOf(ManualColumnResize)).call(this, hotInstance));
        _this.currentTH = null;
        _this.currentCol = null;
        _this.selectedCols = [];
        _this.currentWidth = null;
        _this.newSize = null;
        _this.startY = null;
        _this.startWidth = null;
        _this.startOffset = null;
        _this.handle = document.createElement('DIV');
        _this.guide = document.createElement('DIV');
        _this.eventManager = new _eventManager2.default(_this);
        _this.pressed = null;
        _this.dblclick = 0;
        _this.autoresizeTimeout = null;
        _this.manualColumnWidths = [];
        (0, _element.addClass)(_this.handle, 'manualColumnResizer');
        (0, _element.addClass)(_this.guide, 'manualColumnResizerGuide');
        return _this;
      }
      _createClass(ManualColumnResize, [{
        key: 'isEnabled',
        value: function isEnabled() {
          return this.hot.getSettings().manualColumnResize;
        }
      }, {
        key: 'enablePlugin',
        value: function enablePlugin() {
          var _this2 = this;
          if (this.enabled) {
            return;
          }
          this.manualColumnWidths = [];
          var initialColumnWidth = this.hot.getSettings().manualColumnResize;
          var loadedManualColumnWidths = this.loadManualColumnWidths();
          this.addHook('modifyColWidth', function (width, col) {
            return _this2.onModifyColWidth(width, col);
          });
          this.addHook('beforeStretchingColumnWidth', function (stretchedWidth, column) {
            return _this2.onBeforeStretchingColumnWidth(stretchedWidth, column);
          });
          this.addHook('beforeColumnResize', function (currentColumn, newSize, isDoubleClick) {
            return _this2.onBeforeColumnResize(currentColumn, newSize, isDoubleClick);
          });
          if (typeof loadedManualColumnWidths != 'undefined') {
            this.manualColumnWidths = loadedManualColumnWidths;
          } else if (Array.isArray(initialColumnWidth)) {
            this.manualColumnWidths = initialColumnWidth;
          } else {
            this.manualColumnWidths = [];
          }
          this.bindEvents();
          _get(ManualColumnResize.prototype.__proto__ || Object.getPrototypeOf(ManualColumnResize.prototype), 'enablePlugin', this).call(this);
        }
      }, {
        key: 'updatePlugin',
        value: function updatePlugin() {
          var initialColumnWidth = this.hot.getSettings().manualColumnResize;
          if (Array.isArray(initialColumnWidth)) {
            this.manualColumnWidths = initialColumnWidth;
          } else if (!initialColumnWidth) {
            this.manualColumnWidths = [];
          }
        }
      }, {
        key: 'disablePlugin',
        value: function disablePlugin() {
          _get(ManualColumnResize.prototype.__proto__ || Object.getPrototypeOf(ManualColumnResize.prototype), 'disablePlugin', this).call(this);
        }
      }, {
        key: 'saveManualColumnWidths',
        value: function saveManualColumnWidths() {
          this.hot.runHooks('persistentStateSave', 'manualColumnWidths', this.manualColumnWidths);
        }
      }, {
        key: 'loadManualColumnWidths',
        value: function loadManualColumnWidths() {
          var storedState = {};
          this.hot.runHooks('persistentStateLoad', 'manualColumnWidths', storedState);
          return storedState.value;
        }
      }, {
        key: 'setupHandlePosition',
        value: function setupHandlePosition(TH) {
          var _this3 = this;
          if (!TH.parentNode) {
            return false;
          }
          this.currentTH = TH;
          var col = this.hot.view.wt.wtTable.getCoords(TH).col;
          var headerHeight = (0, _element.outerHeight)(this.currentTH);
          if (col >= 0) {
            var box = this.currentTH.getBoundingClientRect();
            this.currentCol = col;
            this.selectedCols = [];
            if (this.hot.selection.isSelected() && this.hot.selection.selectedHeader.cols) {
              var _hot$getSelectedRange = this.hot.getSelectedRange(),
                from = _hot$getSelectedRange.from,
                to = _hot$getSelectedRange.to;
              var start = from.col;
              var end = to.col;
              if (start >= end) {
                start = to.col;
                end = from.col;
              }
              if (this.currentCol >= start && this.currentCol <= end) {
                (0, _number.rangeEach)(start, end, function (i) {
                  return _this3.selectedCols.push(i);
                });
              } else {
                this.selectedCols.push(this.currentCol);
              }
            } else {
              this.selectedCols.push(this.currentCol);
            }
            this.startOffset = box.left - 6;
            this.startWidth = parseInt(box.width, 10);
            this.handle.style.top = box.top + 'px';
            this.handle.style.left = this.startOffset + this.startWidth + 'px';
            this.handle.style.height = headerHeight + 'px';
            this.hot.rootElement.appendChild(this.handle);
          }
        }
      }, {
        key: 'refreshHandlePosition',
        value: function refreshHandlePosition() {
          this.handle.style.left = this.startOffset + this.currentWidth + 'px';
        }
      }, {
        key: 'setupGuidePosition',
        value: function setupGuidePosition() {
          var handleHeight = parseInt((0, _element.outerHeight)(this.handle), 10);
          var handleBottomPosition = parseInt(this.handle.style.top, 10) + handleHeight;
          var maximumVisibleElementHeight = parseInt(this.hot.view.maximumVisibleElementHeight(0), 10);
          (0, _element.addClass)(this.handle, 'active');
          (0, _element.addClass)(this.guide, 'active');
          this.guide.style.top = handleBottomPosition + 'px';
          this.guide.style.left = this.handle.style.left;
          this.guide.style.height = maximumVisibleElementHeight - handleHeight + 'px';
          this.hot.rootElement.appendChild(this.guide);
        }
      }, {
        key: 'refreshGuidePosition',
        value: function refreshGuidePosition() {
          this.guide.style.left = this.handle.style.left;
        }
      }, {
        key: 'hideHandleAndGuide',
        value: function hideHandleAndGuide() {
          (0, _element.removeClass)(this.handle, 'active');
          (0, _element.removeClass)(this.guide, 'active');
        }
      }, {
        key: 'checkIfColumnHeader',
        value: function checkIfColumnHeader(element) {
          if (element != this.hot.rootElement) {
            var parent = element.parentNode;
            if (parent.tagName === 'THEAD') {
              return true;
            }
            return this.checkIfColumnHeader(parent);
          }
          return false;
        }
      }, {
        key: 'getTHFromTargetElement',
        value: function getTHFromTargetElement(element) {
          if (element.tagName != 'TABLE') {
            if (element.tagName == 'TH') {
              return element;
            }
            return this.getTHFromTargetElement(element.parentNode);
          }
          return null;
        }
      }, {
        key: 'onMouseOver',
        value: function onMouseOver(event) {
          if (this.checkIfColumnHeader(event.target)) {
            var th = this.getTHFromTargetElement(event.target);
            if (!th) {
              return;
            }
            var colspan = th.getAttribute('colspan');
            if (th && (colspan === null || colspan === 1)) {
              if (!this.pressed) {
                this.setupHandlePosition(th);
              }
            }
          }
        }
      }, {
        key: 'afterMouseDownTimeout',
        value: function afterMouseDownTimeout() {
          var _this4 = this;
          var render = function render() {
            _this4.hot.forceFullRender = true;
            _this4.hot.view.render();
            _this4.hot.view.wt.wtOverlays.adjustElementsSize(true);
          };
          var resize = function resize(selectedCol, forceRender) {
            var hookNewSize = _this4.hot.runHooks('beforeColumnResize', selectedCol, _this4.newSize, true);
            if (hookNewSize !== void 0) {
              _this4.newSize = hookNewSize;
            }
            if (_this4.hot.getSettings().stretchH === 'all') {
              _this4.clearManualSize(selectedCol);
            } else {
              _this4.setManualSize(selectedCol, _this4.newSize);
            }
            if (forceRender) {
              render();
            }
            _this4.saveManualColumnWidths();
            _this4.hot.runHooks('afterColumnResize', selectedCol, _this4.newSize, true);
          };
          if (this.dblclick >= 2) {
            var selectedColsLength = this.selectedCols.length;
            if (selectedColsLength > 1) {
              (0, _array.arrayEach)(this.selectedCols, function (selectedCol) {
                resize(selectedCol);
              });
              render();
            } else {
              (0, _array.arrayEach)(this.selectedCols, function (selectedCol) {
                resize(selectedCol, true);
              });
            }
          }
          this.dblclick = 0;
          this.autoresizeTimeout = null;
        }
      }, {
        key: 'onMouseDown',
        value: function onMouseDown(event) {
          var _this5 = this;
          if ((0, _element.hasClass)(event.target, 'manualColumnResizer')) {
            this.setupGuidePosition();
            this.pressed = this.hot;
            if (this.autoresizeTimeout === null) {
              this.autoresizeTimeout = setTimeout(function () {
                return _this5.afterMouseDownTimeout();
              }, 500);
              this.hot._registerTimeout(this.autoresizeTimeout);
            }
            this.dblclick++;
            this.startX = (0, _event.pageX)(event);
            this.newSize = this.startWidth;
          }
        }
      }, {
        key: 'onMouseMove',
        value: function onMouseMove(event) {
          var _this6 = this;
          if (this.pressed) {
            this.currentWidth = this.startWidth + ((0, _event.pageX)(event) - this.startX);
            (0, _array.arrayEach)(this.selectedCols, function (selectedCol) {
              _this6.newSize = _this6.setManualSize(selectedCol, _this6.currentWidth);
            });
            this.refreshHandlePosition();
            this.refreshGuidePosition();
          }
        }
      }, {
        key: 'onMouseUp',
        value: function onMouseUp(event) {
          var _this7 = this;
          var render = function render() {
            _this7.hot.forceFullRender = true;
            _this7.hot.view.render();
            _this7.hot.view.wt.wtOverlays.adjustElementsSize(true);
          };
          var resize = function resize(selectedCol, forceRender) {
            _this7.hot.runHooks('beforeColumnResize', selectedCol, _this7.newSize);
            if (forceRender) {
              render();
            }
            _this7.saveManualColumnWidths();
            _this7.hot.runHooks('afterColumnResize', selectedCol, _this7.newSize);
          };
          if (this.pressed) {
            this.hideHandleAndGuide();
            this.pressed = false;
            if (this.newSize != this.startWidth) {
              var selectedColsLength = this.selectedCols.length;
              if (selectedColsLength > 1) {
                (0, _array.arrayEach)(this.selectedCols, function (selectedCol) {
                  resize(selectedCol);
                });
                render();
              } else {
                (0, _array.arrayEach)(this.selectedCols, function (selectedCol) {
                  resize(selectedCol, true);
                });
              }
            }
            this.setupHandlePosition(this.currentTH);
          }
        }
      }, {
        key: 'bindEvents',
        value: function bindEvents() {
          var _this8 = this;
          this.eventManager.addEventListener(this.hot.rootElement, 'mouseover', function (e) {
            return _this8.onMouseOver(e);
          });
          this.eventManager.addEventListener(this.hot.rootElement, 'mousedown', function (e) {
            return _this8.onMouseDown(e);
          });
          this.eventManager.addEventListener(window, 'mousemove', function (e) {
            return _this8.onMouseMove(e);
          });
          this.eventManager.addEventListener(window, 'mouseup', function (e) {
            return _this8.onMouseUp(e);
          });
        }
      }, {
        key: 'setManualSize',
        value: function setManualSize(column, width) {
          width = Math.max(width, 20);
          column = this.hot.runHooks('modifyCol', column);
          this.manualColumnWidths[column] = width;
          return width;
        }
      }, {
        key: 'clearManualSize',
        value: function clearManualSize(column) {
          column = this.hot.runHooks('modifyCol', column);
          this.manualColumnWidths[column] = void 0;
        }
      }, {
        key: 'onModifyColWidth',
        value: function onModifyColWidth(width, column) {
          if (this.enabled) {
            column = this.hot.runHooks('modifyCol', column);
            if (this.hot.getSettings().manualColumnResize && this.manualColumnWidths[column]) {
              return this.manualColumnWidths[column];
            }
          }
          return width;
        }
      }, {
        key: 'onBeforeStretchingColumnWidth',
        value: function onBeforeStretchingColumnWidth(stretchedWidth, column) {
          var width = this.manualColumnWidths[column];
          if (width === void 0) {
            width = stretchedWidth;
          }
          return width;
        }
      }, {
        key: 'onBeforeColumnResize',
        value: function onBeforeColumnResize() {
          this.hot.view.wt.wtViewport.hasOversizedColumnHeadersMarked = {};
        }
      }]);
      return ManualColumnResize;
    }(_base2.default);
    (0, _plugins.registerPlugin)('manualColumnResize', ManualColumnResize);
    exports.default = ManualColumnResize;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _base = __webpack_require__(16);
    var _base2 = _interopRequireDefault(_base);
    var _pluginHooks = __webpack_require__(11);
    var _pluginHooks2 = _interopRequireDefault(_pluginHooks);
    var _array = __webpack_require__(2);
    var _element = __webpack_require__(0);
    var _number = __webpack_require__(5);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _plugins = __webpack_require__(9);
    var _rowsMapper = __webpack_require__(369);
    var _rowsMapper2 = _interopRequireDefault(_rowsMapper);
    var _backlight = __webpack_require__(370);
    var _backlight2 = _interopRequireDefault(_backlight);
    var _guideline = __webpack_require__(371);
    var _guideline2 = _interopRequireDefault(_guideline);
    var _src = __webpack_require__(14);
    __webpack_require__(303);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    _pluginHooks2.default.getSingleton().register('beforeRowMove');
    _pluginHooks2.default.getSingleton().register('afterRowMove');
    _pluginHooks2.default.getSingleton().register('unmodifyRow');
    var privatePool = new WeakMap();
    var CSS_PLUGIN = 'ht__manualRowMove';
    var CSS_SHOW_UI = 'show-ui';
    var CSS_ON_MOVING = 'on-moving--rows';
    var CSS_AFTER_SELECTION = 'after-selection--rows';
    var ManualRowMove = function (_BasePlugin) {
      _inherits(ManualRowMove, _BasePlugin);

      function ManualRowMove(hotInstance) {
        _classCallCheck(this, ManualRowMove);
        var _this = _possibleConstructorReturn(this, (ManualRowMove.__proto__ || Object.getPrototypeOf(ManualRowMove)).call(this, hotInstance));
        privatePool.set(_this, {
          rowsToMove: [],
          pressed: void 0,
          disallowMoving: void 0,
          target: {
            eventPageY: void 0,
            coords: void 0,
            TD: void 0,
            row: void 0
          }
        });
        _this.removedRows = [];
        _this.rowsMapper = new _rowsMapper2.default(_this);
        _this.eventManager = new _eventManager2.default(_this);
        _this.backlight = new _backlight2.default(hotInstance);
        _this.guideline = new _guideline2.default(hotInstance);
        return _this;
      }
      _createClass(ManualRowMove, [{
        key: 'isEnabled',
        value: function isEnabled() {
          return !!this.hot.getSettings().manualRowMove;
        }
      }, {
        key: 'enablePlugin',
        value: function enablePlugin() {
          var _this2 = this;
          if (this.enabled) {
            return;
          }
          this.addHook('beforeOnCellMouseDown', function (event, coords, TD, blockCalculations) {
            return _this2.onBeforeOnCellMouseDown(event, coords, TD, blockCalculations);
          });
          this.addHook('beforeOnCellMouseOver', function (event, coords, TD, blockCalculations) {
            return _this2.onBeforeOnCellMouseOver(event, coords, TD, blockCalculations);
          });
          this.addHook('afterScrollHorizontally', function () {
            return _this2.onAfterScrollHorizontally();
          });
          this.addHook('modifyRow', function (row, source) {
            return _this2.onModifyRow(row, source);
          });
          this.addHook('beforeRemoveRow', function (index, amount) {
            return _this2.onBeforeRemoveRow(index, amount);
          });
          this.addHook('afterRemoveRow', function (index, amount) {
            return _this2.onAfterRemoveRow(index, amount);
          });
          this.addHook('afterCreateRow', function (index, amount) {
            return _this2.onAfterCreateRow(index, amount);
          });
          this.addHook('afterLoadData', function (firstTime) {
            return _this2.onAfterLoadData(firstTime);
          });
          this.addHook('beforeColumnSort', function (column, order) {
            return _this2.onBeforeColumnSort(column, order);
          });
          this.addHook('unmodifyRow', function (row) {
            return _this2.onUnmodifyRow(row);
          });
          this.registerEvents();
          (0, _element.addClass)(this.hot.rootElement, CSS_PLUGIN);
          _get(ManualRowMove.prototype.__proto__ || Object.getPrototypeOf(ManualRowMove.prototype), 'enablePlugin', this).call(this);
        }
      }, {
        key: 'updatePlugin',
        value: function updatePlugin() {
          this.disablePlugin();
          this.enablePlugin();
          this.onAfterPluginsInitialized();
          _get(ManualRowMove.prototype.__proto__ || Object.getPrototypeOf(ManualRowMove.prototype), 'updatePlugin', this).call(this);
        }
      }, {
        key: 'disablePlugin',
        value: function disablePlugin() {
          var pluginSettings = this.hot.getSettings().manualRowMove;
          if (Array.isArray(pluginSettings)) {
            this.rowsMapper.clearMap();
          } (0, _element.removeClass)(this.hot.rootElement, CSS_PLUGIN);
          this.unregisterEvents();
          this.backlight.destroy();
          this.guideline.destroy();
          _get(ManualRowMove.prototype.__proto__ || Object.getPrototypeOf(ManualRowMove.prototype), 'disablePlugin', this).call(this);
        }
      }, {
        key: 'moveRow',
        value: function moveRow(row, target) {
          this.moveRows([row], target);
        }
      }, {
        key: 'moveRows',
        value: function moveRows(rows, target) {
          var _this3 = this;
          var priv = privatePool.get(this);
          var beforeMoveHook = this.hot.runHooks('beforeRowMove', rows, target);
          priv.disallowMoving = beforeMoveHook === false;
          if (!priv.disallowMoving) {
            (0, _array.arrayEach)(rows, function (row, index, array) {
              array[index] = _this3.rowsMapper.getValueByIndex(row);
            });
            (0, _array.arrayEach)(rows, function (row, index) {
              var actualPosition = _this3.rowsMapper.getIndexByValue(row);
              if (actualPosition !== target) {
                _this3.rowsMapper.moveRow(actualPosition, target + index);
              }
            });
            this.rowsMapper.clearNull();
          }
          this.hot.runHooks('afterRowMove', rows, target);
        }
      }, {
        key: 'changeSelection',
        value: function changeSelection(startRow, endRow) {
          var selection = this.hot.selection;
          var lastColIndex = this.hot.countCols() - 1;
          selection.setRangeStartOnly(new _src.CellCoords(startRow, 0));
          selection.setRangeEnd(new _src.CellCoords(endRow, lastColIndex), false);
        }
      }, {
        key: 'getRowsHeight',
        value: function getRowsHeight(from, to) {
          var height = 0;
          for (var i = from; i < to; i++) {
            var rowHeight = this.hot.view.wt.wtTable.getRowHeight(i) || 23;
            height += rowHeight;
          }
          return height;
        }
      }, {
        key: 'initialSettings',
        value: function initialSettings() {
          var pluginSettings = this.hot.getSettings().manualRowMove;
          if (Array.isArray(pluginSettings)) {
            this.moveRows(pluginSettings, 0);
          } else if (pluginSettings !== void 0) {
            var persistentState = this.persistentStateLoad();
            if (persistentState.length) {
              this.moveRows(persistentState, 0);
            }
          }
        }
      }, {
        key: 'isFixedRowTop',
        value: function isFixedRowTop(row) {
          return row < this.hot.getSettings().fixedRowsTop;
        }
      }, {
        key: 'isFixedRowBottom',
        value: function isFixedRowBottom(row) {
          return row > this.hot.getSettings().fixedRowsBottom;
        }
      }, {
        key: 'persistentStateSave',
        value: function persistentStateSave() {
          this.hot.runHooks('persistentStateSave', 'manualRowMove', this.rowsMapper._arrayMap);
        }
      }, {
        key: 'persistentStateLoad',
        value: function persistentStateLoad() {
          var storedState = {};
          this.hot.runHooks('persistentStateLoad', 'manualRowMove', storedState);
          return storedState.value ? storedState.value : [];
        }
      }, {
        key: 'prepareRowsToMoving',
        value: function prepareRowsToMoving() {
          var selection = this.hot.getSelectedRange();
          var selectedRows = [];
          if (!selection) {
            return selectedRows;
          }
          var from = selection.from,
            to = selection.to;
          var start = Math.min(from.row, to.row);
          var end = Math.max(from.row, to.row);
          (0, _number.rangeEach)(start, end, function (i) {
            selectedRows.push(i);
          });
          return selectedRows;
        }
      }, {
        key: 'refreshPositions',
        value: function refreshPositions() {
          var priv = privatePool.get(this);
          var coords = priv.target.coords;
          var firstVisible = this.hot.view.wt.wtTable.getFirstVisibleRow();
          var lastVisible = this.hot.view.wt.wtTable.getLastVisibleRow();
          var fixedRows = this.hot.getSettings().fixedRowsTop;
          var countRows = this.hot.countRows();
          if (coords.row < fixedRows && firstVisible > 0) {
            this.hot.scrollViewportTo(firstVisible - 1);
          }
          if (coords.row >= lastVisible && lastVisible < countRows) {
            this.hot.scrollViewportTo(lastVisible + 1, undefined, true);
          }
          var wtTable = this.hot.view.wt.wtTable;
          var TD = priv.target.TD;
          var rootElementOffset = (0, _element.offset)(this.hot.rootElement);
          var tdOffsetTop = this.hot.view.THEAD.offsetHeight + this.getRowsHeight(0, coords.row);
          var mouseOffsetTop = priv.target.eventPageY - rootElementOffset.top + wtTable.holder.scrollTop;
          var hiderHeight = wtTable.hider.offsetHeight;
          var tbodyOffsetTop = wtTable.TBODY.offsetTop;
          var backlightElemMarginTop = this.backlight.getOffset().top;
          var backlightElemHeight = this.backlight.getSize().height;
          if (this.isFixedRowTop(coords.row)) {
            tdOffsetTop += wtTable.holder.scrollTop;
          }
          if (coords.row < 0) {
            priv.target.row = firstVisible > 0 ? firstVisible - 1 : firstVisible;
          } else if (TD.offsetHeight / 2 + tdOffsetTop <= mouseOffsetTop) {
            priv.target.row = coords.row + 1;
            tdOffsetTop += coords.row === 0 ? TD.offsetHeight - 1 : TD.offsetHeight;
          } else {
            priv.target.row = coords.row;
          }
          var backlightTop = mouseOffsetTop;
          var guidelineTop = tdOffsetTop;
          if (mouseOffsetTop + backlightElemHeight + backlightElemMarginTop >= hiderHeight) {
            backlightTop = hiderHeight - backlightElemHeight - backlightElemMarginTop;
          } else if (mouseOffsetTop + backlightElemMarginTop < tbodyOffsetTop) {
            backlightTop = tbodyOffsetTop + Math.abs(backlightElemMarginTop);
          }
          if (tdOffsetTop >= hiderHeight - 1) {
            guidelineTop = hiderHeight - 1;
          }
          var topOverlayHeight = 0;
          if (this.hot.view.wt.wtOverlays.topOverlay) {
            topOverlayHeight = this.hot.view.wt.wtOverlays.topOverlay.clone.wtTable.TABLE.offsetHeight;
          }
          if (coords.row >= fixedRows && guidelineTop - wtTable.holder.scrollTop < topOverlayHeight) {
            this.hot.scrollViewportTo(coords.row);
          }
          this.backlight.setPosition(backlightTop);
          this.guideline.setPosition(guidelineTop);
        }
      }, {
        key: 'updateRowsMapper',
        value: function updateRowsMapper() {
          var countRows = this.hot.countSourceRows();
          var rowsMapperLen = this.rowsMapper._arrayMap.length;
          if (rowsMapperLen === 0) {
            this.rowsMapper.createMap(countRows || this.hot.getSettings().startRows);
          } else if (rowsMapperLen < countRows) {
            var diff = countRows - rowsMapperLen;
            this.rowsMapper.insertItems(rowsMapperLen, diff);
          } else if (rowsMapperLen > countRows) {
            var maxIndex = countRows - 1;
            var rowsToRemove = [];
            (0, _array.arrayEach)(this.rowsMapper._arrayMap, function (value, index, array) {
              if (value > maxIndex) {
                rowsToRemove.push(index);
              }
            });
            this.rowsMapper.removeItems(rowsToRemove);
          }
        }
      }, {
        key: 'registerEvents',
        value: function registerEvents() {
          var _this4 = this;
          this.eventManager.addEventListener(document.documentElement, 'mousemove', function (event) {
            return _this4.onMouseMove(event);
          });
          this.eventManager.addEventListener(document.documentElement, 'mouseup', function () {
            return _this4.onMouseUp();
          });
        }
      }, {
        key: 'unregisterEvents',
        value: function unregisterEvents() {
          this.eventManager.clear();
        }
      }, {
        key: 'onBeforeColumnSort',
        value: function onBeforeColumnSort(column, order) {
          var priv = privatePool.get(this);
          priv.disallowMoving = order !== void 0;
        }
      }, {
        key: 'onBeforeOnCellMouseDown',
        value: function onBeforeOnCellMouseDown(event, coords, TD, blockCalculations) {
          var wtTable = this.hot.view.wt.wtTable;
          var isHeaderSelection = this.hot.selection.selectedHeader.rows;
          var selection = this.hot.getSelectedRange();
          var priv = privatePool.get(this);
          if (!selection || !isHeaderSelection || priv.pressed || event.button !== 0) {
            priv.pressed = false;
            priv.rowsToMove.length = 0;
            (0, _element.removeClass)(this.hot.rootElement, [CSS_ON_MOVING, CSS_SHOW_UI]);
            return;
          }
          var guidelineIsNotReady = this.guideline.isBuilt() && !this.guideline.isAppended();
          var backlightIsNotReady = this.backlight.isBuilt() && !this.backlight.isAppended();
          if (guidelineIsNotReady && backlightIsNotReady) {
            this.guideline.appendTo(wtTable.hider);
            this.backlight.appendTo(wtTable.hider);
          }
          var from = selection.from,
            to = selection.to;
          var start = Math.min(from.row, to.row);
          var end = Math.max(from.row, to.row);
          if (coords.col < 0 && coords.row >= start && coords.row <= end) {
            blockCalculations.row = true;
            priv.pressed = true;
            priv.target.eventPageY = event.pageY;
            priv.target.coords = coords;
            priv.target.TD = TD;
            priv.rowsToMove = this.prepareRowsToMoving();
            var leftPos = wtTable.holder.scrollLeft + wtTable.getColumnWidth(-1);
            this.backlight.setPosition(null, leftPos);
            this.backlight.setSize(wtTable.hider.offsetWidth - leftPos, this.getRowsHeight(start, end + 1));
            this.backlight.setOffset((this.getRowsHeight(start, coords.row) + event.layerY) * -1, null);
            (0, _element.addClass)(this.hot.rootElement, CSS_ON_MOVING);
            this.refreshPositions();
          } else {
            (0, _element.removeClass)(this.hot.rootElement, CSS_AFTER_SELECTION);
            priv.pressed = false;
            priv.rowsToMove.length = 0;
          }
        }
      }, {
        key: 'onMouseMove',
        value: function onMouseMove(event) {
          var priv = privatePool.get(this);
          if (!priv.pressed) {
            return;
          }
          if (event.realTarget === this.backlight.element) {
            var height = this.backlight.getSize().height;
            this.backlight.setSize(null, 0);
            setTimeout(function () {
              this.backlight.setPosition(null, height);
            });
          }
          priv.target.eventPageY = event.pageY;
          this.refreshPositions();
        }
      }, {
        key: 'onBeforeOnCellMouseOver',
        value: function onBeforeOnCellMouseOver(event, coords, TD, blockCalculations) {
          var selectedRange = this.hot.getSelectedRange();
          var priv = privatePool.get(this);
          if (!selectedRange || !priv.pressed) {
            return;
          }
          if (priv.rowsToMove.indexOf(coords.row) > -1) {
            (0, _element.removeClass)(this.hot.rootElement, CSS_SHOW_UI);
          } else {
            (0, _element.addClass)(this.hot.rootElement, CSS_SHOW_UI);
          }
          blockCalculations.row = true;
          blockCalculations.column = true;
          blockCalculations.cell = true;
          priv.target.coords = coords;
          priv.target.TD = TD;
        }
      }, {
        key: 'onMouseUp',
        value: function onMouseUp() {
          var priv = privatePool.get(this);
          var target = priv.target.row;
          var rowsLen = priv.rowsToMove.length;
          priv.pressed = false;
          priv.backlightHeight = 0;
          (0, _element.removeClass)(this.hot.rootElement, [CSS_ON_MOVING, CSS_SHOW_UI, CSS_AFTER_SELECTION]);
          if (this.hot.selection.selectedHeader.rows) {
            (0, _element.addClass)(this.hot.rootElement, CSS_AFTER_SELECTION);
          }
          if (rowsLen < 1 || target === void 0 || priv.rowsToMove.indexOf(target) > -1 || priv.rowsToMove[rowsLen - 1] === target - 1) {
            return;
          }
          this.moveRows(priv.rowsToMove, target);
          this.persistentStateSave();
          this.hot.render();
          if (!priv.disallowMoving) {
            var selectionStart = this.rowsMapper.getIndexByValue(priv.rowsToMove[0]);
            var selectionEnd = this.rowsMapper.getIndexByValue(priv.rowsToMove[rowsLen - 1]);
            this.changeSelection(selectionStart, selectionEnd);
          }
          priv.rowsToMove.length = 0;
        }
      }, {
        key: 'onAfterScrollHorizontally',
        value: function onAfterScrollHorizontally() {
          var wtTable = this.hot.view.wt.wtTable;
          var headerWidth = wtTable.getColumnWidth(-1);
          var scrollLeft = wtTable.holder.scrollLeft;
          var posLeft = headerWidth + scrollLeft;
          this.backlight.setPosition(null, posLeft);
          this.backlight.setSize(wtTable.hider.offsetWidth - posLeft);
        }
      }, {
        key: 'onAfterCreateRow',
        value: function onAfterCreateRow(index, amount) {
          this.rowsMapper.shiftItems(index, amount);
        }
      }, {
        key: 'onBeforeRemoveRow',
        value: function onBeforeRemoveRow(index, amount) {
          var _this5 = this;
          this.removedRows.length = 0;
          if (index !== false) {
            (0, _number.rangeEach)(index, index + amount - 1, function (removedIndex) {
              _this5.removedRows.push(_this5.hot.runHooks('modifyRow', removedIndex, _this5.pluginName));
            });
          }
        }
      }, {
        key: 'onAfterRemoveRow',
        value: function onAfterRemoveRow(index, amount) {
          this.rowsMapper.unshiftItems(this.removedRows);
        }
      }, {
        key: 'onAfterLoadData',
        value: function onAfterLoadData(firstTime) {
          this.updateRowsMapper();
        }
      }, {
        key: 'onModifyRow',
        value: function onModifyRow(row, source) {
          if (source !== this.pluginName) {
            var rowInMapper = this.rowsMapper.getValueByIndex(row);
            row = rowInMapper === null ? row : rowInMapper;
          }
          return row;
        }
      }, {
        key: 'onUnmodifyRow',
        value: function onUnmodifyRow(row) {
          var indexInMapper = this.rowsMapper.getIndexByValue(row);
          return indexInMapper === null ? row : indexInMapper;
        }
      }, {
        key: 'onAfterPluginsInitialized',
        value: function onAfterPluginsInitialized() {
          this.updateRowsMapper();
          this.initialSettings();
          this.backlight.build();
          this.guideline.build();
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          this.backlight.destroy();
          this.guideline.destroy();
          _get(ManualRowMove.prototype.__proto__ || Object.getPrototypeOf(ManualRowMove.prototype), 'destroy', this).call(this);
        }
      }]);
      return ManualRowMove;
    }(_base2.default);
    (0, _plugins.registerPlugin)('ManualRowMove', ManualRowMove);
    exports.default = ManualRowMove;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _arrayMapper = __webpack_require__(265);
    var _arrayMapper2 = _interopRequireDefault(_arrayMapper);
    var _array = __webpack_require__(2);
    var _object = __webpack_require__(3);
    var _number = __webpack_require__(5);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var RowsMapper = function () {
      function RowsMapper(manualRowMove) {
        _classCallCheck(this, RowsMapper);
        this.manualRowMove = manualRowMove;
      }
      _createClass(RowsMapper, [{
        key: 'createMap',
        value: function createMap(length) {
          var _this = this;
          var originLength = length === void 0 ? this._arrayMap.length : length;
          this._arrayMap.length = 0;
          (0, _number.rangeEach)(originLength - 1, function (itemIndex) {
            _this._arrayMap[itemIndex] = itemIndex;
          });
        }
      }, {
        key: 'destroy',
        value: function destroy() {
          this._arrayMap = null;
        }
      }, {
        key: 'moveRow',
        value: function moveRow(from, to) {
          var indexToMove = this._arrayMap[from];
          this._arrayMap[from] = null;
          this._arrayMap.splice(to, 0, indexToMove);
        }
      }, {
        key: 'clearNull',
        value: function clearNull() {
          this._arrayMap = (0, _array.arrayFilter)(this._arrayMap, function (i) {
            return i !== null;
          });
        }
      }]);
      return RowsMapper;
    }();
    (0, _object.mixin)(RowsMapper, _arrayMapper2.default);
    exports.default = RowsMapper;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _base = __webpack_require__(267);
    var _base2 = _interopRequireDefault(_base);
    var _element = __webpack_require__(0);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var CSS_CLASSNAME = 'ht__manualRowMove--backlight';
    var BacklightUI = function (_BaseUI) {
      _inherits(BacklightUI, _BaseUI);

      function BacklightUI() {
        _classCallCheck(this, BacklightUI);
        return _possibleConstructorReturn(this, (BacklightUI.__proto__ || Object.getPrototypeOf(BacklightUI)).apply(this, arguments));
      }
      _createClass(BacklightUI, [{
        key: 'build',
        value: function build() {
          _get(BacklightUI.prototype.__proto__ || Object.getPrototypeOf(BacklightUI.prototype), 'build', this).call(this);
          (0, _element.addClass)(this._element, CSS_CLASSNAME);
        }
      }]);
      return BacklightUI;
    }(_base2.default);
    exports.default = BacklightUI;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _base = __webpack_require__(267);
    var _base2 = _interopRequireDefault(_base);
    var _element = __webpack_require__(0);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var CSS_CLASSNAME = 'ht__manualRowMove--guideline';
    var GuidelineUI = function (_BaseUI) {
      _inherits(GuidelineUI, _BaseUI);

      function GuidelineUI() {
        _classCallCheck(this, GuidelineUI);
        return _possibleConstructorReturn(this, (GuidelineUI.__proto__ || Object.getPrototypeOf(GuidelineUI)).apply(this, arguments));
      }
      _createClass(GuidelineUI, [{
        key: 'build',
        value: function build() {
          _get(GuidelineUI.prototype.__proto__ || Object.getPrototypeOf(GuidelineUI.prototype), 'build', this).call(this);
          (0, _element.addClass)(this._element, CSS_CLASSNAME);
        }
      }]);
      return GuidelineUI;
    }(_base2.default);
    exports.default = GuidelineUI;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _base = __webpack_require__(16);
    var _base2 = _interopRequireDefault(_base);
    var _element = __webpack_require__(0);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _event = __webpack_require__(7);
    var _array = __webpack_require__(2);
    var _number = __webpack_require__(5);
    var _plugins = __webpack_require__(9);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var ManualRowResize = function (_BasePlugin) {
      _inherits(ManualRowResize, _BasePlugin);

      function ManualRowResize(hotInstance) {
        _classCallCheck(this, ManualRowResize);
        var _this = _possibleConstructorReturn(this, (ManualRowResize.__proto__ || Object.getPrototypeOf(ManualRowResize)).call(this, hotInstance));
        _this.currentTH = null;
        _this.currentRow = null;
        _this.selectedRows = [];
        _this.currentHeight = null;
        _this.newSize = null;
        _this.startY = null;
        _this.startHeight = null;
        _this.startOffset = null;
        _this.handle = document.createElement('DIV');
        _this.guide = document.createElement('DIV');
        _this.eventManager = new _eventManager2.default(_this);
        _this.pressed = null;
        _this.dblclick = 0;
        _this.autoresizeTimeout = null;
        _this.manualRowHeights = [];
        (0, _element.addClass)(_this.handle, 'manualRowResizer');
        (0, _element.addClass)(_this.guide, 'manualRowResizerGuide');
        return _this;
      }
      _createClass(ManualRowResize, [{
        key: 'isEnabled',
        value: function isEnabled() {
          return this.hot.getSettings().manualRowResize;
        }
      }, {
        key: 'enablePlugin',
        value: function enablePlugin() {
          var _this2 = this;
          if (this.enabled) {
            return;
          }
          this.manualRowHeights = [];
          var initialRowHeights = this.hot.getSettings().manualRowResize;
          var loadedManualRowHeights = this.loadManualRowHeights();
          if (typeof loadedManualRowHeights != 'undefined') {
            this.manualRowHeights = loadedManualRowHeights;
          } else if (Array.isArray(initialRowHeights)) {
            this.manualRowHeights = initialRowHeights;
          } else {
            this.manualRowHeights = [];
          }
          this.addHook('modifyRowHeight', function (height, row) {
            return _this2.onModifyRowHeight(height, row);
          });
          this.bindEvents();
          _get(ManualRowResize.prototype.__proto__ || Object.getPrototypeOf(ManualRowResize.prototype), 'enablePlugin', this).call(this);
        }
      }, {
        key: 'updatePlugin',
        value: function updatePlugin() {
          var initialRowHeights = this.hot.getSettings().manualRowResize;
          if (Array.isArray(initialRowHeights)) {
            this.manualRowHeights = initialRowHeights;
          } else if (!initialRowHeights) {
            this.manualRowHeights = [];
          }
        }
      }, {
        key: 'disablePlugin',
        value: function disablePlugin() {
          _get(ManualRowResize.prototype.__proto__ || Object.getPrototypeOf(ManualRowResize.prototype), 'disablePlugin', this).call(this);
        }
      }, {
        key: 'saveManualRowHeights',
        value: function saveManualRowHeights() {
          this.hot.runHooks('persistentStateSave', 'manualRowHeights', this.manualRowHeights);
        }
      }, {
        key: 'loadManualRowHeights',
        value: function loadManualRowHeights() {
          var storedState = {};
          this.hot.runHooks('persistentStateLoad', 'manualRowHeights', storedState);
          return storedState.value;
        }
      }, {
        key: 'setupHandlePosition',
        value: function setupHandlePosition(TH) {
          var _this3 = this;
          this.currentTH = TH;
          var row = this.hot.view.wt.wtTable.getCoords(TH).row;
          var headerWidth = (0, _element.outerWidth)(this.currentTH);
          if (row >= 0) {
            var box = this.currentTH.getBoundingClientRect();
            this.currentRow = row;
            this.selectedRows = [];
            if (this.hot.selection.isSelected() && this.hot.selection.selectedHeader.rows) {
              var _hot$getSelectedRange = this.hot.getSelectedRange(),
                from = _hot$getSelectedRange.from,
                to = _hot$getSelectedRange.to;
              var start = from.row;
              var end = to.row;
              if (start >= end) {
                start = to.row;
                end = from.row;
              }
              if (this.currentRow >= start && this.currentRow <= end) {
                (0, _number.rangeEach)(start, end, function (i) {
                  return _this3.selectedRows.push(i);
                });
              } else {
                this.selectedRows.push(this.currentRow);
              }
            } else {
              this.selectedRows.push(this.currentRow);
            }
            this.startOffset = box.top - 6;
            this.startHeight = parseInt(box.height, 10);
            this.handle.style.left = box.left + 'px';
            this.handle.style.top = this.startOffset + this.startHeight + 'px';
            this.handle.style.width = headerWidth + 'px';
            this.hot.rootElement.appendChild(this.handle);
          }
        }
      }, {
        key: 'refreshHandlePosition',
        value: function refreshHandlePosition() {
          this.handle.style.top = this.startOffset + this.currentHeight + 'px';
        }
      }, {
        key: 'setupGuidePosition',
        value: function setupGuidePosition() {
          var handleWidth = parseInt((0, _element.outerWidth)(this.handle), 10);
          var handleRightPosition = parseInt(this.handle.style.left, 10) + handleWidth;
          var maximumVisibleElementWidth = parseInt(this.hot.view.maximumVisibleElementWidth(0), 10);
          (0, _element.addClass)(this.handle, 'active');
          (0, _element.addClass)(this.guide, 'active');
          this.guide.style.top = this.handle.style.top;
          this.guide.style.left = handleRightPosition + 'px';
          this.guide.style.width = maximumVisibleElementWidth - handleWidth + 'px';
          this.hot.rootElement.appendChild(this.guide);
        }
      }, {
        key: 'refreshGuidePosition',
        value: function refreshGuidePosition() {
          this.guide.style.top = this.handle.style.top;
        }
      }, {
        key: 'hideHandleAndGuide',
        value: function hideHandleAndGuide() {
          (0, _element.removeClass)(this.handle, 'active');
          (0, _element.removeClass)(this.guide, 'active');
        }
      }, {
        key: 'checkIfRowHeader',
        value: function checkIfRowHeader(element) {
          if (element != this.hot.rootElement) {
            var parent = element.parentNode;
            if (parent.tagName === 'TBODY') {
              return true;
            }
            return this.checkIfRowHeader(parent);
          }
          return false;
        }
      }, {
        key: 'getTHFromTargetElement',
        value: function getTHFromTargetElement(element) {
          if (element.tagName != 'TABLE') {
            if (element.tagName == 'TH') {
              return element;
            }
            return this.getTHFromTargetElement(element.parentNode);
          }
          return null;
        }
      }, {
        key: 'onMouseOver',
        value: function onMouseOver(event) {
          if (this.checkIfRowHeader(event.target)) {
            var th = this.getTHFromTargetElement(event.target);
            if (th) {
              if (!this.pressed) {
                this.setupHandlePosition(th);
              }
            }
          }
        }
      }, {
        key: 'afterMouseDownTimeout',
        value: function afterMouseDownTimeout() {
          var _this4 = this;
          var render = function render() {
            _this4.hot.forceFullRender = true;
            _this4.hot.view.render();
            _this4.hot.view.wt.wtOverlays.adjustElementsSize(true);
          };
          var resize = function resize(selectedRow, forceRender) {
            var hookNewSize = _this4.hot.runHooks('beforeRowResize', selectedRow, _this4.newSize, true);
            if (hookNewSize !== void 0) {
              _this4.newSize = hookNewSize;
            }
            _this4.setManualSize(selectedRow, _this4.newSize);
            if (forceRender) {
              render();
            }
            _this4.hot.runHooks('afterRowResize', selectedRow, _this4.newSize, true);
          };
          if (this.dblclick >= 2) {
            var selectedRowsLength = this.selectedRows.length;
            if (selectedRowsLength > 1) {
              (0, _array.arrayEach)(this.selectedRows, function (selectedRow) {
                resize(selectedRow);
              });
              render();
            } else {
              (0, _array.arrayEach)(this.selectedRows, function (selectedRow) {
                resize(selectedRow, true);
              });
            }
          }
          this.dblclick = 0;
          this.autoresizeTimeout = null;
        }
      }, {
        key: 'onMouseDown',
        value: function onMouseDown(event) {
          var _this5 = this;
          if ((0, _element.hasClass)(event.target, 'manualRowResizer')) {
            this.setupGuidePosition();
            this.pressed = this.hot;
            if (this.autoresizeTimeout == null) {
              this.autoresizeTimeout = setTimeout(function () {
                return _this5.afterMouseDownTimeout();
              }, 500);
              this.hot._registerTimeout(this.autoresizeTimeout);
            }
            this.dblclick++;
            this.startY = (0, _event.pageY)(event);
            this.newSize = this.startHeight;
          }
        }
      }, {
        key: 'onMouseMove',
        value: function onMouseMove(event) {
          var _this6 = this;
          if (this.pressed) {
            this.currentHeight = this.startHeight + ((0, _event.pageY)(event) - this.startY);
            (0, _array.arrayEach)(this.selectedRows, function (selectedRow) {
              _this6.newSize = _this6.setManualSize(selectedRow, _this6.currentHeight);
            });
            this.refreshHandlePosition();
            this.refreshGuidePosition();
          }
        }
      }, {
        key: 'onMouseUp',
        value: function onMouseUp(event) {
          var _this7 = this;
          var render = function render() {
            _this7.hot.forceFullRender = true;
            _this7.hot.view.render();
            _this7.hot.view.wt.wtOverlays.adjustElementsSize(true);
          };
          var runHooks = function runHooks(selectedRow, forceRender) {
            _this7.hot.runHooks('beforeRowResize', selectedRow, _this7.newSize);
            if (forceRender) {
              render();
            }
            _this7.saveManualRowHeights();
            _this7.hot.runHooks('afterRowResize', selectedRow, _this7.newSize);
          };
          if (this.pressed) {
            this.hideHandleAndGuide();
            this.pressed = false;
            if (this.newSize != this.startHeight) {
              var selectedRowsLength = this.selectedRows.length;
              if (selectedRowsLength > 1) {
                (0, _array.arrayEach)(this.selectedRows, function (selectedRow) {
                  runHooks(selectedRow);
                });
                render();
              } else {
                (0, _array.arrayEach)(this.selectedRows, function (selectedRow) {
                  runHooks(selectedRow, true);
                });
              }
            }
            this.setupHandlePosition(this.currentTH);
          }
        }
      }, {
        key: 'bindEvents',
        value: function bindEvents() {
          var _this8 = this;
          this.eventManager.addEventListener(this.hot.rootElement, 'mouseover', function (e) {
            return _this8.onMouseOver(e);
          });
          this.eventManager.addEventListener(this.hot.rootElement, 'mousedown', function (e) {
            return _this8.onMouseDown(e);
          });
          this.eventManager.addEventListener(window, 'mousemove', function (e) {
            return _this8.onMouseMove(e);
          });
          this.eventManager.addEventListener(window, 'mouseup', function (e) {
            return _this8.onMouseUp(e);
          });
        }
      }, {
        key: 'setManualSize',
        value: function setManualSize(row, height) {
          row = this.hot.runHooks('modifyRow', row);
          this.manualRowHeights[row] = height;
          return height;
        }
      }, {
        key: 'onModifyRowHeight',
        value: function onModifyRowHeight(height, row) {
          if (this.enabled) {
            var autoRowSizePlugin = this.hot.getPlugin('autoRowSize');
            var autoRowHeightResult = autoRowSizePlugin ? autoRowSizePlugin.heights[row] : null;
            row = this.hot.runHooks('modifyRow', row);
            var manualRowHeight = this.manualRowHeights[row];
            if (manualRowHeight !== void 0 && (manualRowHeight === autoRowHeightResult || manualRowHeight > (height || 0))) {
              return manualRowHeight;
            }
          }
          return height;
        }
      }]);
      return ManualRowResize;
    }(_base2.default);
    (0, _plugins.registerPlugin)('manualRowResize', ManualRowResize);
    exports.default = ManualRowResize;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _pluginHooks = __webpack_require__(11);
    var _pluginHooks2 = _interopRequireDefault(_pluginHooks);
    var _plugins = __webpack_require__(9);
    var _event = __webpack_require__(7);
    var _src = __webpack_require__(14);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function CellInfoCollection() {
      var collection = [];
      collection.getInfo = function (row, col) {
        for (var i = 0, ilen = this.length; i < ilen; i++) {
          if (this[i].row <= row && this[i].row + this[i].rowspan - 1 >= row && this[i].col <= col && this[i].col + this[i].colspan - 1 >= col) {
            return this[i];
          }
        }
      };
      collection.setInfo = function (info) {
        for (var i = 0, ilen = this.length; i < ilen; i++) {
          if (this[i].row === info.row && this[i].col === info.col) {
            this[i] = info;
            return;
          }
        }
        this.push(info);
      };
      collection.removeInfo = function (row, col) {
        for (var i = 0, ilen = this.length; i < ilen; i++) {
          if (this[i].row === row && this[i].col === col) {
            this.splice(i, 1);
            break;
          }
        }
      };
      return collection;
    }

    function MergeCells(mergeCellsSetting) {
      this.mergedCellInfoCollection = new CellInfoCollection();
      if (Array.isArray(mergeCellsSetting)) {
        for (var i = 0, ilen = mergeCellsSetting.length; i < ilen; i++) {
          this.mergedCellInfoCollection.setInfo(mergeCellsSetting[i]);
        }
      }
    }
    MergeCells.prototype.canMergeRange = function (cellRange) {
      return !cellRange.isSingle();
    };
    MergeCells.prototype.mergeRange = function (cellRange) {
      if (!this.canMergeRange(cellRange)) {
        return;
      }
      var topLeft = cellRange.getTopLeftCorner();
      var bottomRight = cellRange.getBottomRightCorner();
      var mergeParent = {};
      mergeParent.row = topLeft.row;
      mergeParent.col = topLeft.col;
      mergeParent.rowspan = bottomRight.row - topLeft.row + 1;
      mergeParent.colspan = bottomRight.col - topLeft.col + 1;
      this.mergedCellInfoCollection.setInfo(mergeParent);
    };
    MergeCells.prototype.mergeOrUnmergeSelection = function (cellRange) {
      var info = this.mergedCellInfoCollection.getInfo(cellRange.from.row, cellRange.from.col);
      if (info) {
        this.unmergeSelection(cellRange.from);
      } else {
        this.mergeSelection(cellRange);
      }
    };
    MergeCells.prototype.mergeSelection = function (cellRange) {
      this.mergeRange(cellRange);
    };
    MergeCells.prototype.unmergeSelection = function (cellRange) {
      var info = this.mergedCellInfoCollection.getInfo(cellRange.row, cellRange.col);
      this.mergedCellInfoCollection.removeInfo(info.row, info.col);
    };
    MergeCells.prototype.applySpanProperties = function (TD, row, col) {
      var info = this.mergedCellInfoCollection.getInfo(row, col);
      if (info) {
        if (info.row === row && info.col === col) {
          TD.setAttribute('rowspan', info.rowspan);
          TD.setAttribute('colspan', info.colspan);
        } else {
          TD.removeAttribute('rowspan');
          TD.removeAttribute('colspan');
          TD.style.display = 'none';
        }
      } else {
        TD.removeAttribute('rowspan');
        TD.removeAttribute('colspan');
      }
    };
    MergeCells.prototype.modifyTransform = function (hook, currentSelectedRange, delta) {
      var sameRowspan = function sameRowspan(merged, coords) {
        if (coords.row >= merged.row && coords.row <= merged.row + merged.rowspan - 1) {
          return true;
        }
        return false;
      },
        sameColspan = function sameColspan(merged, coords) {
          if (coords.col >= merged.col && coords.col <= merged.col + merged.colspan - 1) {
            return true;
          }
          return false;
        },
        getNextPosition = function getNextPosition(newDelta) {
          return new _src.CellCoords(currentSelectedRange.to.row + newDelta.row, currentSelectedRange.to.col + newDelta.col);
        };
      var newDelta = {
        row: delta.row,
        col: delta.col
      };
      if (hook == 'modifyTransformStart') {
        var nextPosition;
        if (!this.lastDesiredCoords) {
          this.lastDesiredCoords = new _src.CellCoords(null, null);
        }
        var currentPosition = new _src.CellCoords(currentSelectedRange.highlight.row, currentSelectedRange.highlight.col),
          mergedParent = this.mergedCellInfoCollection.getInfo(currentPosition.row, currentPosition.col),
          currentRangeContainsMerge;
        for (var i = 0, mergesLength = this.mergedCellInfoCollection.length; i < mergesLength; i++) {
          var range = this.mergedCellInfoCollection[i];
          range = new _src.CellCoords(range.row + range.rowspan - 1, range.col + range.colspan - 1);
          if (currentSelectedRange.includes(range)) {
            currentRangeContainsMerge = true;
            break;
          }
        }
        if (mergedParent) {
          var mergeTopLeft = new _src.CellCoords(mergedParent.row, mergedParent.col);
          var mergeBottomRight = new _src.CellCoords(mergedParent.row + mergedParent.rowspan - 1, mergedParent.col + mergedParent.colspan - 1);
          var mergeRange = new _src.CellRange(mergeTopLeft, mergeTopLeft, mergeBottomRight);
          if (!mergeRange.includes(this.lastDesiredCoords)) {
            this.lastDesiredCoords = new _src.CellCoords(null, null);
          }
          newDelta.row = this.lastDesiredCoords.row ? this.lastDesiredCoords.row - currentPosition.row : newDelta.row;
          newDelta.col = this.lastDesiredCoords.col ? this.lastDesiredCoords.col - currentPosition.col : newDelta.col;
          if (delta.row > 0) {
            newDelta.row = mergedParent.row + mergedParent.rowspan - 1 - currentPosition.row + delta.row;
          } else if (delta.row < 0) {
            newDelta.row = currentPosition.row - mergedParent.row + delta.row;
          }
          if (delta.col > 0) {
            newDelta.col = mergedParent.col + mergedParent.colspan - 1 - currentPosition.col + delta.col;
          } else if (delta.col < 0) {
            newDelta.col = currentPosition.col - mergedParent.col + delta.col;
          }
        }
        nextPosition = new _src.CellCoords(currentSelectedRange.highlight.row + newDelta.row, currentSelectedRange.highlight.col + newDelta.col);
        var nextParentIsMerged = this.mergedCellInfoCollection.getInfo(nextPosition.row, nextPosition.col);
        if (nextParentIsMerged) {
          this.lastDesiredCoords = nextPosition;
          newDelta = {
            row: nextParentIsMerged.row - currentPosition.row,
            col: nextParentIsMerged.col - currentPosition.col
          };
        }
      } else if (hook == 'modifyTransformEnd') {
        for (var _i = 0, _mergesLength = this.mergedCellInfoCollection.length; _i < _mergesLength; _i++) {
          var currentMerge = this.mergedCellInfoCollection[_i];
          var _mergeTopLeft = new _src.CellCoords(currentMerge.row, currentMerge.col);
          var _mergeBottomRight = new _src.CellCoords(currentMerge.row + currentMerge.rowspan - 1, currentMerge.col + currentMerge.colspan - 1);
          var mergedRange = new _src.CellRange(_mergeTopLeft, _mergeTopLeft, _mergeBottomRight);
          var sharedBorders = currentSelectedRange.getBordersSharedWith(mergedRange);
          if (mergedRange.isEqual(currentSelectedRange)) {
            currentSelectedRange.setDirection('NW-SE');
          } else if (sharedBorders.length > 0) {
            var mergeHighlighted = currentSelectedRange.highlight.isEqual(mergedRange.from);
            if (sharedBorders.indexOf('top') > -1) {
              if (currentSelectedRange.to.isSouthEastOf(mergedRange.from) && mergeHighlighted) {
                currentSelectedRange.setDirection('NW-SE');
              } else if (currentSelectedRange.to.isSouthWestOf(mergedRange.from) && mergeHighlighted) {
                currentSelectedRange.setDirection('NE-SW');
              }
            } else if (sharedBorders.indexOf('bottom') > -1) {
              if (currentSelectedRange.to.isNorthEastOf(mergedRange.from) && mergeHighlighted) {
                currentSelectedRange.setDirection('SW-NE');
              } else if (currentSelectedRange.to.isNorthWestOf(mergedRange.from) && mergeHighlighted) {
                currentSelectedRange.setDirection('SE-NW');
              }
            }
          }
          nextPosition = getNextPosition(newDelta);
          var withinRowspan = sameRowspan(currentMerge, nextPosition),
            withinColspan = sameColspan(currentMerge, nextPosition);
          if (currentSelectedRange.includesRange(mergedRange) && (mergedRange.includes(nextPosition) || withinRowspan || withinColspan)) {
            if (withinRowspan) {
              if (newDelta.row < 0) {
                newDelta.row -= currentMerge.rowspan - 1;
              } else if (newDelta.row > 0) {
                newDelta.row += currentMerge.rowspan - 1;
              }
            }
            if (withinColspan) {
              if (newDelta.col < 0) {
                newDelta.col -= currentMerge.colspan - 1;
              } else if (newDelta.col > 0) {
                newDelta.col += currentMerge.colspan - 1;
              }
            }
          }
        }
      }
      if (newDelta.row !== 0) {
        delta.row = newDelta.row;
      }
      if (newDelta.col !== 0) {
        delta.col = newDelta.col;
      }
    };
    MergeCells.prototype.shiftCollection = function (direction, index, count) {
      var shiftVector = [0, 0];
      switch (direction) {
        case 'right':
          shiftVector[0] += 1;
          break;
        case 'left':
          shiftVector[0] -= 1;
          break;
        case 'down':
          shiftVector[1] += 1;
          break;
        case 'up':
          shiftVector[1] -= 1;
          break;
        default:
          break;
      }
      for (var i = 0; i < this.mergedCellInfoCollection.length; i++) {
        var currentMerge = this.mergedCellInfoCollection[i];
        if (direction === 'right' || direction === 'left') {
          if (index <= currentMerge.col) {
            currentMerge.col += shiftVector[0];
          }
        } else if (index <= currentMerge.row) {
          currentMerge.row += shiftVector[1];
        }
      }
    };
    var beforeInit = function beforeInit() {
      var instance = this;
      var mergeCellsSetting = instance.getSettings().mergeCells;
      if (mergeCellsSetting) {
        if (!instance.mergeCells) {
          instance.mergeCells = new MergeCells(mergeCellsSetting);
        }
      }
    };
    var afterInit = function afterInit() {
      var instance = this;
      if (instance.mergeCells) {
        instance.view.wt.wtTable.getCell = function (coords) {
          if (instance.getSettings().mergeCells) {
            var mergeParent = instance.mergeCells.mergedCellInfoCollection.getInfo(coords.row, coords.col);
            if (mergeParent) {
              coords = mergeParent;
            }
          }
          return _src.Table.prototype.getCell.call(this, coords);
        };
      }
    };
    var afterUpdateSettings = function afterUpdateSettings() {
      var instance = this;
      var mergeCellsSetting = instance.getSettings().mergeCells;
      if (mergeCellsSetting) {
        if (instance.mergeCells) {
          instance.mergeCells.mergedCellInfoCollection = new CellInfoCollection();
          if (Array.isArray(mergeCellsSetting)) {
            for (var i = 0, ilen = mergeCellsSetting.length; i < ilen; i++) {
              instance.mergeCells.mergedCellInfoCollection.setInfo(mergeCellsSetting[i]);
            }
          }
        } else {
          instance.mergeCells = new MergeCells(mergeCellsSetting);
        }
      } else if (instance.mergeCells) {
        instance.mergeCells.mergedCellInfoCollection = new CellInfoCollection();
      }
    };
    var onBeforeKeyDown = function onBeforeKeyDown(event) {
      if (!this.mergeCells) {
        return;
      }
      var ctrlDown = (event.ctrlKey || event.metaKey) && !event.altKey;
      if (ctrlDown) {
        if (event.keyCode === 77) {
          this.mergeCells.mergeOrUnmergeSelection(this.getSelectedRange());
          this.render();
          (0, _event.stopImmediatePropagation)(event);
        }
      }
    };
    var addMergeActionsToContextMenu = function addMergeActionsToContextMenu(defaultOptions) {
      if (!this.getSettings().mergeCells) {
        return;
      }
      defaultOptions.items.push({
        name: '---------'
      });
      defaultOptions.items.push({
        key: 'mergeCells',
        name: function name() {
          var sel = this.getSelected();
          var info = this.mergeCells.mergedCellInfoCollection.getInfo(sel[0], sel[1]);
          if (info) {
            return 'Unmerge cells';
          }
          return 'Merge cells';
        },
        callback: function callback() {
          this.mergeCells.mergeOrUnmergeSelection(this.getSelectedRange());
          this.render();
        },
        disabled: function disabled() {
          return this.selection.selectedHeader.corner;
        }
      });
    };
    var afterRenderer = function afterRenderer(TD, row, col, prop, value, cellProperties) {
      if (this.mergeCells) {
        this.mergeCells.applySpanProperties(TD, row, col);
      }
    };
    var modifyTransformFactory = function modifyTransformFactory(hook) {
      return function (delta) {
        var mergeCellsSetting = this.getSettings().mergeCells;
        if (mergeCellsSetting) {
          var currentSelectedRange = this.getSelectedRange();
          this.mergeCells.modifyTransform(hook, currentSelectedRange, delta);
          if (hook === 'modifyTransformEnd') {
            var totalRows = this.countRows();
            var totalCols = this.countCols();
            if (currentSelectedRange.from.row < 0) {
              currentSelectedRange.from.row = 0;
            } else if (currentSelectedRange.from.row > 0 && currentSelectedRange.from.row >= totalRows) {
              currentSelectedRange.from.row = currentSelectedRange.from - 1;
            }
            if (currentSelectedRange.from.col < 0) {
              currentSelectedRange.from.col = 0;
            } else if (currentSelectedRange.from.col > 0 && currentSelectedRange.from.col >= totalCols) {
              currentSelectedRange.from.col = totalCols - 1;
            }
          }
        }
      };
    };
    var beforeSetRangeEnd = function beforeSetRangeEnd(coords) {
      this.lastDesiredCoords = null;
      var mergeCellsSetting = this.getSettings().mergeCells;
      if (mergeCellsSetting) {
        var selRange = this.getSelectedRange();
        selRange.highlight = new _src.CellCoords(selRange.highlight.row, selRange.highlight.col);
        selRange.to = coords;
        var rangeExpanded = false;
        do {
          rangeExpanded = false;
          for (var i = 0, ilen = this.mergeCells.mergedCellInfoCollection.length; i < ilen; i++) {
            var cellInfo = this.mergeCells.mergedCellInfoCollection[i];
            var mergedCellTopLeft = new _src.CellCoords(cellInfo.row, cellInfo.col);
            var mergedCellBottomRight = new _src.CellCoords(cellInfo.row + cellInfo.rowspan - 1, cellInfo.col + cellInfo.colspan - 1);
            var mergedCellRange = new _src.CellRange(mergedCellTopLeft, mergedCellTopLeft, mergedCellBottomRight);
            if (selRange.expandByRange(mergedCellRange)) {
              coords.row = selRange.to.row;
              coords.col = selRange.to.col;
              rangeExpanded = true;
            }
          }
        } while (rangeExpanded);
      }
    };
    var beforeDrawAreaBorders = function beforeDrawAreaBorders(corners, className) {
      if (className && className == 'area') {
        var mergeCellsSetting = this.getSettings().mergeCells;
        if (mergeCellsSetting) {
          var selRange = this.getSelectedRange();
          var startRange = new _src.CellRange(selRange.from, selRange.from, selRange.from);
          var stopRange = new _src.CellRange(selRange.to, selRange.to, selRange.to);
          for (var i = 0, ilen = this.mergeCells.mergedCellInfoCollection.length; i < ilen; i++) {
            var cellInfo = this.mergeCells.mergedCellInfoCollection[i];
            var mergedCellTopLeft = new _src.CellCoords(cellInfo.row, cellInfo.col);
            var mergedCellBottomRight = new _src.CellCoords(cellInfo.row + cellInfo.rowspan - 1, cellInfo.col + cellInfo.colspan - 1);
            var mergedCellRange = new _src.CellRange(mergedCellTopLeft, mergedCellTopLeft, mergedCellBottomRight);
            if (startRange.expandByRange(mergedCellRange)) {
              corners[0] = startRange.from.row;
              corners[1] = startRange.from.col;
            }
            if (stopRange.expandByRange(mergedCellRange)) {
              corners[2] = stopRange.from.row;
              corners[3] = stopRange.from.col;
            }
          }
        }
      }
    };
    var afterGetCellMeta = function afterGetCellMeta(row, col, cellProperties) {
      var mergeCellsSetting = this.getSettings().mergeCells;
      if (mergeCellsSetting) {
        var mergeParent = this.mergeCells.mergedCellInfoCollection.getInfo(row, col);
        if (mergeParent && (mergeParent.row != row || mergeParent.col != col)) {
          cellProperties.copyable = false;
        }
      }
    };
    var afterViewportRowCalculatorOverride = function afterViewportRowCalculatorOverride(calc) {
      var mergeCellsSetting = this.getSettings().mergeCells;
      if (mergeCellsSetting) {
        var colCount = this.countCols();
        var mergeParent;
        for (var c = 0; c < colCount; c++) {
          mergeParent = this.mergeCells.mergedCellInfoCollection.getInfo(calc.startRow, c);
          if (mergeParent) {
            if (mergeParent.row < calc.startRow) {
              calc.startRow = mergeParent.row;
              return afterViewportRowCalculatorOverride.call(this, calc);
            }
          }
          mergeParent = this.mergeCells.mergedCellInfoCollection.getInfo(calc.endRow, c);
          if (mergeParent) {
            var mergeEnd = mergeParent.row + mergeParent.rowspan - 1;
            if (mergeEnd > calc.endRow) {
              calc.endRow = mergeEnd;
              return afterViewportRowCalculatorOverride.call(this, calc);
            }
          }
        }
      }
    };
    var afterViewportColumnCalculatorOverride = function afterViewportColumnCalculatorOverride(calc) {
      var mergeCellsSetting = this.getSettings().mergeCells;
      if (mergeCellsSetting) {
        var rowCount = this.countRows();
        var mergeParent;
        for (var r = 0; r < rowCount; r++) {
          mergeParent = this.mergeCells.mergedCellInfoCollection.getInfo(r, calc.startColumn);
          if (mergeParent) {
            if (mergeParent.col < calc.startColumn) {
              calc.startColumn = mergeParent.col;
              return afterViewportColumnCalculatorOverride.call(this, calc);
            }
          }
          mergeParent = this.mergeCells.mergedCellInfoCollection.getInfo(r, calc.endColumn);
          if (mergeParent) {
            var mergeEnd = mergeParent.col + mergeParent.colspan - 1;
            if (mergeEnd > calc.endColumn) {
              calc.endColumn = mergeEnd;
              return afterViewportColumnCalculatorOverride.call(this, calc);
            }
          }
        }
      }
    };
    var isMultipleSelection = function isMultipleSelection(isMultiple) {
      if (isMultiple && this.mergeCells) {
        var mergedCells = this.mergeCells.mergedCellInfoCollection,
          selectionRange = this.getSelectedRange();
        for (var group in mergedCells) {
          if (selectionRange.highlight.row == mergedCells[group].row && selectionRange.highlight.col == mergedCells[group].col && selectionRange.to.row == mergedCells[group].row + mergedCells[group].rowspan - 1 && selectionRange.to.col == mergedCells[group].col + mergedCells[group].colspan - 1) {
            return false;
          }
        }
      }
      return isMultiple;
    };

    function modifyAutofillRange(select, drag) {
      var mergeCellsSetting = this.getSettings().mergeCells;
      if (!mergeCellsSetting || this.selection.isMultiple()) {
        return;
      }
      var info = this.mergeCells.mergedCellInfoCollection.getInfo(select[0], select[1]);
      if (info) {
        select[0] = info.row;
        select[1] = info.col;
        select[2] = info.row + info.rowspan - 1;
        select[3] = info.col + info.colspan - 1;
      }
    }

    function onAfterCreateCol(col, count) {
      if (this.mergeCells) {
        this.mergeCells.shiftCollection('right', col, count);
      }
    }

    function onAfterRemoveCol(col, count) {
      if (this.mergeCells) {
        this.mergeCells.shiftCollection('left', col, count);
      }
    }

    function onAfterCreateRow(row, count) {
      if (this.mergeCells) {
        this.mergeCells.shiftCollection('down', row, count);
      }
    }

    function onAfterRemoveRow(row, count) {
      if (this.mergeCells) {
        this.mergeCells.shiftCollection('up', row, count);
      }
    }
    var hook = _pluginHooks2.default.getSingleton();
    hook.add('beforeInit', beforeInit);
    hook.add('afterInit', afterInit);
    hook.add('afterUpdateSettings', afterUpdateSettings);
    hook.add('beforeKeyDown', onBeforeKeyDown);
    hook.add('modifyTransformStart', modifyTransformFactory('modifyTransformStart'));
    hook.add('modifyTransformEnd', modifyTransformFactory('modifyTransformEnd'));
    hook.add('beforeSetRangeEnd', beforeSetRangeEnd);
    hook.add('beforeDrawBorders', beforeDrawAreaBorders);
    hook.add('afterIsMultipleSelection', isMultipleSelection);
    hook.add('afterRenderer', afterRenderer);
    hook.add('afterContextMenuDefaultOptions', addMergeActionsToContextMenu);
    hook.add('afterGetCellMeta', afterGetCellMeta);
    hook.add('afterViewportRowCalculatorOverride', afterViewportRowCalculatorOverride);
    hook.add('afterViewportColumnCalculatorOverride', afterViewportColumnCalculatorOverride);
    hook.add('modifyAutofillRange', modifyAutofillRange);
    hook.add('afterCreateCol', onAfterCreateCol);
    hook.add('afterRemoveCol', onAfterRemoveCol);
    hook.add('afterCreateRow', onAfterCreateRow);
    hook.add('afterRemoveRow', onAfterRemoveRow);
    exports.default = MergeCells;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    var _get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);
      if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);
        if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;
        if (getter === undefined) {
          return undefined;
        }
        return getter.call(receiver);
      }
    };
    var _pluginHooks = __webpack_require__(11);
    var _pluginHooks2 = _interopRequireDefault(_pluginHooks);
    var _element = __webpack_require__(0);
    var _browser = __webpack_require__(22);
    var _base = __webpack_require__(16);
    var _base2 = _interopRequireDefault(_base);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _plugins = __webpack_require__(9);
    var _src = __webpack_require__(14);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return call && (typeof call === "object" || typeof call === "function") ? call : self;
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
    var MultipleSelectionHandles = function (_BasePlugin) {
      _inherits(MultipleSelectionHandles, _BasePlugin);

      function MultipleSelectionHandles(hotInstance) {
        _classCallCheck(this, MultipleSelectionHandles);
        var _this2 = _possibleConstructorReturn(this, (MultipleSelectionHandles.__proto__ || Object.getPrototypeOf(MultipleSelectionHandles)).call(this, hotInstance));
        _this2.dragged = [];
        _this2.eventManager = null;
        _this2.lastSetCell = null;
        return _this2;
      }
      _createClass(MultipleSelectionHandles, [{
        key: 'isEnabled',
        value: function isEnabled() {
          return (0, _browser.isMobileBrowser)();
        }
      }, {
        key: 'enablePlugin',
        value: function enablePlugin() {
          if (this.enabled) {
            return;
          }
          if (!this.eventManager) {
            this.eventManager = new _eventManager2.default(this);
          }
          this.registerListeners();
          _get(MultipleSelectionHandles.prototype.__proto__ || Object.getPrototypeOf(MultipleSelectionHandles.prototype), 'enablePlugin', this).call(this);
        }
      }, {
        key: 'registerListeners',
        value: function registerListeners() {
          var _this = this;

          function removeFromDragged(query) {
            if (_this.dragged.length === 1) {
              _this.dragged.splice(0, _this.dragged.length);
              return true;
            }
            var entryPosition = _this.dragged.indexOf(query);
            if (entryPosition == -1) {
              return false;
            } else if (entryPosition === 0) {
              _this.dragged = _this.dragged.slice(0, 1);
            } else if (entryPosition == 1) {
              _this.dragged = _this.dragged.slice(-1);
            }
          }
          this.eventManager.addEventListener(this.hot.rootElement, 'touchstart', function (event) {
            var selectedRange = void 0;
            if ((0, _element.hasClass)(event.target, 'topLeftSelectionHandle-HitArea')) {
              selectedRange = _this.hot.getSelectedRange();
              _this.dragged.push('topLeft');
              _this.touchStartRange = {
                width: selectedRange.getWidth(),
                height: selectedRange.getHeight(),
                direction: selectedRange.getDirection()
              };
              event.preventDefault();
              return false;
            } else if ((0, _element.hasClass)(event.target, 'bottomRightSelectionHandle-HitArea')) {
              selectedRange = _this.hot.getSelectedRange();
              _this.dragged.push('bottomRight');
              _this.touchStartRange = {
                width: selectedRange.getWidth(),
                height: selectedRange.getHeight(),
                direction: selectedRange.getDirection()
              };
              event.preventDefault();
              return false;
            }
          });
          this.eventManager.addEventListener(this.hot.rootElement, 'touchend', function (event) {
            if ((0, _element.hasClass)(event.target, 'topLeftSelectionHandle-HitArea')) {
              removeFromDragged.call(_this, 'topLeft');
              _this.touchStartRange = void 0;
              event.preventDefault();
              return false;
            } else if ((0, _element.hasClass)(event.target, 'bottomRightSelectionHandle-HitArea')) {
              removeFromDragged.call(_this, 'bottomRight');
              _this.touchStartRange = void 0;
              event.preventDefault();
              return false;
            }
          });
          this.eventManager.addEventListener(this.hot.rootElement, 'touchmove', function (event) {
            var scrollTop = (0, _element.getWindowScrollTop)(),
              scrollLeft = (0, _element.getWindowScrollLeft)(),
              endTarget = void 0,
              targetCoords = void 0,
              selectedRange = void 0,
              rangeWidth = void 0,
              rangeHeight = void 0,
              rangeDirection = void 0,
              newRangeCoords = void 0;
            if (_this.dragged.length === 0) {
              return;
            }
            endTarget = document.elementFromPoint(event.touches[0].screenX - scrollLeft, event.touches[0].screenY - scrollTop);
            if (!endTarget || endTarget === _this.lastSetCell) {
              return;
            }
            if (endTarget.nodeName == 'TD' || endTarget.nodeName == 'TH') {
              targetCoords = _this.hot.getCoords(endTarget);
              if (targetCoords.col == -1) {
                targetCoords.col = 0;
              }
              selectedRange = _this.hot.getSelectedRange();
              rangeWidth = selectedRange.getWidth();
              rangeHeight = selectedRange.getHeight();
              rangeDirection = selectedRange.getDirection();
              if (rangeWidth == 1 && rangeHeight == 1) {
                _this.hot.selection.setRangeEnd(targetCoords);
              }
              newRangeCoords = _this.getCurrentRangeCoords(selectedRange, targetCoords, _this.touchStartRange.direction, rangeDirection, _this.dragged[0]);
              if (newRangeCoords.start !== null) {
                _this.hot.selection.setRangeStart(newRangeCoords.start);
              }
              _this.hot.selection.setRangeEnd(newRangeCoords.end);
              _this.lastSetCell = endTarget;
            }
            event.preventDefault();
          });
        }
      }, {
        key: 'getCurrentRangeCoords',
        value: function getCurrentRangeCoords(selectedRange, currentTouch, touchStartDirection, currentDirection, draggedHandle) {
          var topLeftCorner = selectedRange.getTopLeftCorner(),
            bottomRightCorner = selectedRange.getBottomRightCorner(),
            bottomLeftCorner = selectedRange.getBottomLeftCorner(),
            topRightCorner = selectedRange.getTopRightCorner();
          var newCoords = {
            start: null,
            end: null
          };
          switch (touchStartDirection) {
            case 'NE-SW':
              switch (currentDirection) {
                case 'NE-SW':
                case 'NW-SE':
                  if (draggedHandle == 'topLeft') {
                    newCoords = {
                      start: new _src.CellCoords(currentTouch.row, selectedRange.highlight.col),
                      end: new _src.CellCoords(bottomLeftCorner.row, currentTouch.col)
                    };
                  } else {
                    newCoords = {
                      start: new _src.CellCoords(selectedRange.highlight.row, currentTouch.col),
                      end: new _src.CellCoords(currentTouch.row, topLeftCorner.col)
                    };
                  }
                  break;
                case 'SE-NW':
                  if (draggedHandle == 'bottomRight') {
                    newCoords = {
                      start: new _src.CellCoords(bottomRightCorner.row, currentTouch.col),
                      end: new _src.CellCoords(currentTouch.row, topLeftCorner.col)
                    };
                  }
                  break;
                default:
                  break;
              }
              break;
            case 'NW-SE':
              switch (currentDirection) {
                case 'NE-SW':
                  if (draggedHandle == 'topLeft') {
                    newCoords = {
                      start: currentTouch,
                      end: bottomLeftCorner
                    };
                  } else {
                    newCoords.end = currentTouch;
                  }
                  break;
                case 'NW-SE':
                  if (draggedHandle == 'topLeft') {
                    newCoords = {
                      start: currentTouch,
                      end: bottomRightCorner
                    };
                  } else {
                    newCoords.end = currentTouch;
                  }
                  break;
                case 'SE-NW':
                  if (draggedHandle == 'topLeft') {
                    newCoords = {
                      start: currentTouch,
                      end: topLeftCorner
                    };
                  } else {
                    newCoords.end = currentTouch;
                  }
                  break;
                case 'SW-NE':
                  if (draggedHandle == 'topLeft') {
                    newCoords = {
                      start: currentTouch,
                      end: topRightCorner
                    };
                  } else {
                    newCoords.end = currentTouch;
                  }
                  break;
                default:
                  break;
              }
              break;
            case 'SW-NE':
              switch (currentDirection) {
                case 'NW-SE':
                  if (draggedHandle == 'bottomRight') {
                    newCoords = {
                      start: new _src.CellCoords(currentTouch.row, topLeftCorner.col),
                      end: new _src.CellCoords(bottomLeftCorner.row, currentTouch.col)
                    };
                  } else {
                    newCoords = {
                      start: new _src.CellCoords(topLeftCorner.row, currentTouch.col),
                      end: new _src.CellCoords(currentTouch.row, bottomRightCorner.col)
                    };
                  }
                  break;
                case 'SW-NE':
                  if (draggedHandle == 'topLeft') {
                    newCoords = {
                      start: new _src.CellCoords(selectedRange.highlight.row, currentTouch.col),
                      end: new _src.CellCoords(currentTouch.row, bottomRightCorner.col)
                    };
                  } else {
                    newCoords = {
                      start: new _src.CellCoords(currentTouch.row, topLeftCorner.col),
                      end: new _src.CellCoords(topLeftCorner.row, currentTouch.col)
                    };
                  }
                  break;
                case 'SE-NW':
                  if (draggedHandle == 'bottomRight') {
                    newCoords = {
                      start: new _src.CellCoords(currentTouch.row, topRightCorner.col),
                      end: new _src.CellCoords(topLeftCorner.row, currentTouch.col)
                    };
                  } else if (draggedHandle == 'topLeft') {
                    newCoords = {
                      start: bottomLeftCorner,
                      end: currentTouch
                    };
                  }
                  break;
                default:
                  break;
              }
              break;
            case 'SE-NW':
              switch (currentDirection) {
                case 'NW-SE':
                case 'NE-SW':
                case 'SW-NE':
                  if (draggedHandle == 'topLeft') {
                    newCoords.end = currentTouch;
                  }
                  break;
                case 'SE-NW':
                  if (draggedHandle == 'topLeft') {
                    newCoords.end = currentTouch;
                  } else {
                    newCoords = {
                      start: currentTouch,
                      end: topLeftCorner
                    };
                  }
                  break;
                default:
                  break;
              }
              break;
            default:
              break;
          }
          return newCoords;
        }
      }, {
        key: 'isDragged',
        value: function isDragged() {
          return this.dragged.length > 0;
        }
      }]);
      return MultipleSelectionHandles;
    }(_base2.default);
    (0, _plugins.registerPlugin)('multipleSelectionHandles', MultipleSelectionHandles);
    exports.default = MultipleSelectionHandles;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
      return typeof obj;
    } : function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
    var _pluginHooks = __webpack_require__(11);
    var _pluginHooks2 = _interopRequireDefault(_pluginHooks);
    var _element = __webpack_require__(0);
    var _renderers = __webpack_require__(6);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function Search(instance) {
      this.query = function (queryStr, callback, queryMethod) {
        var rowCount = instance.countRows();
        var colCount = instance.countCols();
        var queryResult = [];
        if (!callback) {
          callback = Search.global.getDefaultCallback();
        }
        if (!queryMethod) {
          queryMethod = Search.global.getDefaultQueryMethod();
        }
        for (var rowIndex = 0; rowIndex < rowCount; rowIndex++) {
          for (var colIndex = 0; colIndex < colCount; colIndex++) {
            var cellData = instance.getDataAtCell(rowIndex, colIndex);
            var cellProperties = instance.getCellMeta(rowIndex, colIndex);
            var cellCallback = cellProperties.search.callback || callback;
            var cellQueryMethod = cellProperties.search.queryMethod || queryMethod;
            var testResult = cellQueryMethod(queryStr, cellData);
            if (testResult) {
              var singleResult = {
                row: rowIndex,
                col: colIndex,
                data: cellData
              };
              queryResult.push(singleResult);
            }
            if (cellCallback) {
              cellCallback(instance, rowIndex, colIndex, cellData, testResult);
            }
          }
        }
        return queryResult;
      };
    };
    Search.DEFAULT_CALLBACK = function (instance, row, col, data, testResult) {
      instance.getCellMeta(row, col).isSearchResult = testResult;
    };
    Search.DEFAULT_QUERY_METHOD = function (query, value) {
      if (typeof query == 'undefined' || query == null || !query.toLowerCase || query.length === 0) {
        return false;
      }
      if (typeof value == 'undefined' || value == null) {
        return false;
      }
      return value.toString().toLowerCase().indexOf(query.toLowerCase()) != -1;
    };
    Search.DEFAULT_SEARCH_RESULT_CLASS = 'htSearchResult';
    Search.global = function () {
      var defaultCallback = Search.DEFAULT_CALLBACK;
      var defaultQueryMethod = Search.DEFAULT_QUERY_METHOD;
      var defaultSearchResultClass = Search.DEFAULT_SEARCH_RESULT_CLASS;
      return {
        getDefaultCallback: function getDefaultCallback() {
          return defaultCallback;
        },
        setDefaultCallback: function setDefaultCallback(newDefaultCallback) {
          defaultCallback = newDefaultCallback;
        },
        getDefaultQueryMethod: function getDefaultQueryMethod() {
          return defaultQueryMethod;
        },
        setDefaultQueryMethod: function setDefaultQueryMethod(newDefaultQueryMethod) {
          defaultQueryMethod = newDefaultQueryMethod;
        },
        getDefaultSearchResultClass: function getDefaultSearchResultClass() {
          return defaultSearchResultClass;
        },
        setDefaultSearchResultClass: function setDefaultSearchResultClass(newSearchResultClass) {
          defaultSearchResultClass = newSearchResultClass;
        }
      };
    }();

    function SearchCellDecorator(instance, TD, row, col, prop, value, cellProperties) {
      var searchResultClass = cellProperties.search !== null && _typeof(cellProperties.search) == 'object' && cellProperties.search.searchResultClass || Search.global.getDefaultSearchResultClass();
      if (cellProperties.isSearchResult) {
        (0, _element.addClass)(TD, searchResultClass);
      } else {
        (0, _element.removeClass)(TD, searchResultClass);
      }
    };
    var originalBaseRenderer = (0, _renderers.getRenderer)('base');
    (0, _renderers.registerRenderer)('base', function (instance, TD, row, col, prop, value, cellProperties) {
      originalBaseRenderer.apply(this, arguments);
      SearchCellDecorator.apply(this, arguments);
    });

    function init() {
      var instance = this;
      var pluginEnabled = !!instance.getSettings().search;
      if (pluginEnabled) {
        instance.search = new Search(instance);
      } else {
        delete instance.search;
      }
    }
    _pluginHooks2.default.getSingleton().add('afterInit', init);
    _pluginHooks2.default.getSingleton().add('afterUpdateSettings', init);
    exports.default = Search;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _element = __webpack_require__(0);

    function cellDecorator(instance, TD, row, col, prop, value, cellProperties) {
      if (cellProperties.className) {
        if (TD.className) {
          TD.className = TD.className + ' ' + cellProperties.className;
        } else {
          TD.className = cellProperties.className;
        }
      }
      if (cellProperties.readOnly) {
        (0, _element.addClass)(TD, cellProperties.readOnlyCellClassName);
      }
      if (cellProperties.valid === false && cellProperties.invalidCellClassName) {
        (0, _element.addClass)(TD, cellProperties.invalidCellClassName);
      } else {
        (0, _element.removeClass)(TD, cellProperties.invalidCellClassName);
      }
      if (cellProperties.wordWrap === false && cellProperties.noWordWrapClassName) {
        (0, _element.addClass)(TD, cellProperties.noWordWrapClassName);
      }
      if (!value && cellProperties.placeholder) {
        (0, _element.addClass)(TD, cellProperties.placeholderCellClassName);
      }
    }
    exports.default = cellDecorator;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _element = __webpack_require__(0);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _src = __webpack_require__(14);
    var _index = __webpack_require__(6);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }
    var clonableWRAPPER = document.createElement('DIV');
    clonableWRAPPER.className = 'htAutocompleteWrapper';
    var clonableARROW = document.createElement('DIV');
    clonableARROW.className = 'htAutocompleteArrow';
    clonableARROW.appendChild(document.createTextNode(String.fromCharCode(9660)));
    var wrapTdContentWithWrapper = function wrapTdContentWithWrapper(TD, WRAPPER) {
      WRAPPER.innerHTML = TD.innerHTML;
      (0, _element.empty)(TD);
      TD.appendChild(WRAPPER);
    };

    function autocompleteRenderer(instance, TD, row, col, prop, value, cellProperties) {
      var WRAPPER = clonableWRAPPER.cloneNode(true);
      var ARROW = clonableARROW.cloneNode(true);
      if (cellProperties.allowHtml) {
        (0, _index.getRenderer)('html').apply(this, arguments);
      } else {
        (0, _index.getRenderer)('text').apply(this, arguments);
      }
      TD.appendChild(ARROW);
      (0, _element.addClass)(TD, 'htAutocomplete');
      if (!TD.firstChild) {
        TD.appendChild(document.createTextNode(String.fromCharCode(160)));
      }
      if (!instance.acArrowListener) {
        var eventManager = new _eventManager2.default(instance);
        instance.acArrowListener = function (event) {
          if ((0, _element.hasClass)(event.target, 'htAutocompleteArrow')) {
            instance.view.wt.getSetting('onCellDblClick', null, new _src.CellCoords(row, col), TD);
          }
        };
        eventManager.addEventListener(instance.rootElement, 'mousedown', instance.acArrowListener);
        instance.addHookOnce('afterDestroy', function () {
          eventManager.destroy();
        });
      }
    }
    exports.default = autocompleteRenderer;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _element = __webpack_require__(0);
    var _string = __webpack_require__(28);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _unicode = __webpack_require__(15);
    var _function = __webpack_require__(35);
    var _event = __webpack_require__(7);
    var _index = __webpack_require__(6);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }
    var isListeningKeyDownEvent = new WeakMap();
    var isCheckboxListenerAdded = new WeakMap();
    var BAD_VALUE_CLASS = 'htBadValue';

    function checkboxRenderer(instance, TD, row, col, prop, value, cellProperties) {
      (0, _index.getRenderer)('base').apply(this, arguments);
      var eventManager = registerEvents(instance);
      var input = createInput();
      var labelOptions = cellProperties.label;
      var badValue = false;
      if (typeof cellProperties.checkedTemplate === 'undefined') {
        cellProperties.checkedTemplate = true;
      }
      if (typeof cellProperties.uncheckedTemplate === 'undefined') {
        cellProperties.uncheckedTemplate = false;
      } (0, _element.empty)(TD);
      if (value === cellProperties.checkedTemplate || (0, _string.equalsIgnoreCase)(value, cellProperties.checkedTemplate)) {
        input.checked = true;
      } else if (value === cellProperties.uncheckedTemplate || (0, _string.equalsIgnoreCase)(value, cellProperties.uncheckedTemplate)) {
        input.checked = false;
      } else if (value === null) {
        (0, _element.addClass)(input, 'noValue');
      } else {
        input.style.display = 'none';
        (0, _element.addClass)(input, BAD_VALUE_CLASS);
        badValue = true;
      }
      input.setAttribute('data-row', row);
      input.setAttribute('data-col', col);
      if (!badValue && labelOptions) {
        var labelText = '';
        if (labelOptions.value) {
          labelText = typeof labelOptions.value === 'function' ? labelOptions.value.call(this, row, col, prop, value) : labelOptions.value;
        } else if (labelOptions.property) {
          labelText = instance.getDataAtRowProp(row, labelOptions.property);
        }
        var label = createLabel(labelText);
        if (labelOptions.position === 'before') {
          label.appendChild(input);
        } else {
          label.insertBefore(input, label.firstChild);
        }
        input = label;
      }
      TD.appendChild(input);
      if (badValue) {
        TD.appendChild(document.createTextNode('#bad-value#'));
      }
      if (!isListeningKeyDownEvent.has(instance)) {
        isListeningKeyDownEvent.set(instance, true);
        instance.addHook('beforeKeyDown', onBeforeKeyDown);
      }

      function onBeforeKeyDown(event) {
        var toggleKeys = 'SPACE|ENTER';
        var switchOffKeys = 'DELETE|BACKSPACE';
        var isKeyCode = (0, _function.partial)(_unicode.isKey, event.keyCode);
        if (isKeyCode(toggleKeys + '|' + switchOffKeys) && !(0, _event.isImmediatePropagationStopped)(event)) {
          eachSelectedCheckboxCell(function () {
            (0, _event.stopImmediatePropagation)(event);
            event.preventDefault();
          });
        }
        if (isKeyCode(toggleKeys)) {
          changeSelectedCheckboxesState();
        }
        if (isKeyCode(switchOffKeys)) {
          changeSelectedCheckboxesState(true);
        }
      }

      function changeSelectedCheckboxesState() {
        var uncheckCheckbox = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
        var selRange = instance.getSelectedRange();
        if (!selRange) {
          return;
        }
        var topLeft = selRange.getTopLeftCorner();
        var bottomRight = selRange.getBottomRightCorner();
        var changes = [];
        for (var _row = topLeft.row; _row <= bottomRight.row; _row += 1) {
          for (var _col = topLeft.col; _col <= bottomRight.col; _col += 1) {
            var _cellProperties = instance.getCellMeta(_row, _col);
            if (_cellProperties.type !== 'checkbox') {
              return;
            }
            if (_cellProperties.readOnly === true) {
              continue;
            }
            if (typeof _cellProperties.checkedTemplate === 'undefined') {
              _cellProperties.checkedTemplate = true;
            }
            if (typeof _cellProperties.uncheckedTemplate === 'undefined') {
              _cellProperties.uncheckedTemplate = false;
            }
            var dataAtCell = instance.getDataAtCell(_row, _col);
            if (uncheckCheckbox === false) {
              if (dataAtCell === _cellProperties.checkedTemplate) {
                changes.push([_row, _col, _cellProperties.uncheckedTemplate]);
              } else if ([_cellProperties.uncheckedTemplate, null, void 0].indexOf(dataAtCell) !== -1) {
                changes.push([_row, _col, _cellProperties.checkedTemplate]);
              }
            } else {
              changes.push([_row, _col, _cellProperties.uncheckedTemplate]);
            }
          }
        }
        if (changes.length > 0) {
          instance.setDataAtCell(changes);
        }
      }

      function eachSelectedCheckboxCell(callback) {
        var selRange = instance.getSelectedRange();
        if (!selRange) {
          return;
        }
        var topLeft = selRange.getTopLeftCorner();
        var bottomRight = selRange.getBottomRightCorner();
        for (var _row2 = topLeft.row; _row2 <= bottomRight.row; _row2++) {
          for (var _col2 = topLeft.col; _col2 <= bottomRight.col; _col2++) {
            var _cellProperties2 = instance.getCellMeta(_row2, _col2);
            if (_cellProperties2.type !== 'checkbox') {
              return;
            }
            var cell = instance.getCell(_row2, _col2);
            if (cell == null) {
              callback(_row2, _col2, _cellProperties2);
            } else {
              var checkboxes = cell.querySelectorAll('input[type=checkbox]');
              if (checkboxes.length > 0 && !_cellProperties2.readOnly) {
                callback(checkboxes);
              }
            }
          }
        }
      }
    }

    function registerEvents(instance) {
      var eventManager = isCheckboxListenerAdded.get(instance);
      if (!eventManager) {
        eventManager = new _eventManager2.default(instance);
        eventManager.addEventListener(instance.rootElement, 'click', function (event) {
          return onClick(event, instance);
        });
        eventManager.addEventListener(instance.rootElement, 'mouseup', function (event) {
          return onMouseUp(event, instance);
        });
        eventManager.addEventListener(instance.rootElement, 'change', function (event) {
          return onChange(event, instance);
        });
        isCheckboxListenerAdded.set(instance, eventManager);
      }
      return eventManager;
    }

    function createInput() {
      var input = document.createElement('input');
      input.className = 'htCheckboxRendererInput';
      input.type = 'checkbox';
      input.setAttribute('autocomplete', 'off');
      input.setAttribute('tabindex', '-1');
      return input.cloneNode(false);
    }

    function createLabel(text) {
      var label = document.createElement('label');
      label.className = 'htCheckboxRendererLabel';
      label.appendChild(document.createTextNode(text));
      return label.cloneNode(true);
    }

    function onMouseUp(event, instance) {
      if (!isCheckboxInput(event.target)) {
        return;
      }
      setTimeout(instance.listen, 10);
    }

    function onClick(event, instance) {
      if (!isCheckboxInput(event.target)) {
        return false;
      }
      var row = parseInt(event.target.getAttribute('data-row'), 10);
      var col = parseInt(event.target.getAttribute('data-col'), 10);
      var cellProperties = instance.getCellMeta(row, col);
      if (cellProperties.readOnly) {
        event.preventDefault();
      }
    }

    function onChange(event, instance) {
      if (!isCheckboxInput(event.target)) {
        return false;
      }
      var row = parseInt(event.target.getAttribute('data-row'), 10);
      var col = parseInt(event.target.getAttribute('data-col'), 10);
      var cellProperties = instance.getCellMeta(row, col);
      if (!cellProperties.readOnly) {
        var newCheckboxValue = null;
        if (event.target.checked) {
          newCheckboxValue = cellProperties.uncheckedTemplate === void 0 ? true : cellProperties.checkedTemplate;
        } else {
          newCheckboxValue = cellProperties.uncheckedTemplate === void 0 ? false : cellProperties.uncheckedTemplate;
        }
        instance.setDataAtCell(row, col, newCheckboxValue);
      }
    }

    function isCheckboxInput(element) {
      return element.tagName === 'INPUT' && element.getAttribute('type') === 'checkbox';
    }
    exports.default = checkboxRenderer;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _element = __webpack_require__(0);
    var _index = __webpack_require__(6);

    function htmlRenderer(instance, TD, row, col, prop, value, cellProperties) {
      (0, _index.getRenderer)('base').apply(this, arguments);
      if (value === null || value === void 0) {
        value = '';
      } (0, _element.fastInnerHTML)(TD, value);
    }
    exports.default = htmlRenderer;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _numbro = __webpack_require__(52);
    var _numbro2 = _interopRequireDefault(_numbro);
    var _index = __webpack_require__(6);
    var _number = __webpack_require__(5);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function numericRenderer(instance, TD, row, col, prop, value, cellProperties) {
      if ((0, _number.isNumeric)(value)) {
        if (typeof cellProperties.language !== 'undefined') {
          _numbro2.default.culture(cellProperties.language);
        }
        value = (0, _numbro2.default)(value).format(cellProperties.format || '0');
        var className = cellProperties.className || '';
        var classArr = className.length ? className.split(' ') : [];
        if (classArr.indexOf('htLeft') < 0 && classArr.indexOf('htCenter') < 0 && classArr.indexOf('htRight') < 0 && classArr.indexOf('htJustify') < 0) {
          classArr.push('htRight');
        }
        if (classArr.indexOf('htNumeric') < 0) {
          classArr.push('htNumeric');
        }
        cellProperties.className = classArr.join(' ');
      } (0, _index.getRenderer)('text')(instance, TD, row, col, prop, value, cellProperties);
    }
    exports.default = numericRenderer;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _element = __webpack_require__(0);
    var _index = __webpack_require__(6);
    var _number = __webpack_require__(5);

    function passwordRenderer(instance, TD, row, col, prop, value, cellProperties) {
      (0, _index.getRenderer)('text').apply(this, arguments);
      value = TD.innerHTML;
      var hashLength = cellProperties.hashLength || value.length;
      var hashSymbol = cellProperties.hashSymbol || '*';
      var hash = '';
      (0, _number.rangeEach)(hashLength - 1, function () {
        hash += hashSymbol;
      });
      (0, _element.fastInnerHTML)(TD, hash);
    }
    exports.default = passwordRenderer;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _element = __webpack_require__(0);
    var _mixed = __webpack_require__(23);
    var _index = __webpack_require__(6);

    function textRenderer(instance, TD, row, col, prop, value, cellProperties) {
      (0, _index.getRenderer)('base').apply(this, arguments);
      if (!value && cellProperties.placeholder) {
        value = cellProperties.placeholder;
      }
      var escaped = (0, _mixed.stringify)(value);
      if (!instance.getSettings().trimWhitespace) {
        escaped = escaped.replace(/ /g, String.fromCharCode(160));
      }
      if (cellProperties.rendererTemplate) {
        (0, _element.empty)(TD);
        var TEMPLATE = document.createElement('TEMPLATE');
        TEMPLATE.setAttribute('bind', '{{}}');
        TEMPLATE.innerHTML = cellProperties.rendererTemplate;
        HTMLTemplateElement.decorate(TEMPLATE);
        TEMPLATE.model = instance.getSourceDataAtRow(row);
        TD.appendChild(TEMPLATE);
      } else {
        (0, _element.fastInnerText)(TD, escaped);
      }
    }
    exports.default = textRenderer;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _slicedToArray = function () {
      function sliceIterator(arr, i) {
        var _arr = [];
        var _n = true;
        var _d = false;
        var _e = undefined;
        try {
          for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
            _arr.push(_s.value);
            if (i && _arr.length === i) break;
          }
        } catch (err) {
          _d = true;
          _e = err;
        } finally {
          try {
            if (!_n && _i["return"]) _i["return"]();
          } finally {
            if (_d) throw _e;
          }
        }
        return _arr;
      }
      return function (arr, i) {
        if (Array.isArray(arr)) {
          return arr;
        } else if (Symbol.iterator in Object(arr)) {
          return sliceIterator(arr, i);
        } else {
          throw new TypeError("Invalid attempt to destructure non-iterable instance");
        }
      };
    }();
    var _element = __webpack_require__(0);
    var _browser = __webpack_require__(22);
    var _eventManager = __webpack_require__(4);
    var _eventManager2 = _interopRequireDefault(_eventManager);
    var _event = __webpack_require__(7);
    var _src = __webpack_require__(14);
    var _src2 = _interopRequireDefault(_src);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function TableView(instance) {
      var _this = this;
      var that = this;
      this.eventManager = new _eventManager2.default(instance);
      this.instance = instance;
      this.settings = instance.getSettings();
      this.selectionMouseDown = false;
      var originalStyle = instance.rootElement.getAttribute('style');
      if (originalStyle) {
        instance.rootElement.setAttribute('data-originalstyle', originalStyle);
      } (0, _element.addClass)(instance.rootElement, 'handsontable');
      var table = document.createElement('TABLE');
      (0, _element.addClass)(table, 'htCore');
      if (instance.getSettings().tableClassName) {
        (0, _element.addClass)(table, instance.getSettings().tableClassName);
      }
      this.THEAD = document.createElement('THEAD');
      table.appendChild(this.THEAD);
      this.TBODY = document.createElement('TBODY');
      table.appendChild(this.TBODY);
      instance.table = table;
      instance.container.insertBefore(table, instance.container.firstChild);
      this.eventManager.addEventListener(instance.rootElement, 'mousedown', function (event) {
        this.selectionMouseDown = true;
        if (!that.isTextSelectionAllowed(event.target)) {
          clearTextSelection();
          event.preventDefault();
          window.focus();
        }
      });
      this.eventManager.addEventListener(instance.rootElement, 'mouseup', function (event) {
        this.selectionMouseDown = false;
      });
      this.eventManager.addEventListener(instance.rootElement, 'mousemove', function (event) {
        if (this.selectionMouseDown && !that.isTextSelectionAllowed(event.target)) {
          clearTextSelection();
          event.preventDefault();
        }
      });
      this.eventManager.addEventListener(document.documentElement, 'keyup', function (event) {
        if (instance.selection.isInProgress() && !event.shiftKey) {
          instance.selection.finish();
        }
      });
      var isMouseDown;
      this.isMouseDown = function () {
        return isMouseDown;
      };
      this.eventManager.addEventListener(document.documentElement, 'mouseup', function (event) {
        if (instance.selection.isInProgress() && event.which === 1) {
          instance.selection.finish();
        }
        isMouseDown = false;
        if ((0, _element.isOutsideInput)(document.activeElement) || !instance.selection.isSelected()) {
          instance.unlisten();
        }
      });
      this.eventManager.addEventListener(document.documentElement, 'mousedown', function (event) {
        var originalTarget = event.target;
        var next = event.target;
        var eventX = event.x || event.clientX;
        var eventY = event.y || event.clientY;
        if (isMouseDown || !instance.rootElement) {
          return;
        }
        if (next === instance.view.wt.wtTable.holder) {
          var scrollbarWidth = (0, _element.getScrollbarWidth)();
          if (document.elementFromPoint(eventX + scrollbarWidth, eventY) !== instance.view.wt.wtTable.holder || document.elementFromPoint(eventX, eventY + scrollbarWidth) !== instance.view.wt.wtTable.holder) {
            return;
          }
        } else {
          while (next !== document.documentElement) {
            if (next === null) {
              if (event.isTargetWebComponent) {
                break;
              }
              return;
            }
            if (next === instance.rootElement) {
              return;
            }
            next = next.parentNode;
          }
        }
        var outsideClickDeselects = typeof that.settings.outsideClickDeselects === 'function' ? that.settings.outsideClickDeselects(originalTarget) : that.settings.outsideClickDeselects;
        if (outsideClickDeselects) {
          instance.deselectCell();
        } else if (!jQuery(originalTarget).parents('#link__wiz,#tool__bar,.picker').length) {
          instance.destroyEditor();
        }
      });
      this.eventManager.addEventListener(table, 'selectstart', function (event) {
        if (that.settings.fragmentSelection || (0, _element.isInput)(event.target)) {
          return;
        }
        event.preventDefault();
      });
      var clearTextSelection = function clearTextSelection() {
        if (window.getSelection) {
          if (window.getSelection().empty) {
            window.getSelection().empty();
          } else if (window.getSelection().removeAllRanges) {
            window.getSelection().removeAllRanges();
          }
        } else if (document.selection) {
          document.selection.empty();
        }
      };
      var selections = [new _src.Selection({
        className: 'current',
        border: {
          width: 2,
          color: '#5292F7',
          cornerVisible: function cornerVisible() {
            return that.settings.fillHandle && !that.isCellEdited() && !instance.selection.isMultiple();
          },
          multipleSelectionHandlesVisible: function multipleSelectionHandlesVisible() {
            return !that.isCellEdited() && !instance.selection.isMultiple();
          }
        }
      }), new _src.Selection({
        className: 'area',
        border: {
          width: 1,
          color: '#89AFF9',
          cornerVisible: function cornerVisible() {
            return that.settings.fillHandle && !that.isCellEdited() && instance.selection.isMultiple();
          },
          multipleSelectionHandlesVisible: function multipleSelectionHandlesVisible() {
            return !that.isCellEdited() && instance.selection.isMultiple();
          }
        }
      }), new _src.Selection({
        className: 'highlight',
        highlightHeaderClassName: that.settings.currentHeaderClassName,
        highlightRowClassName: that.settings.currentRowClassName,
        highlightColumnClassName: that.settings.currentColClassName
      }), new _src.Selection({
        className: 'fill',
        border: {
          width: 1,
          color: 'red'
        }
      })];
      selections.current = selections[0];
      selections.area = selections[1];
      selections.highlight = selections[2];
      selections.fill = selections[3];
      var walkontableConfig = {
        debug: function debug() {
          return that.settings.debug;
        },
        externalRowCalculator: this.instance.getPlugin('autoRowSize') && this.instance.getPlugin('autoRowSize').isEnabled(),
        table: table,
        preventOverflow: function preventOverflow() {
          return _this.settings.preventOverflow;
        },
        stretchH: function stretchH() {
          return that.settings.stretchH;
        },
        data: instance.getDataAtCell,
        totalRows: function totalRows() {
          return instance.countRows();
        },
        totalColumns: function totalColumns() {
          return instance.countCols();
        },
        fixedColumnsLeft: function fixedColumnsLeft() {
          return that.settings.fixedColumnsLeft;
        },
        fixedRowsTop: function fixedRowsTop() {
          return that.settings.fixedRowsTop;
        },
        fixedRowsBottom: function fixedRowsBottom() {
          return that.settings.fixedRowsBottom;
        },
        minSpareRows: function minSpareRows() {
          return that.settings.minSpareRows;
        },
        renderAllRows: that.settings.renderAllRows,
        rowHeaders: function rowHeaders() {
          var headerRenderers = [];
          if (instance.hasRowHeaders()) {
            headerRenderers.push(function (row, TH) {
              that.appendRowHeader(row, TH);
            });
          }
          instance.runHooks('afterGetRowHeaderRenderers', headerRenderers);
          return headerRenderers;
        },
        columnHeaders: function columnHeaders() {
          var headerRenderers = [];
          if (instance.hasColHeaders()) {
            headerRenderers.push(function (column, TH) {
              that.appendColHeader(column, TH);
            });
          }
          instance.runHooks('afterGetColumnHeaderRenderers', headerRenderers);
          return headerRenderers;
        },
        columnWidth: instance.getColWidth,
        rowHeight: instance.getRowHeight,
        cellRenderer: function cellRenderer(row, col, TD) {
          var cellProperties = that.instance.getCellMeta(row, col);
          var prop = that.instance.colToProp(col);
          var value = that.instance.getDataAtRowProp(row, prop);
          if (that.instance.hasHook('beforeValueRender')) {
            value = that.instance.runHooks('beforeValueRender', value);
          }
          that.instance.runHooks('beforeRenderer', TD, row, col, prop, value, cellProperties);
          that.instance.getCellRenderer(cellProperties)(that.instance, TD, row, col, prop, value, cellProperties);
          that.instance.runHooks('afterRenderer', TD, row, col, prop, value, cellProperties);
        },
        selections: selections,
        hideBorderOnMouseDownOver: function hideBorderOnMouseDownOver() {
          return that.settings.fragmentSelection;
        },
        onCellMouseDown: function onCellMouseDown(event, coords, TD, wt) {
          var blockCalculations = {
            row: false,
            column: false,
            cells: false
          };
          instance.listen();
          that.activeWt = wt;
          isMouseDown = true;
          instance.runHooks('beforeOnCellMouseDown', event, coords, TD, blockCalculations);
          if ((0, _event.isImmediatePropagationStopped)(event)) {
            return;
          }
          var actualSelection = instance.getSelectedRange();
          var selection = instance.selection;
          var selectedHeader = selection.selectedHeader;
          if (event.shiftKey && actualSelection) {
            if (coords.row >= 0 && coords.col >= 0 && !blockCalculations.cells) {
              selection.setSelectedHeaders(false, false);
              selection.setRangeEnd(coords);
            } else if ((selectedHeader.cols || selectedHeader.rows) && coords.row >= 0 && coords.col >= 0 && !blockCalculations.cells) {
              selection.setSelectedHeaders(false, false);
              selection.setRangeEnd(new _src.CellCoords(coords.row, coords.col));
            } else if (selectedHeader.cols && coords.row < 0 && !blockCalculations.column) {
              selection.setRangeEnd(new _src.CellCoords(actualSelection.to.row, coords.col));
            } else if (selectedHeader.rows && coords.col < 0 && !blockCalculations.row) {
              selection.setRangeEnd(new _src.CellCoords(coords.row, actualSelection.to.col));
            } else if ((!selectedHeader.cols && !selectedHeader.rows && coords.col < 0 || selectedHeader.cols && coords.col < 0) && !blockCalculations.row) {
              selection.setSelectedHeaders(true, false);
              selection.setRangeStartOnly(new _src.CellCoords(actualSelection.from.row, 0));
              selection.setRangeEnd(new _src.CellCoords(coords.row, instance.countCols() - 1));
            } else if ((!selectedHeader.cols && !selectedHeader.rows && coords.row < 0 || selectedHeader.rows && coords.row < 0) && !blockCalculations.column) {
              selection.setSelectedHeaders(false, true);
              selection.setRangeStartOnly(new _src.CellCoords(0, actualSelection.from.col));
              selection.setRangeEnd(new _src.CellCoords(instance.countRows() - 1, coords.col));
            }
          } else {
            var doNewSelection = true;
            if (actualSelection) {
              var from = actualSelection.from,
                to = actualSelection.to;
              var coordsNotInSelection = !selection.inInSelection(coords);
              if (coords.row < 0 && selectedHeader.cols) {
                var start = Math.min(from.col, to.col);
                var end = Math.max(from.col, to.col);
                doNewSelection = coords.col < start || coords.col > end;
              } else if (coords.col < 0 && selectedHeader.rows) {
                var _start = Math.min(from.row, to.row);
                var _end = Math.max(from.row, to.row);
                doNewSelection = coords.row < _start || coords.row > _end;
              } else {
                doNewSelection = coordsNotInSelection;
              }
            }
            var rightClick = (0, _event.isRightClick)(event);
            var leftClick = (0, _event.isLeftClick)(event) || event.type === 'touchstart';
            if (coords.row < 0 && coords.col >= 0 && !blockCalculations.column) {
              selection.setSelectedHeaders(false, true);
              if (leftClick || rightClick && doNewSelection) {
                selection.setRangeStartOnly(new _src.CellCoords(0, coords.col));
                selection.setRangeEnd(new _src.CellCoords(Math.max(instance.countRows() - 1, 0), coords.col), false);
              }
            } else if (coords.col < 0 && coords.row >= 0 && !blockCalculations.row) {
              selection.setSelectedHeaders(true, false);
              if (leftClick || rightClick && doNewSelection) {
                selection.setRangeStartOnly(new _src.CellCoords(coords.row, 0));
                selection.setRangeEnd(new _src.CellCoords(coords.row, Math.max(instance.countCols() - 1, 0)), false);
              }
            } else if (coords.col >= 0 && coords.row >= 0 && !blockCalculations.cells) {
              if (leftClick || rightClick && doNewSelection) {
                selection.setSelectedHeaders(false, false);
                selection.setRangeStart(coords);
              }
            } else if (coords.col < 0 && coords.row < 0) {
              coords.row = 0;
              coords.col = 0;
              selection.setSelectedHeaders(false, false, true);
              selection.setRangeStart(coords);
            }
          }
          instance.runHooks('afterOnCellMouseDown', event, coords, TD);
          that.activeWt = that.wt;
        },
        onCellMouseOut: function onCellMouseOut(event, coords, TD, wt) {
          that.activeWt = wt;
          instance.runHooks('beforeOnCellMouseOut', event, coords, TD);
          if ((0, _event.isImmediatePropagationStopped)(event)) {
            return;
          }
          instance.runHooks('afterOnCellMouseOut', event, coords, TD);
          that.activeWt = that.wt;
        },
        onCellMouseOver: function onCellMouseOver(event, coords, TD, wt) {
          var blockCalculations = {
            row: false,
            column: false,
            cell: false
          };
          that.activeWt = wt;
          instance.runHooks('beforeOnCellMouseOver', event, coords, TD, blockCalculations);
          if ((0, _event.isImmediatePropagationStopped)(event)) {
            return;
          }
          if (event.button === 0 && isMouseDown) {
            if (coords.row >= 0 && coords.col >= 0) {
              if (instance.selection.selectedHeader.cols && !blockCalculations.column) {
                instance.selection.setRangeEnd(new _src.CellCoords(instance.countRows() - 1, coords.col), false);
              } else if (instance.selection.selectedHeader.rows && !blockCalculations.row) {
                instance.selection.setRangeEnd(new _src.CellCoords(coords.row, instance.countCols() - 1), false);
              } else if (!blockCalculations.cell) {
                instance.selection.setRangeEnd(coords);
              }
            } else {
              if (instance.selection.selectedHeader.cols && !blockCalculations.column) {
                instance.selection.setRangeEnd(new _src.CellCoords(instance.countRows() - 1, coords.col), false);
              } else if (instance.selection.selectedHeader.rows && !blockCalculations.row) {
                instance.selection.setRangeEnd(new _src.CellCoords(coords.row, instance.countCols() - 1), false);
              } else if (!blockCalculations.cell) {
                instance.selection.setRangeEnd(coords);
              }
            }
          }
          instance.runHooks('afterOnCellMouseOver', event, coords, TD);
          that.activeWt = that.wt;
        },
        onCellMouseUp: function onCellMouseUp(event, coords, TD, wt) {
          that.activeWt = wt;
          instance.runHooks('beforeOnCellMouseUp', event, coords, TD);
          instance.runHooks('afterOnCellMouseUp', event, coords, TD);
          that.activeWt = that.wt;
        },
        onCellCornerMouseDown: function onCellCornerMouseDown(event) {
          event.preventDefault();
          instance.runHooks('afterOnCellCornerMouseDown', event);
        },
        onCellCornerDblClick: function onCellCornerDblClick(event) {
          event.preventDefault();
          instance.runHooks('afterOnCellCornerDblClick', event);
        },
        beforeDraw: function beforeDraw(force, skipRender) {
          that.beforeRender(force, skipRender);
        },
        onDraw: function onDraw(force) {
          that.onDraw(force);
        },
        onScrollVertically: function onScrollVertically() {
          instance.runHooks('afterScrollVertically');
        },
        onScrollHorizontally: function onScrollHorizontally() {
          instance.runHooks('afterScrollHorizontally');
        },
        onBeforeDrawBorders: function onBeforeDrawBorders(corners, borderClassName) {
          instance.runHooks('beforeDrawBorders', corners, borderClassName);
        },
        onBeforeTouchScroll: function onBeforeTouchScroll() {
          instance.runHooks('beforeTouchScroll');
        },
        onAfterMomentumScroll: function onAfterMomentumScroll() {
          instance.runHooks('afterMomentumScroll');
        },
        onBeforeStretchingColumnWidth: function onBeforeStretchingColumnWidth(stretchedWidth, column) {
          return instance.runHooks('beforeStretchingColumnWidth', stretchedWidth, column);
        },
        onModifyRowHeaderWidth: function onModifyRowHeaderWidth(rowHeaderWidth) {
          return instance.runHooks('modifyRowHeaderWidth', rowHeaderWidth);
        },
        viewportRowCalculatorOverride: function viewportRowCalculatorOverride(calc) {
          var rows = instance.countRows();
          var viewportOffset = that.settings.viewportRowRenderingOffset;
          if (viewportOffset === 'auto' && that.settings.fixedRowsTop) {
            viewportOffset = 10;
          }
          if (typeof viewportOffset === 'number') {
            calc.startRow = Math.max(calc.startRow - viewportOffset, 0);
            calc.endRow = Math.min(calc.endRow + viewportOffset, rows - 1);
          }
          if (viewportOffset === 'auto') {
            var center = calc.startRow + calc.endRow - calc.startRow;
            var offset = Math.ceil(center / rows * 12);
            calc.startRow = Math.max(calc.startRow - offset, 0);
            calc.endRow = Math.min(calc.endRow + offset, rows - 1);
          }
          instance.runHooks('afterViewportRowCalculatorOverride', calc);
        },
        viewportColumnCalculatorOverride: function viewportColumnCalculatorOverride(calc) {
          var cols = instance.countCols();
          var viewportOffset = that.settings.viewportColumnRenderingOffset;
          if (viewportOffset === 'auto' && that.settings.fixedColumnsLeft) {
            viewportOffset = 10;
          }
          if (typeof viewportOffset === 'number') {
            calc.startColumn = Math.max(calc.startColumn - viewportOffset, 0);
            calc.endColumn = Math.min(calc.endColumn + viewportOffset, cols - 1);
          }
          if (viewportOffset === 'auto') {
            var center = calc.startColumn + calc.endColumn - calc.startColumn;
            var offset = Math.ceil(center / cols * 12);
            calc.startRow = Math.max(calc.startColumn - offset, 0);
            calc.endColumn = Math.min(calc.endColumn + offset, cols - 1);
          }
          instance.runHooks('afterViewportColumnCalculatorOverride', calc);
        },
        rowHeaderWidth: function rowHeaderWidth() {
          return that.settings.rowHeaderWidth;
        },
        columnHeaderHeight: function columnHeaderHeight() {
          var columnHeaderHeight = instance.runHooks('modifyColumnHeaderHeight');
          return that.settings.columnHeaderHeight || columnHeaderHeight;
        }
      };
      instance.runHooks('beforeInitWalkontable', walkontableConfig);
      this.wt = new _src2.default(walkontableConfig);
      this.activeWt = this.wt;
      if (!(0, _browser.isChrome)() && !(0, _browser.isSafari)()) {
        this.eventManager.addEventListener(instance.rootElement, 'wheel', function (event) {
          event.preventDefault();
          var lineHeight = parseInt((0, _element.getComputedStyle)(document.body)['font-size'], 10);
          var holder = that.wt.wtOverlays.scrollableElement;
          var deltaY = event.wheelDeltaY || event.deltaY;
          var deltaX = event.wheelDeltaX || event.deltaX;
          switch (event.deltaMode) {
            case 0:
              holder.scrollLeft += deltaX;
              holder.scrollTop += deltaY;
              break;
            case 1:
              holder.scrollLeft += deltaX * lineHeight;
              holder.scrollTop += deltaY * lineHeight;
              break;
            default:
              break;
          }
        });
      }
      this.eventManager.addEventListener(that.wt.wtTable.spreader, 'mousedown', function (event) {
        if (event.target === that.wt.wtTable.spreader && event.which === 3) {
          (0, _event.stopPropagation)(event);
        }
      });
      this.eventManager.addEventListener(that.wt.wtTable.spreader, 'contextmenu', function (event) {
        if (event.target === that.wt.wtTable.spreader && event.which === 3) {
          (0, _event.stopPropagation)(event);
        }
      });
      this.eventManager.addEventListener(document.documentElement, 'click', function () {
        if (that.settings.observeDOMVisibility) {
          if (that.wt.drawInterrupted) {
            that.instance.forceFullRender = true;
            that.render();
          }
        }
      });
    }
    TableView.prototype.isTextSelectionAllowed = function (el) {
      if ((0, _element.isInput)(el)) {
        return true;
      }
      var isChildOfTableBody = (0, _element.isChildOf)(el, this.instance.view.wt.wtTable.spreader);
      if (this.settings.fragmentSelection === true && isChildOfTableBody) {
        return true;
      }
      if (this.settings.fragmentSelection === 'cell' && this.isSelectedOnlyCell() && isChildOfTableBody) {
        return true;
      }
      if (!this.settings.fragmentSelection && this.isCellEdited() && this.isSelectedOnlyCell()) {
        return true;
      }
      return false;
    };
    TableView.prototype.isSelectedOnlyCell = function () {
      var _ref = this.instance.getSelected() || [],
        _ref2 = _slicedToArray(_ref, 4),
        row = _ref2[0],
        col = _ref2[1],
        rowEnd = _ref2[2],
        colEnd = _ref2[3];
      return row !== void 0 && row === rowEnd && col === colEnd;
    };
    TableView.prototype.isCellEdited = function () {
      var activeEditor = this.instance.getActiveEditor();
      return activeEditor && activeEditor.isOpened();
    };
    TableView.prototype.beforeRender = function (force, skipRender) {
      if (force) {
        this.instance.runHooks('beforeRender', this.instance.forceFullRender, skipRender);
      }
    };
    TableView.prototype.onDraw = function (force) {
      if (force) {
        this.instance.runHooks('afterRender', this.instance.forceFullRender);
      }
    };
    TableView.prototype.render = function () {
      this.wt.draw(!this.instance.forceFullRender);
      this.instance.forceFullRender = false;
      this.instance.renderCall = false;
    };
    TableView.prototype.getCellAtCoords = function (coords, topmost) {
      var td = this.wt.getCell(coords, topmost);
      if (td < 0) {
        return null;
      }
      return td;
    };
    TableView.prototype.scrollViewport = function (coords) {
      this.wt.scrollViewport(coords);
    };
    TableView.prototype.appendRowHeader = function (row, TH) {
      if (TH.firstChild) {
        var container = TH.firstChild;
        if (!(0, _element.hasClass)(container, 'relative')) {
          (0, _element.empty)(TH);
          this.appendRowHeader(row, TH);
          return;
        }
        this.updateCellHeader(container.querySelector('.rowHeader'), row, this.instance.getRowHeader);
      } else {
        var div = document.createElement('div');
        var span = document.createElement('span');
        div.className = 'relative';
        span.className = 'rowHeader';
        this.updateCellHeader(span, row, this.instance.getRowHeader);
        div.appendChild(span);
        TH.appendChild(div);
      }
      this.instance.runHooks('afterGetRowHeader', row, TH);
    };
    TableView.prototype.appendColHeader = function (col, TH) {
      if (TH.firstChild) {
        var container = TH.firstChild;
        if ((0, _element.hasClass)(container, 'relative')) {
          this.updateCellHeader(container.querySelector('.colHeader'), col, this.instance.getColHeader);
        } else {
          (0, _element.empty)(TH);
          this.appendColHeader(col, TH);
        }
      } else {
        var div = document.createElement('div');
        var span = document.createElement('span');
        div.className = 'relative';
        span.className = 'colHeader';
        this.updateCellHeader(span, col, this.instance.getColHeader);
        div.appendChild(span);
        TH.appendChild(div);
      }
      this.instance.runHooks('afterGetColHeader', col, TH);
    };
    TableView.prototype.updateCellHeader = function (element, index, content) {
      var renderedIndex = index;
      var parentOverlay = this.wt.wtOverlays.getParentOverlay(element) || this.wt;
      if (element.parentNode) {
        if ((0, _element.hasClass)(element, 'colHeader')) {
          renderedIndex = parentOverlay.wtTable.columnFilter.sourceToRendered(index);
        } else if ((0, _element.hasClass)(element, 'rowHeader')) {
          renderedIndex = parentOverlay.wtTable.rowFilter.sourceToRendered(index);
        }
      }
      if (renderedIndex > -1) {
        (0, _element.fastInnerHTML)(element, content(index));
      } else {
        (0, _element.fastInnerText)(element, String.fromCharCode(160));
        (0, _element.addClass)(element, 'cornerHeader');
      }
    };
    TableView.prototype.maximumVisibleElementWidth = function (leftOffset) {
      var workspaceWidth = this.wt.wtViewport.getWorkspaceWidth();
      var maxWidth = workspaceWidth - leftOffset;
      return maxWidth > 0 ? maxWidth : 0;
    };
    TableView.prototype.maximumVisibleElementHeight = function (topOffset) {
      var workspaceHeight = this.wt.wtViewport.getWorkspaceHeight();
      var maxHeight = workspaceHeight - topOffset;
      return maxHeight > 0 ? maxHeight : 0;
    };
    TableView.prototype.mainViewIsActive = function () {
      return this.wt === this.activeWt;
    };
    TableView.prototype.destroy = function () {
      this.wt.destroy();
      this.eventManager.destroy();
    };
    exports.default = TableView;
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    var _createClass = function () {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();
    exports.parseDelay = parseDelay;
    var _feature = __webpack_require__(34);

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var Interval = function () {
      _createClass(Interval, null, [{
        key: 'create',
        value: function create(func, delay) {
          return new Interval(func, delay);
        }
      }]);

      function Interval(func, delay) {
        var _this = this;
        _classCallCheck(this, Interval);
        this.timer = null;
        this.func = func;
        this.delay = parseDelay(delay);
        this.stopped = true;
        this._then = null;
        this._callback = function () {
          return _this.__callback();
        };
      }
      _createClass(Interval, [{
        key: 'start',
        value: function start() {
          if (this.stopped) {
            this._then = Date.now();
            this.stopped = false;
            this.timer = (0, _feature.requestAnimationFrame)(this._callback);
          }
          return this;
        }
      }, {
        key: 'stop',
        value: function stop() {
          if (!this.stopped) {
            this.stopped = true;
            (0, _feature.cancelAnimationFrame)(this.timer);
            this.timer = null;
          }
          return this;
        }
      }, {
        key: '__callback',
        value: function __callback() {
          this.timer = (0, _feature.requestAnimationFrame)(this._callback);
          if (this.delay) {
            var now = Date.now();
            var elapsed = now - this._then;
            if (elapsed > this.delay) {
              this._then = now - elapsed % this.delay;
              this.func();
            }
          } else {
            this.func();
          }
        }
      }]);
      return Interval;
    }();
    exports.default = Interval;

    function parseDelay(delay) {
      if (typeof delay === 'string' && /fps$/.test(delay)) {
        delay = 1000 / parseInt(delay.replace('fps', '') || 0, 10);
      }
      return delay;
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.default = autocompleteValidator;

    function autocompleteValidator(value, callback) {
      if (value == null) {
        value = '';
      }
      if (this.allowEmpty && value === '') {
        callback(true);
        return;
      }
      if (this.strict && this.source) {
        if (typeof this.source === 'function') {
          this.source(value, process(value, callback));
        } else {
          process(value, callback)(this.source);
        }
      } else {
        callback(true);
      }
    };

    function process(value, callback) {
      var originalVal = value;
      return function (source) {
        var found = false;
        for (var s = 0, slen = source.length; s < slen; s++) {
          if (originalVal === source[s]) {
            found = true;
            break;
          }
        }
        callback(found);
      };
    }
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.default = dateValidator;
    exports.correctFormat = correctFormat;
    var _moment = __webpack_require__(42);
    var _moment2 = _interopRequireDefault(_moment);
    var _date = __webpack_require__(89);
    var _editors = __webpack_require__(13);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }

    function dateValidator(value, callback) {
      var valid = true;
      var dateEditor = (0, _editors.getEditorInstance)('date', this.instance);
      if (value == null) {
        value = '';
      }
      var isValidDate = (0, _moment2.default)(new Date(value)).isValid() || (0, _moment2.default)(value, dateEditor.defaultDateFormat).isValid();
      var isValidFormat = (0, _moment2.default)(value, this.dateFormat || dateEditor.defaultDateFormat, true).isValid();
      if (this.allowEmpty && value === '') {
        isValidDate = true;
        isValidFormat = true;
      }
      if (!isValidDate) {
        valid = false;
      }
      if (!isValidDate && isValidFormat) {
        valid = true;
      }
      if (isValidDate && !isValidFormat) {
        if (this.correctFormat === true) {
          var correctedValue = correctFormat(value, this.dateFormat);
          var row = this.instance.runHooks('unmodifyRow', this.row);
          var column = this.instance.runHooks('unmodifyCol', this.col);
          this.instance.setDataAtCell(row, column, correctedValue, 'dateValidator');
          valid = true;
        } else {
          valid = false;
        }
      }
      callback(valid);
    };

    function correctFormat(value, dateFormat) {
      var dateFromDate = (0, _moment2.default)((0, _date.getNormalizedDate)(value));
      var dateFromMoment = (0, _moment2.default)(value, dateFormat);
      var isAlphanumeric = value.search(/[A-z]/g) > -1;
      var date = void 0;
      if (dateFromDate.isValid() && dateFromDate.format('x') === dateFromMoment.format('x') || !dateFromMoment.isValid() || isAlphanumeric) {
        date = dateFromDate;
      } else {
        date = dateFromMoment;
      }
      return date.format(dateFormat);
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.default = numericValidator;

    function numericValidator(value, callback) {
      if (value == null) {
        value = '';
      }
      if (this.allowEmpty && value === '') {
        callback(true);
      } else if (value === '') {
        callback(false);
      } else {
        callback(/^-?\d*(\.|,)?\d*$/.test(value));
      }
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    exports.__esModule = true;
    exports.default = timeValidator;
    var _moment = __webpack_require__(42);
    var _moment2 = _interopRequireDefault(_moment);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        default: obj
      };
    }
    var STRICT_FORMATS = ['YYYY-MM-DDTHH:mm:ss.SSSZ', 'X', 'x'];

    function timeValidator(value, callback) {
      var valid = true;
      var timeFormat = this.timeFormat || 'h:mm:ss a';
      if (value === null) {
        value = '';
      }
      value = /^\d{3,}$/.test(value) ? parseInt(value, 10) : value;
      var twoDigitValue = /^\d{1,2}$/.test(value);
      if (twoDigitValue) {
        value += ':00';
      }
      var date = (0, _moment2.default)(value, STRICT_FORMATS, true).isValid() ? (0, _moment2.default)(value) : (0, _moment2.default)(value, timeFormat);
      var isValidTime = date.isValid();
      var isValidFormat = (0, _moment2.default)(value, timeFormat, true).isValid() && !twoDigitValue;
      if (this.allowEmpty && value === '') {
        isValidTime = true;
        isValidFormat = true;
      }
      if (!isValidTime) {
        valid = false;
      }
      if (!isValidTime && isValidFormat) {
        valid = true;
      }
      if (isValidTime && !isValidFormat) {
        if (this.correctFormat === true) {
          var correctedValue = date.format(timeFormat);
          var row = this.instance.runHooks('unmodifyRow', this.row);
          var column = this.instance.runHooks('unmodifyCol', this.col);
          this.instance.setDataAtCell(row, column, correctedValue, 'timeValidator');
          valid = true;
        } else {
          valid = false;
        }
      }
      callback(valid);
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var toObject = __webpack_require__(40);
    var toAbsoluteIndex = __webpack_require__(63);
    var toLength = __webpack_require__(21);
    module.exports = [].copyWithin || function copyWithin(target, start) {
      var O = toObject(this);
      var len = toLength(O.length);
      var to = toAbsoluteIndex(target, len);
      var from = toAbsoluteIndex(start, len);
      var end = arguments.length > 2 ? arguments[2] : undefined;
      var count = Math.min((end === undefined ? len : toAbsoluteIndex(end, len)) - from, len - to);
      var inc = 1;
      if (from < to && to < from + count) {
        inc = -1;
        from += count - 1;
        to += count - 1;
      }
      while (count-- > 0) {
        if (from in O) O[to] = O[from];
        else delete O[to];
        to += inc;
        from += inc;
      }
      return O;
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var toObject = __webpack_require__(40);
    var toAbsoluteIndex = __webpack_require__(63);
    var toLength = __webpack_require__(21);
    module.exports = function fill(value) {
      var O = toObject(this);
      var length = toLength(O.length);
      var aLen = arguments.length;
      var index = toAbsoluteIndex(aLen > 1 ? arguments[1] : undefined, length);
      var end = aLen > 2 ? arguments[2] : undefined;
      var endPos = end === undefined ? length : toAbsoluteIndex(end, length);
      while (endPos > index) O[index++] = value;
      return O;
    };
  }), (function (module, exports, __webpack_require__) {
    var isObject = __webpack_require__(12);
    var isArray = __webpack_require__(277);
    var SPECIES = __webpack_require__(8)('species');
    module.exports = function (original) {
      var C;
      if (isArray(original)) {
        C = original.constructor;
        if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;
        if (isObject(C)) {
          C = C[SPECIES];
          if (C === null) C = undefined;
        }
      }
      return C === undefined ? Array : C;
    };
  }), (function (module, exports, __webpack_require__) {
    var speciesConstructor = __webpack_require__(391);
    module.exports = function (original, length) {
      return new (speciesConstructor(original))(length);
    };
  }), (function (module, exports, __webpack_require__) {
    var getKeys = __webpack_require__(39);
    var gOPS = __webpack_require__(61);
    var pIE = __webpack_require__(48);
    module.exports = function (it) {
      var result = getKeys(it);
      var getSymbols = gOPS.f;
      if (getSymbols) {
        var symbols = getSymbols(it);
        var isEnum = pIE.f;
        var i = 0;
        var key;
        while (symbols.length > i)
          if (isEnum.call(it, key = symbols[i++])) result.push(key);
      }
      return result;
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var anObject = __webpack_require__(17);
    module.exports = function () {
      var that = anObject(this);
      var result = '';
      if (that.global) result += 'g';
      if (that.ignoreCase) result += 'i';
      if (that.multiline) result += 'm';
      if (that.unicode) result += 'u';
      if (that.sticky) result += 'y';
      return result;
    };
  }), (function (module, exports, __webpack_require__) {
    var isObject = __webpack_require__(12);
    var setPrototypeOf = __webpack_require__(287).set;
    module.exports = function (that, target, C) {
      var S = target.constructor;
      var P;
      if (S !== C && typeof S == 'function' && (P = S.prototype) !== C.prototype && isObject(P) && setPrototypeOf) {
        setPrototypeOf(that, P);
      }
      return that;
    };
  }), (function (module, exports) {
    module.exports = function (fn, args, that) {
      var un = that === undefined;
      switch (args.length) {
        case 0:
          return un ? fn() : fn.call(that);
        case 1:
          return un ? fn(args[0]) : fn.call(that, args[0]);
        case 2:
          return un ? fn(args[0], args[1]) : fn.call(that, args[0], args[1]);
        case 3:
          return un ? fn(args[0], args[1], args[2]) : fn.call(that, args[0], args[1], args[2]);
        case 4:
          return un ? fn(args[0], args[1], args[2], args[3]) : fn.call(that, args[0], args[1], args[2], args[3]);
      }
      return fn.apply(that, args);
    };
  }), (function (module, exports, __webpack_require__) {
    "use strict";
    var create = __webpack_require__(80);
    var descriptor = __webpack_require__(49);
    var setToStringTag = __webpack_require__(50);
    var IteratorPrototype = {};
    __webpack_require__(31)(IteratorPrototype, __webpack_require__(8)('iterator'), function () {
      return this;
    });
    module.exports = function (Constructor, NAME, next) {
      Constructor.prototype = create(IteratorPrototype, {
        next: descriptor(1, next)
      });
      setToStringTag(Constructor, NAME + ' Iterator');
    };
  }), (function (module, exports, __webpack_require__) {
    var global = __webpack_require__(10);
    var macrotask = __webpack_require__(86).set;
    var Observer = global.MutationObserver || global.WebKitMutationObserver;
    var process = global.process;
    var Promise = global.Promise;
    var isNode = __webpack_require__(38)(process) == 'process';
    module.exports = function () {
      var head, last, notify;
      var flush = function () {
        var parent, fn;
        if (isNode && (parent = process.domain)) parent.exit();
        while (head) {
          fn = head.fn;
          head = head.next;
          try {
            fn();
          } catch (e) {
            if (head) notify();
            else last = undefined;
            throw e;
          }
        }
        last = undefined;
        if (parent) parent.enter();
      };
      if (isNode) {
        notify = function () {
          process.nextTick(flush);
        };
      } else if (Observer) {
        var toggle = true;
        var node = document.createTextNode('');
        new Observer(flush).observe(node, {
          characterData: true
        });
        notify = function () {
          node.data = toggle = !toggle;
        };
      } else if (Promise && Promise.resolve) {
        var promise = Promise.resolve();
        notify = function () {
          promise.then(flush);
        };
      } else {
        notify = function () {
          macrotask.call(global, flush);
        };
      }
      return function (fn) {
        var task = {
          fn: fn,
          next: undefined
        };
        if (last) last.next = task;
        if (!head) {
          head = task;
          notify();
        }
        last = task;
      };
    };
  }), (function (module, exports, __webpack_require__) {
    var dP = __webpack_require__(18);
    var anObject = __webpack_require__(17);
    var getKeys = __webpack_require__(39);
    module.exports = __webpack_require__(20) ? Object.defineProperties : function defineProperties(O, Properties) {
      anObject(O);
      var keys = getKeys(Properties);
      var length = keys.length;
      var i = 0;
      var P;
      while (length > i) dP.f(O, P = keys[i++], Properties[P]);
      return O;
    };
  }), (function (module, exports, __webpack_require__) {
    var toIObject = __webpack_require__(27);
    var gOPN = __webpack_require__(82).f;
    var toString = {}.toString;
    var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames ? Object.getOwnPropertyNames(window) : [];
    var getWindowNames = function (it) {
      try {
        return gOPN(it);
      } catch (e) {
        return windowNames.slice();
      }
    };
    module.exports.f = function getOwnPropertyNames(it) {
      return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));
    };
  }), (function (module, exports, __webpack_require__) {
    var has = __webpack_require__(26);
    var toObject = __webpack_require__(40);
    var IE_PROTO = __webpack_require__(83)('IE_PROTO');
    var ObjectProto = Object.prototype;
    module.exports = Object.getPrototypeOf || function (O) {
      O = toObject(O);
      if (has(O, IE_PROTO)) return O[IE_PROTO];
      if (typeof O.constructor == 'function' && O instanceof O.constructor) {
        return O.constructor.prototype;
      }
      return O instanceof Object ? ObjectProto : null;
    };
  }), (function (module, exports, __webpack_require__) {
    var gOPN = __webpack_require__(82);
    var gOPS = __webpack_require__(61);
    var anObject = __webpack_require__(17);
    var Reflect = __webpack_require__(10).Reflect;
    module.exports = Reflect && Reflect.ownKeys || function ownKeys(it) {
      var keys = gOPN.f(anObject(it));
      var getSymbols = gOPS.f;
      return getSymbols ? keys.concat(getSymbols(it)) : keys;
    };
  }), (function (module, exports) {
    module.exports = function (exec) {
      try {
        return {
          e: false,
          v: exec()
        };
      } catch (e) {
        return {
          e: true,
          v: e
        };
      }
    };
  }), (function (module, exports, __webpack_require__) {
    var anObject = __webpack_require__(17);
    var isObject = __webpack_require__(12);
    var newPromiseCapability = __webpack_require__(283);
    module.exports = function (C, x) {
      anObject(C);
      if (isObject(x) && x.constructor === C) return x;
      var promiseCapability = newPromiseCapability.f(C);
      var resolve = promiseCapability.resolve;
      resolve(x);
      return promiseCapability.promise;
    };
  }), (function (module, exports) {
    module.exports = Object.is || function is(x, y) {
      return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y;
    };
  }), (function (module, exports, __webpack_require__) {
    var anObject = __webpack_require__(17);
    var aFunction = __webpack_require__(54);
    var SPECIES = __webpack_require__(8)('species');
    module.exports = function (O, D) {
      var C = anObject(O).constructor;
      var S;
      return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);
    };
  }), (function (module, exports, __webpack_require__) {
    var toInteger = __webpack_require__(64);
    var defined = __webpack_require__(33);
    module.exports = function (TO_STRING) {
      return function (that, pos) {
        var s = String(defined(that));
        var i = toInteger(pos);
        var l = s.length;
        var a, b;
        if (i < 0 || i >= l) return TO_STRING ? '' : undefined;
        a = s.charCodeAt(i);
        return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff ? TO_STRING ? s.charAt(i) : a : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
      };
    };
  }), (function (module, exports, __webpack_require__) {
    var global = __webpack_require__(10);
    var core = __webpack_require__(45);
    var LIBRARY = __webpack_require__(60);
    var wksExt = __webpack_require__(291);
    var defineProperty = __webpack_require__(18).f;
    module.exports = function (name) {
      var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});
      if (name.charAt(0) != '_' && !(name in $Symbol)) defineProperty($Symbol, name, {
        value: wksExt.f(name)
      });
    };
  }), (function (module, exports, __webpack_require__) {
    var map = {
      "./af": 134,
      "./af.js": 134,
      "./ar": 141,
      "./ar-dz": 135,
      "./ar-dz.js": 135,
      "./ar-kw": 136,
      "./ar-kw.js": 136,
      "./ar-ly": 137,
      "./ar-ly.js": 137,
      "./ar-ma": 138,
      "./ar-ma.js": 138,
      "./ar-sa": 139,
      "./ar-sa.js": 139,
      "./ar-tn": 140,
      "./ar-tn.js": 140,
      "./ar.js": 141,
      "./az": 142,
      "./az.js": 142,
      "./be": 143,
      "./be.js": 143,
      "./bg": 144,
      "./bg.js": 144,
      "./bn": 145,
      "./bn.js": 145,
      "./bo": 146,
      "./bo.js": 146,
      "./br": 147,
      "./br.js": 147,
      "./bs": 148,
      "./bs.js": 148,
      "./ca": 149,
      "./ca.js": 149,
      "./cs": 150,
      "./cs.js": 150,
      "./cv": 151,
      "./cv.js": 151,
      "./cy": 152,
      "./cy.js": 152,
      "./da": 153,
      "./da.js": 153,
      "./de": 156,
      "./de-at": 154,
      "./de-at.js": 154,
      "./de-ch": 155,
      "./de-ch.js": 155,
      "./de.js": 156,
      "./dv": 157,
      "./dv.js": 157,
      "./el": 158,
      "./el.js": 158,
      "./en-au": 159,
      "./en-au.js": 159,
      "./en-ca": 160,
      "./en-ca.js": 160,
      "./en-gb": 161,
      "./en-gb.js": 161,
      "./en-ie": 162,
      "./en-ie.js": 162,
      "./en-nz": 163,
      "./en-nz.js": 163,
      "./eo": 164,
      "./eo.js": 164,
      "./es": 166,
      "./es-do": 165,
      "./es-do.js": 165,
      "./es.js": 166,
      "./et": 167,
      "./et.js": 167,
      "./eu": 168,
      "./eu.js": 168,
      "./fa": 169,
      "./fa.js": 169,
      "./fi": 170,
      "./fi.js": 170,
      "./fo": 171,
      "./fo.js": 171,
      "./fr": 174,
      "./fr-ca": 172,
      "./fr-ca.js": 172,
      "./fr-ch": 173,
      "./fr-ch.js": 173,
      "./fr.js": 174,
      "./fy": 175,
      "./fy.js": 175,
      "./gd": 176,
      "./gd.js": 176,
      "./gl": 177,
      "./gl.js": 177,
      "./gom-latn": 178,
      "./gom-latn.js": 178,
      "./he": 179,
      "./he.js": 179,
      "./hi": 180,
      "./hi.js": 180,
      "./hr": 181,
      "./hr.js": 181,
      "./hu": 182,
      "./hu.js": 182,
      "./hy-am": 183,
      "./hy-am.js": 183,
      "./id": 184,
      "./id.js": 184,
      "./is": 185,
      "./is.js": 185,
      "./it": 186,
      "./it.js": 186,
      "./ja": 187,
      "./ja.js": 187,
      "./jv": 188,
      "./jv.js": 188,
      "./ka": 189,
      "./ka.js": 189,
      "./kk": 190,
      "./kk.js": 190,
      "./km": 191,
      "./km.js": 191,
      "./kn": 192,
      "./kn.js": 192,
      "./ko": 193,
      "./ko.js": 193,
      "./ky": 194,
      "./ky.js": 194,
      "./lb": 195,
      "./lb.js": 195,
      "./lo": 196,
      "./lo.js": 196,
      "./lt": 197,
      "./lt.js": 197,
      "./lv": 198,
      "./lv.js": 198,
      "./me": 199,
      "./me.js": 199,
      "./mi": 200,
      "./mi.js": 200,
      "./mk": 201,
      "./mk.js": 201,
      "./ml": 202,
      "./ml.js": 202,
      "./mr": 203,
      "./mr.js": 203,
      "./ms": 205,
      "./ms-my": 204,
      "./ms-my.js": 204,
      "./ms.js": 205,
      "./my": 206,
      "./my.js": 206,
      "./nb": 207,
      "./nb.js": 207,
      "./ne": 208,
      "./ne.js": 208,
      "./nl": 210,
      "./nl-be": 209,
      "./nl-be.js": 209,
      "./nl.js": 210,
      "./nn": 211,
      "./nn.js": 211,
      "./pa-in": 212,
      "./pa-in.js": 212,
      "./pl": 213,
      "./pl.js": 213,
      "./pt": 215,
      "./pt-br": 214,
      "./pt-br.js": 214,
      "./pt.js": 215,
      "./ro": 216,
      "./ro.js": 216,
      "./ru": 217,
      "./ru.js": 217,
      "./sd": 218,
      "./sd.js": 218,
      "./se": 219,
      "./se.js": 219,
      "./si": 220,
      "./si.js": 220,
      "./sk": 221,
      "./sk.js": 221,
      "./sl": 222,
      "./sl.js": 222,
      "./sq": 223,
      "./sq.js": 223,
      "./sr": 225,
      "./sr-cyrl": 224,
      "./sr-cyrl.js": 224,
      "./sr.js": 225,
      "./ss": 226,
      "./ss.js": 226,
      "./sv": 227,
      "./sv.js": 227,
      "./sw": 228,
      "./sw.js": 228,
      "./ta": 229,
      "./ta.js": 229,
      "./te": 230,
      "./te.js": 230,
      "./tet": 231,
      "./tet.js": 231,
      "./th": 232,
      "./th.js": 232,
      "./tl-ph": 233,
      "./tl-ph.js": 233,
      "./tlh": 234,
      "./tlh.js": 234,
      "./tr": 235,
      "./tr.js": 235,
      "./tzl": 236,
      "./tzl.js": 236,
      "./tzm": 238,
      "./tzm-latn": 237,
      "./tzm-latn.js": 237,
      "./tzm.js": 238,
      "./uk": 239,
      "./uk.js": 239,
      "./ur": 240,
      "./ur.js": 240,
      "./uz": 242,
      "./uz-latn": 241,
      "./uz-latn.js": 241,
      "./uz.js": 242,
      "./vi": 243,
      "./vi.js": 243,
      "./x-pseudo": 244,
      "./x-pseudo.js": 244,
      "./yo": 245,
      "./yo.js": 245,
      "./zh-cn": 246,
      "./zh-cn.js": 246,
      "./zh-hk": 247,
      "./zh-hk.js": 247,
      "./zh-tw": 248,
      "./zh-tw.js": 248
    };

    function webpackContext(req) {
      return __webpack_require__(webpackContextResolve(req));
    };

    function webpackContextResolve(req) {
      var id = map[req];
      if (!(id + 1)) throw new Error("Cannot find module '" + req + "'.");
      return id;
    };
    webpackContext.keys = function webpackContextKeys() {
      return Object.keys(map);
    };
    webpackContext.resolve = webpackContextResolve;
    module.exports = webpackContext;
    webpackContext.id = 409;
  }), (function (module, exports, __webpack_require__) {
    (function (root, factory) {
      'use strict';
      var moment;
      if (true) {
        try {
          moment = __webpack_require__(42);
        } catch (e) { }
        module.exports = factory(moment);
      } else if (typeof define === 'function' && define.amd) {
        define(function (req) {
          var id = 'moment';
          try {
            moment = req(id);
          } catch (e) { }
          return factory(moment);
        });
      } else {
        root.Pikaday = factory(root.moment);
      }
    }(this, function (moment) {
      'use strict';
      var hasMoment = typeof moment === 'function',
        hasEventListeners = !!window.addEventListener,
        document = window.document,
        sto = window.setTimeout,
        addEvent = function (el, e, callback, capture) {
          if (hasEventListeners) {
            el.addEventListener(e, callback, !!capture);
          } else {
            el.attachEvent('on' + e, callback);
          }
        },
        removeEvent = function (el, e, callback, capture) {
          if (hasEventListeners) {
            el.removeEventListener(e, callback, !!capture);
          } else {
            el.detachEvent('on' + e, callback);
          }
        },
        fireEvent = function (el, eventName, data) {
          var ev;
          if (document.createEvent) {
            ev = document.createEvent('HTMLEvents');
            ev.initEvent(eventName, true, false);
            ev = extend(ev, data);
            el.dispatchEvent(ev);
          } else if (document.createEventObject) {
            ev = document.createEventObject();
            ev = extend(ev, data);
            el.fireEvent('on' + eventName, ev);
          }
        },
        trim = function (str) {
          return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, '');
        },
        hasClass = function (el, cn) {
          return (' ' + el.className + ' ').indexOf(' ' + cn + ' ') !== -1;
        },
        addClass = function (el, cn) {
          if (!hasClass(el, cn)) {
            el.className = (el.className === '') ? cn : el.className + ' ' + cn;
          }
        },
        removeClass = function (el, cn) {
          el.className = trim((' ' + el.className + ' ').replace(' ' + cn + ' ', ' '));
        },
        isArray = function (obj) {
          return (/Array/).test(Object.prototype.toString.call(obj));
        },
        isDate = function (obj) {
          return (/Date/).test(Object.prototype.toString.call(obj)) && !isNaN(obj.getTime());
        },
        isWeekend = function (date) {
          var day = date.getDay();
          return day === 0 || day === 6;
        },
        isLeapYear = function (year) {
          return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
        },
        getDaysInMonth = function (year, month) {
          return [31, isLeapYear(year) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month];
        },
        setToStartOfDay = function (date) {
          if (isDate(date)) date.setHours(0, 0, 0, 0);
        },
        compareDates = function (a, b) {
          return a.getTime() === b.getTime();
        },
        extend = function (to, from, overwrite) {
          var prop, hasProp;
          for (prop in from) {
            hasProp = to[prop] !== undefined;
            if (hasProp && typeof from[prop] === 'object' && from[prop] !== null && from[prop].nodeName === undefined) {
              if (isDate(from[prop])) {
                if (overwrite) {
                  to[prop] = new Date(from[prop].getTime());
                }
              } else if (isArray(from[prop])) {
                if (overwrite) {
                  to[prop] = from[prop].slice(0);
                }
              } else {
                to[prop] = extend({}, from[prop], overwrite);
              }
            } else if (overwrite || !hasProp) {
              to[prop] = from[prop];
            }
          }
          return to;
        },
        adjustCalendar = function (calendar) {
          if (calendar.month < 0) {
            calendar.year -= Math.ceil(Math.abs(calendar.month) / 12);
            calendar.month += 12;
          }
          if (calendar.month > 11) {
            calendar.year += Math.floor(Math.abs(calendar.month) / 12);
            calendar.month -= 12;
          }
          return calendar;
        },
        defaults = {
          field: null,
          bound: undefined,
          position: 'bottom left',
          reposition: true,
          format: 'YYYY-MM-DD',
          defaultDate: null,
          setDefaultDate: false,
          firstDay: 0,
          formatStrict: false,
          minDate: null,
          maxDate: null,
          yearRange: 10,
          showWeekNumber: false,
          minYear: 0,
          maxYear: 9999,
          minMonth: undefined,
          maxMonth: undefined,
          startRange: null,
          endRange: null,
          isRTL: false,
          yearSuffix: '',
          showMonthAfterYear: false,
          showDaysInNextAndPreviousMonths: false,
          numberOfMonths: 1,
          mainCalendar: 'left',
          container: undefined,
          i18n: {
            previousMonth: 'Previous Month',
            nextMonth: 'Next Month',
            months: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
            weekdays: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
            weekdaysShort: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
          },
          theme: null,
          onSelect: null,
          onOpen: null,
          onClose: null,
          onDraw: null
        },
        renderDayName = function (opts, day, abbr) {
          day += opts.firstDay;
          while (day >= 7) {
            day -= 7;
          }
          return abbr ? opts.i18n.weekdaysShort[day] : opts.i18n.weekdays[day];
        },
        renderDay = function (opts) {
          var arr = [];
          var ariaSelected = 'false';
          if (opts.isEmpty) {
            if (opts.showDaysInNextAndPreviousMonths) {
              arr.push('is-outside-current-month');
            } else {
              return '<td class="is-empty"></td>';
            }
          }
          if (opts.isDisabled) {
            arr.push('is-disabled');
          }
          if (opts.isToday) {
            arr.push('is-today');
          }
          if (opts.isSelected) {
            arr.push('is-selected');
            ariaSelected = 'true';
          }
          if (opts.isInRange) {
            arr.push('is-inrange');
          }
          if (opts.isStartRange) {
            arr.push('is-startrange');
          }
          if (opts.isEndRange) {
            arr.push('is-endrange');
          }
          return '<td data-day="' + opts.day + '" class="' + arr.join(' ') + '" aria-selected="' + ariaSelected + '">' + '<button class="pika-button pika-day" type="button" ' + 'data-pika-year="' + opts.year + '" data-pika-month="' + opts.month + '" data-pika-day="' + opts.day + '">' + opts.day + '</button>' + '</td>';
        },
        renderWeek = function (d, m, y) {
          var onejan = new Date(y, 0, 1),
            weekNum = Math.ceil((((new Date(y, m, d) - onejan) / 86400000) + onejan.getDay() + 1) / 7);
          return '<td class="pika-week">' + weekNum + '</td>';
        },
        renderRow = function (days, isRTL) {
          return '<tr>' + (isRTL ? days.reverse() : days).join('') + '</tr>';
        },
        renderBody = function (rows) {
          return '<tbody>' + rows.join('') + '</tbody>';
        },
        renderHead = function (opts) {
          var i, arr = [];
          if (opts.showWeekNumber) {
            arr.push('<th></th>');
          }
          for (i = 0; i < 7; i++) {
            arr.push('<th scope="col"><abbr title="' + renderDayName(opts, i) + '">' + renderDayName(opts, i, true) + '</abbr></th>');
          }
          return '<thead><tr>' + (opts.isRTL ? arr.reverse() : arr).join('') + '</tr></thead>';
        },
        renderTitle = function (instance, c, year, month, refYear, randId) {
          var i, j, arr, opts = instance._o,
            isMinYear = year === opts.minYear,
            isMaxYear = year === opts.maxYear,
            html = '<div id="' + randId + '" class="pika-title" role="heading" aria-live="assertive">',
            monthHtml, yearHtml, prev = true,
            next = true;
          for (arr = [], i = 0; i < 12; i++) {
            arr.push('<option value="' + (year === refYear ? i - c : 12 + i - c) + '"' + (i === month ? ' selected="selected"' : '') + ((isMinYear && i < opts.minMonth) || (isMaxYear && i > opts.maxMonth) ? 'disabled="disabled"' : '') + '>' + opts.i18n.months[i] + '</option>');
          }
          monthHtml = '<div class="pika-label">' + opts.i18n.months[month] + '<select class="pika-select pika-select-month" tabindex="-1">' + arr.join('') + '</select></div>';
          if (isArray(opts.yearRange)) {
            i = opts.yearRange[0];
            j = opts.yearRange[1] + 1;
          } else {
            i = year - opts.yearRange;
            j = 1 + year + opts.yearRange;
          }
          for (arr = []; i < j && i <= opts.maxYear; i++) {
            if (i >= opts.minYear) {
              arr.push('<option value="' + i + '"' + (i === year ? ' selected="selected"' : '') + '>' + (i) + '</option>');
            }
          }
          yearHtml = '<div class="pika-label">' + year + opts.yearSuffix + '<select class="pika-select pika-select-year" tabindex="-1">' + arr.join('') + '</select></div>';
          if (opts.showMonthAfterYear) {
            html += yearHtml + monthHtml;
          } else {
            html += monthHtml + yearHtml;
          }
          if (isMinYear && (month === 0 || opts.minMonth >= month)) {
            prev = false;
          }
          if (isMaxYear && (month === 11 || opts.maxMonth <= month)) {
            next = false;
          }
          if (c === 0) {
            html += '<button class="pika-prev' + (prev ? '' : ' is-disabled') + '" type="button">' + opts.i18n.previousMonth + '</button>';
          }
          if (c === (instance._o.numberOfMonths - 1)) {
            html += '<button class="pika-next' + (next ? '' : ' is-disabled') + '" type="button">' + opts.i18n.nextMonth + '</button>';
          }
          return html += '</div>';
        },
        renderTable = function (opts, data, randId) {
          return '<table cellpadding="0" cellspacing="0" class="pika-table" role="grid" aria-labelledby="' + randId + '">' + renderHead(opts) + renderBody(data) + '</table>';
        },
        Pikaday = function (options) {
          var self = this,
            opts = self.config(options);
          self._onMouseDown = function (e) {
            if (!self._v) {
              return;
            }
            e = e || window.event;
            var target = e.target || e.srcElement;
            if (!target) {
              return;
            }
            if (!hasClass(target, 'is-disabled')) {
              if (hasClass(target, 'pika-button') && !hasClass(target, 'is-empty') && !hasClass(target.parentNode, 'is-disabled')) {
                self.setDate(new Date(target.getAttribute('data-pika-year'), target.getAttribute('data-pika-month'), target.getAttribute('data-pika-day')));
                if (opts.bound) {
                  sto(function () {
                    self.hide();
                    if (opts.field) {
                      opts.field.blur();
                    }
                  }, 100);
                }
              } else if (hasClass(target, 'pika-prev')) {
                self.prevMonth();
              } else if (hasClass(target, 'pika-next')) {
                self.nextMonth();
              }
            }
            if (!hasClass(target, 'pika-select')) {
              if (e.preventDefault) {
                e.preventDefault();
              } else {
                e.returnValue = false;
                return false;
              }
            } else {
              self._c = true;
            }
          };
          self._onChange = function (e) {
            e = e || window.event;
            var target = e.target || e.srcElement;
            if (!target) {
              return;
            }
            if (hasClass(target, 'pika-select-month')) {
              self.gotoMonth(target.value);
            } else if (hasClass(target, 'pika-select-year')) {
              self.gotoYear(target.value);
            }
          };
          self._onKeyChange = function (e) {
            e = e || window.event;
            if (self.isVisible()) {
              switch (e.keyCode) {
                case 13:
                case 27:
                  opts.field.blur();
                  break;
                case 37:
                  e.preventDefault();
                  self.adjustDate('subtract', 1);
                  break;
                case 38:
                  self.adjustDate('subtract', 7);
                  break;
                case 39:
                  self.adjustDate('add', 1);
                  break;
                case 40:
                  self.adjustDate('add', 7);
                  break;
              }
            }
          };
          self._onInputChange = function (e) {
            var date;
            if (e.firedBy === self) {
              return;
            }
            if (hasMoment) {
              date = moment(opts.field.value, opts.format, opts.formatStrict);
              date = (date && date.isValid()) ? date.toDate() : null;
            } else {
              date = new Date(Date.parse(opts.field.value));
            }
            if (isDate(date)) {
              self.setDate(date);
            }
            if (!self._v) {
              self.show();
            }
          };
          self._onInputFocus = function () {
            self.show();
          };
          self._onInputClick = function () {
            self.show();
          };
          self._onInputBlur = function () {
            var pEl = document.activeElement;
            do {
              if (hasClass(pEl, 'pika-single')) {
                return;
              }
            } while ((pEl = pEl.parentNode));
            if (!self._c) {
              self._b = sto(function () {
                self.hide();
              }, 50);
            }
            self._c = false;
          };
          self._onClick = function (e) {
            e = e || window.event;
            var target = e.target || e.srcElement,
              pEl = target;
            if (!target) {
              return;
            }
            if (!hasEventListeners && hasClass(target, 'pika-select')) {
              if (!target.onchange) {
                target.setAttribute('onchange', 'return;');
                addEvent(target, 'change', self._onChange);
              }
            }
            do {
              if (hasClass(pEl, 'pika-single') || pEl === opts.trigger) {
                return;
              }
            } while ((pEl = pEl.parentNode));
            if (self._v && target !== opts.trigger && pEl !== opts.trigger) {
              self.hide();
            }
          };
          self.el = document.createElement('div');
          self.el.className = 'pika-single' + (opts.isRTL ? ' is-rtl' : '') + (opts.theme ? ' ' + opts.theme : '');
          addEvent(self.el, 'mousedown', self._onMouseDown, true);
          addEvent(self.el, 'touchend', self._onMouseDown, true);
          addEvent(self.el, 'change', self._onChange);
          addEvent(document, 'keydown', self._onKeyChange);
          if (opts.field) {
            if (opts.container) {
              opts.container.appendChild(self.el);
            } else if (opts.bound) {
              document.body.appendChild(self.el);
            } else {
              opts.field.parentNode.insertBefore(self.el, opts.field.nextSibling);
            }
            addEvent(opts.field, 'change', self._onInputChange);
            if (!opts.defaultDate) {
              if (hasMoment && opts.field.value) {
                opts.defaultDate = moment(opts.field.value, opts.format).toDate();
              } else {
                opts.defaultDate = new Date(Date.parse(opts.field.value));
              }
              opts.setDefaultDate = true;
            }
          }
          var defDate = opts.defaultDate;
          if (isDate(defDate)) {
            if (opts.setDefaultDate) {
              self.setDate(defDate, true);
            } else {
              self.gotoDate(defDate);
            }
          } else {
            self.gotoDate(new Date());
          }
          if (opts.bound) {
            this.hide();
            self.el.className += ' is-bound';
            addEvent(opts.trigger, 'click', self._onInputClick);
            addEvent(opts.trigger, 'focus', self._onInputFocus);
            addEvent(opts.trigger, 'blur', self._onInputBlur);
          } else {
            this.show();
          }
        };
      Pikaday.prototype = {
        config: function (options) {
          if (!this._o) {
            this._o = extend({}, defaults, true);
          }
          var opts = extend(this._o, options, true);
          opts.isRTL = !!opts.isRTL;
          opts.field = (opts.field && opts.field.nodeName) ? opts.field : null;
          opts.theme = (typeof opts.theme) === 'string' && opts.theme ? opts.theme : null;
          opts.bound = !!(opts.bound !== undefined ? opts.field && opts.bound : opts.field);
          opts.trigger = (opts.trigger && opts.trigger.nodeName) ? opts.trigger : opts.field;
          opts.disableWeekends = !!opts.disableWeekends;
          opts.disableDayFn = (typeof opts.disableDayFn) === 'function' ? opts.disableDayFn : null;
          var nom = parseInt(opts.numberOfMonths, 10) || 1;
          opts.numberOfMonths = nom > 4 ? 4 : nom;
          if (!isDate(opts.minDate)) {
            opts.minDate = false;
          }
          if (!isDate(opts.maxDate)) {
            opts.maxDate = false;
          }
          if ((opts.minDate && opts.maxDate) && opts.maxDate < opts.minDate) {
            opts.maxDate = opts.minDate = false;
          }
          if (opts.minDate) {
            this.setMinDate(opts.minDate);
          }
          if (opts.maxDate) {
            this.setMaxDate(opts.maxDate);
          }
          if (isArray(opts.yearRange)) {
            var fallback = new Date().getFullYear() - 10;
            opts.yearRange[0] = parseInt(opts.yearRange[0], 10) || fallback;
            opts.yearRange[1] = parseInt(opts.yearRange[1], 10) || fallback;
          } else {
            opts.yearRange = Math.abs(parseInt(opts.yearRange, 10)) || defaults.yearRange;
            if (opts.yearRange > 100) {
              opts.yearRange = 100;
            }
          }
          return opts;
        },
        toString: function (format) {
          return !isDate(this._d) ? '' : hasMoment ? moment(this._d).format(format || this._o.format) : this._d.toDateString();
        },
        getMoment: function () {
          return hasMoment ? moment(this._d) : null;
        },
        setMoment: function (date, preventOnSelect) {
          if (hasMoment && moment.isMoment(date)) {
            this.setDate(date.toDate(), preventOnSelect);
          }
        },
        getDate: function () {
          return isDate(this._d) ? new Date(this._d.getTime()) : new Date();
        },
        setDate: function (date, preventOnSelect) {
          if (!date) {
            this._d = null;
            if (this._o.field) {
              this._o.field.value = '';
              fireEvent(this._o.field, 'change', {
                firedBy: this
              });
            }
            return this.draw();
          }
          if (typeof date === 'string') {
            date = new Date(Date.parse(date));
          }
          if (!isDate(date)) {
            return;
          }
          var min = this._o.minDate,
            max = this._o.maxDate;
          if (isDate(min) && date < min) {
            date = min;
          } else if (isDate(max) && date > max) {
            date = max;
          }
          this._d = new Date(date.getTime());
          setToStartOfDay(this._d);
          this.gotoDate(this._d);
          if (this._o.field) {
            this._o.field.value = this.toString();
            fireEvent(this._o.field, 'change', {
              firedBy: this
            });
          }
          if (!preventOnSelect && typeof this._o.onSelect === 'function') {
            this._o.onSelect.call(this, this.getDate());
          }
        },
        gotoDate: function (date) {
          var newCalendar = true;
          if (!isDate(date)) {
            return;
          }
          if (this.calendars) {
            var firstVisibleDate = new Date(this.calendars[0].year, this.calendars[0].month, 1),
              lastVisibleDate = new Date(this.calendars[this.calendars.length - 1].year, this.calendars[this.calendars.length - 1].month, 1),
              visibleDate = date.getTime();
            lastVisibleDate.setMonth(lastVisibleDate.getMonth() + 1);
            lastVisibleDate.setDate(lastVisibleDate.getDate() - 1);
            newCalendar = (visibleDate < firstVisibleDate.getTime() || lastVisibleDate.getTime() < visibleDate);
          }
          if (newCalendar) {
            this.calendars = [{
              month: date.getMonth(),
              year: date.getFullYear()
            }];
            if (this._o.mainCalendar === 'right') {
              this.calendars[0].month += 1 - this._o.numberOfMonths;
            }
          }
          this.adjustCalendars();
        },
        adjustDate: function (sign, days) {
          var day = this.getDate();
          var difference = parseInt(days) * 24 * 60 * 60 * 1000;
          var newDay;
          if (sign === 'add') {
            newDay = new Date(day.valueOf() + difference);
          } else if (sign === 'subtract') {
            newDay = new Date(day.valueOf() - difference);
          }
          if (hasMoment) {
            if (sign === 'add') {
              newDay = moment(day).add(days, "days").toDate();
            } else if (sign === 'subtract') {
              newDay = moment(day).subtract(days, "days").toDate();
            }
          }
          this.setDate(newDay);
        },
        adjustCalendars: function () {
          this.calendars[0] = adjustCalendar(this.calendars[0]);
          for (var c = 1; c < this._o.numberOfMonths; c++) {
            this.calendars[c] = adjustCalendar({
              month: this.calendars[0].month + c,
              year: this.calendars[0].year
            });
          }
          this.draw();
        },
        gotoToday: function () {
          this.gotoDate(new Date());
        },
        gotoMonth: function (month) {
          if (!isNaN(month)) {
            this.calendars[0].month = parseInt(month, 10);
            this.adjustCalendars();
          }
        },
        nextMonth: function () {
          this.calendars[0].month++;
          this.adjustCalendars();
        },
        prevMonth: function () {
          this.calendars[0].month--;
          this.adjustCalendars();
        },
        gotoYear: function (year) {
          if (!isNaN(year)) {
            this.calendars[0].year = parseInt(year, 10);
            this.adjustCalendars();
          }
        },
        setMinDate: function (value) {
          if (value instanceof Date) {
            setToStartOfDay(value);
            this._o.minDate = value;
            this._o.minYear = value.getFullYear();
            this._o.minMonth = value.getMonth();
          } else {
            this._o.minDate = defaults.minDate;
            this._o.minYear = defaults.minYear;
            this._o.minMonth = defaults.minMonth;
            this._o.startRange = defaults.startRange;
          }
          this.draw();
        },
        setMaxDate: function (value) {
          if (value instanceof Date) {
            setToStartOfDay(value);
            this._o.maxDate = value;
            this._o.maxYear = value.getFullYear();
            this._o.maxMonth = value.getMonth();
          } else {
            this._o.maxDate = defaults.maxDate;
            this._o.maxYear = defaults.maxYear;
            this._o.maxMonth = defaults.maxMonth;
            this._o.endRange = defaults.endRange;
          }
          this.draw();
        },
        setStartRange: function (value) {
          this._o.startRange = value;
        },
        setEndRange: function (value) {
          this._o.endRange = value;
        },
        draw: function (force) {
          if (!this._v && !force) {
            return;
          }
          var opts = this._o,
            minYear = opts.minYear,
            maxYear = opts.maxYear,
            minMonth = opts.minMonth,
            maxMonth = opts.maxMonth,
            html = '',
            randId;
          if (this._y <= minYear) {
            this._y = minYear;
            if (!isNaN(minMonth) && this._m < minMonth) {
              this._m = minMonth;
            }
          }
          if (this._y >= maxYear) {
            this._y = maxYear;
            if (!isNaN(maxMonth) && this._m > maxMonth) {
              this._m = maxMonth;
            }
          }
          randId = 'pika-title-' + Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 2);
          for (var c = 0; c < opts.numberOfMonths; c++) {
            html += '<div class="pika-lendar">' + renderTitle(this, c, this.calendars[c].year, this.calendars[c].month, this.calendars[0].year, randId) + this.render(this.calendars[c].year, this.calendars[c].month, randId) + '</div>';
          }
          this.el.innerHTML = html;
          if (opts.bound) {
            if (opts.field.type !== 'hidden') {
              sto(function () {
                opts.trigger.focus();
              }, 1);
            }
          }
          if (typeof this._o.onDraw === 'function') {
            this._o.onDraw(this);
          }
          if (opts.bound) {
            opts.field.setAttribute('aria-label', 'Use the arrow keys to pick a date');
          }
        },
        adjustPosition: function () {
          var field, pEl, width, height, viewportWidth, viewportHeight, scrollTop, left, top, clientRect;
          if (this._o.container) return;
          this.el.style.position = 'absolute';
          field = this._o.trigger;
          pEl = field;
          width = this.el.offsetWidth;
          height = this.el.offsetHeight;
          viewportWidth = window.innerWidth || document.documentElement.clientWidth;
          viewportHeight = window.innerHeight || document.documentElement.clientHeight;
          scrollTop = window.pageYOffset || document.body.scrollTop || document.documentElement.scrollTop;
          if (typeof field.getBoundingClientRect === 'function') {
            clientRect = field.getBoundingClientRect();
            left = clientRect.left + window.pageXOffset;
            top = clientRect.bottom + window.pageYOffset;
          } else {
            left = pEl.offsetLeft;
            top = pEl.offsetTop + pEl.offsetHeight;
            while ((pEl = pEl.offsetParent)) {
              left += pEl.offsetLeft;
              top += pEl.offsetTop;
            }
          }
          if ((this._o.reposition && left + width > viewportWidth) || (this._o.position.indexOf('right') > -1 && left - width + field.offsetWidth > 0)) {
            left = left - width + field.offsetWidth;
          }
          if ((this._o.reposition && top + height > viewportHeight + scrollTop) || (this._o.position.indexOf('top') > -1 && top - height - field.offsetHeight > 0)) {
            top = top - height - field.offsetHeight;
          }
          this.el.style.left = left + 'px';
          this.el.style.top = top + 'px';
        },
        render: function (year, month, randId) {
          var opts = this._o,
            now = new Date(),
            days = getDaysInMonth(year, month),
            before = new Date(year, month, 1).getDay(),
            data = [],
            row = [];
          setToStartOfDay(now);
          if (opts.firstDay > 0) {
            before -= opts.firstDay;
            if (before < 0) {
              before += 7;
            }
          }
          var previousMonth = month === 0 ? 11 : month - 1,
            nextMonth = month === 11 ? 0 : month + 1,
            yearOfPreviousMonth = month === 0 ? year - 1 : year,
            yearOfNextMonth = month === 11 ? year + 1 : year,
            daysInPreviousMonth = getDaysInMonth(yearOfPreviousMonth, previousMonth);
          var cells = days + before,
            after = cells;
          while (after > 7) {
            after -= 7;
          }
          cells += 7 - after;
          for (var i = 0, r = 0; i < cells; i++) {
            var day = new Date(year, month, 1 + (i - before)),
              isSelected = isDate(this._d) ? compareDates(day, this._d) : false,
              isToday = compareDates(day, now),
              isEmpty = i < before || i >= (days + before),
              dayNumber = 1 + (i - before),
              monthNumber = month,
              yearNumber = year,
              isStartRange = opts.startRange && compareDates(opts.startRange, day),
              isEndRange = opts.endRange && compareDates(opts.endRange, day),
              isInRange = opts.startRange && opts.endRange && opts.startRange < day && day < opts.endRange,
              isDisabled = (opts.minDate && day < opts.minDate) || (opts.maxDate && day > opts.maxDate) || (opts.disableWeekends && isWeekend(day)) || (opts.disableDayFn && opts.disableDayFn(day));
            if (isEmpty) {
              if (i < before) {
                dayNumber = daysInPreviousMonth + dayNumber;
                monthNumber = previousMonth;
                yearNumber = yearOfPreviousMonth;
              } else {
                dayNumber = dayNumber - days;
                monthNumber = nextMonth;
                yearNumber = yearOfNextMonth;
              }
            }
            var dayConfig = {
              day: dayNumber,
              month: monthNumber,
              year: yearNumber,
              isSelected: isSelected,
              isToday: isToday,
              isDisabled: isDisabled,
              isEmpty: isEmpty,
              isStartRange: isStartRange,
              isEndRange: isEndRange,
              isInRange: isInRange,
              showDaysInNextAndPreviousMonths: opts.showDaysInNextAndPreviousMonths
            };
            row.push(renderDay(dayConfig));
            if (++r === 7) {
              if (opts.showWeekNumber) {
                row.unshift(renderWeek(i - before, month, year));
              }
              data.push(renderRow(row, opts.isRTL));
              row = [];
              r = 0;
            }
          }
          return renderTable(opts, data, randId);
        },
        isVisible: function () {
          return this._v;
        },
        show: function () {
          if (!this.isVisible()) {
            removeClass(this.el, 'is-hidden');
            this._v = true;
            this.draw();
            if (this._o.bound) {
              addEvent(document, 'click', this._onClick);
              this.adjustPosition();
            }
            if (typeof this._o.onOpen === 'function') {
              this._o.onOpen.call(this);
            }
          }
        },
        hide: function () {
          var v = this._v;
          if (v !== false) {
            if (this._o.bound) {
              removeEvent(document, 'click', this._onClick);
            }
            this.el.style.position = 'static';
            this.el.style.left = 'auto';
            this.el.style.top = 'auto';
            addClass(this.el, 'is-hidden');
            this._v = false;
            if (v !== undefined && typeof this._o.onClose === 'function') {
              this._o.onClose.call(this);
            }
          }
        },
        destroy: function () {
          this.hide();
          removeEvent(this.el, 'mousedown', this._onMouseDown, true);
          removeEvent(this.el, 'touchend', this._onMouseDown, true);
          removeEvent(this.el, 'change', this._onChange);
          if (this._o.field) {
            removeEvent(this._o.field, 'change', this._onInputChange);
            if (this._o.bound) {
              removeEvent(this._o.trigger, 'click', this._onInputClick);
              removeEvent(this._o.trigger, 'focus', this._onInputFocus);
              removeEvent(this._o.trigger, 'blur', this._onInputBlur);
            }
          }
          if (this.el.parentNode) {
            this.el.parentNode.removeChild(this.el);
          }
        }
      };
      return Pikaday;
    }));
  })]);
});
window.edittable = window.edittable || {};
(function (edittable) {
  'use strict';
  edittable.cellArray = function (selection) {
    var selectionArray = [];
    for (var currentRow = selection.start.row; currentRow <= selection.end.row; currentRow += 1) {
      for (var currentCol = selection.start.col; currentCol <= selection.end.col; currentCol += 1) {
        selectionArray.push({
          row: currentRow,
          col: currentCol
        });
      }
    }
    return selectionArray;
  };
  edittable.getEditTableContextMenu = function (getData, getMeta) {
    return {
      items: {
        toggle_header: {
          name: LANG.plugins.edittable.toggle_header,
          callback: function (key, selection) {
            var meta = getMeta();
            jQuery.each(edittable.cellArray(selection), function (index, cell) {
              var col = cell.col;
              var row = cell.row;
              if (meta[row][col].tag && meta[row][col].tag === 'th') {
                meta[row][col].tag = 'td';
              } else {
                meta[row][col].tag = 'th';
              }
            });
            this.render();
          }
        },
        align_left: {
          name: LANG.plugins.edittable.align_left,
          callback: function (key, selection) {
            var meta = getMeta();
            jQuery.each(edittable.cellArray(selection), function (index, cell) {
              var col = cell.col;
              var row = cell.row;
              meta[row][col].align = 'left';
            });
            this.render();
          },
          disabled: function () {
            var meta = getMeta();
            var selection = this.getSelected();
            var row = selection[0];
            var col = selection[1];
            return (!meta[row][col].align || meta[row][col].align === 'left');
          }
        },
        align_center: {
          name: LANG.plugins.edittable.align_center,
          callback: function (key, selection) {
            var meta = getMeta();
            jQuery.each(edittable.cellArray(selection), function (index, cell) {
              var col = cell.col;
              var row = cell.row;
              meta[row][col].align = 'center';
            });
            this.render();
          },
          disabled: function () {
            var meta = getMeta();
            var selection = this.getSelected();
            var row = selection[0];
            var col = selection[1];
            return (meta[row][col].align && meta[row][col].align === 'center');
          }
        },
        align_right: {
          name: LANG.plugins.edittable.align_right,
          callback: function (key, selection) {
            var meta = getMeta();
            jQuery.each(edittable.cellArray(selection), function (index, cell) {
              var col = cell.col;
              var row = cell.row;
              meta[row][col].align = 'right';
            });
            this.render();
          },
          disabled: function () {
            var meta = getMeta();
            var selection = this.getSelected();
            var row = selection[0];
            var col = selection[1];
            return (meta[row][col].align && meta[row][col].align === 'right');
          }
        },
        hsep1: '---------',
        row_above: {
          name: LANG.plugins.edittable.row_above
        },
        remove_row: {
          name: LANG.plugins.edittable.remove_row,
          callback: function (key, selection) {
            if (window.confirm(LANG.plugins.edittable.confirmdeleterow)) {
              var amount = selection.end.row - selection.start.row + 1;
              this.alter('remove_row', selection.start.row, amount);
            }
          },
          disabled: function () {
            var rowsInTable = this.countRows();
            var firstSelectedRow = this.getSelected()[0];
            var lastSelectedRow = this.getSelected()[2];
            var allRowsSelected = firstSelectedRow === 0 && lastSelectedRow === rowsInTable - 1;
            return (rowsInTable <= 1 || allRowsSelected);
          }
        },
        row_below: {
          name: LANG.plugins.edittable.row_below
        },
        hsep2: '---------',
        col_left: {
          name: LANG.plugins.edittable.col_left
        },
        remove_col: {
          name: LANG.plugins.edittable.remove_col,
          callback: function (key, selection) {
            if (window.confirm(LANG.plugins.edittable.confirmdeletecol)) {
              var amount = selection.end.col - selection.start.col + 1;
              this.alter('remove_col', selection.start.col, amount);
            }
          },
          disabled: function () {
            var colsInTable = this.countCols();
            var firstSelectedColumn = this.getSelected()[1];
            var lastSelectedColumn = this.getSelected()[3];
            var allColsSelected = firstSelectedColumn === 0 && lastSelectedColumn === colsInTable - 1;
            return (colsInTable <= 1 || allColsSelected);
          }
        },
        col_right: {
          name: LANG.plugins.edittable.col_right
        },
        hsep3: '---------',
        mergeCells: {
          name: function () {
            var sel = this.getSelected();
            var info = this.mergeCells.mergedCellInfoCollection.getInfo(sel[0], sel[1]);
            if (info) {
              return '<div class="unmerge">' + LANG.plugins.edittable.unmerge_cells + '</div>';
            } else {
              return '<div class="merge">' + LANG.plugins.edittable.merge_cells + '</div>';
            }
          },
          disabled: function () {
            var selection = this.getSelected();
            var startRow = selection[0];
            var startCol = selection[1];
            var endRow = selection[2];
            var endCol = selection[3];
            return startRow === endRow && startCol === endCol;
          }
        }
      }
    };
  };
}(window.edittable));
window.edittable = window.edittable || {};
window.edittable_plugins = window.edittable_plugins || {};
(function (edittable, edittable_plugins) {
  'use strict';
  edittable.moveRow = function moveRow(movingRowIndexes, target, dmarray) {
    var startIndex = movingRowIndexes[0];
    var endIndex = movingRowIndexes[movingRowIndexes.length - 1];
    var moveForward = target < startIndex;
    var first = dmarray.slice(0, Math.min(startIndex, target));
    var moving = dmarray.slice(startIndex, endIndex + 1);
    var between;
    if (moveForward) {
      between = dmarray.slice(target, startIndex);
    } else {
      between = dmarray.slice(endIndex + 1, target);
    }
    var last = dmarray.slice(Math.max(endIndex + 1, target));
    if (moveForward) {
      return [].concat(first, moving, between, last);
    }
    return [].concat(first, between, moving, last);
  };
  edittable.addRowToMeta = function (index, amount, metaArray) {
    var i;
    var cols = 1;
    if (metaArray[0]) {
      cols = metaArray[0].length;
    }
    for (i = 0; i < amount; i += 1) {
      var newrow = Array.apply(null, new Array(cols)).map(function initializeRowMeta() {
        return {
          rowspan: 1,
          colspan: 1
        };
      });
      metaArray.splice(index, 0, newrow);
    }
    return metaArray;
  };
  edittable.moveCol = function moveCol(movingColIndexes, target, dmarray) {
    return dmarray.map(function (row) {
      return edittable.moveRow(movingColIndexes, target, row);
    });
  };
  edittable.getMerges = function (meta) {
    var merges = [];
    for (var row = 0; row < meta.length; row += 1) {
      for (var col = 0; col < meta[0].length; col += 1) {
        if (meta[row][col].hasOwnProperty('rowspan') && meta[row][col].rowspan > 1 || meta[row][col].hasOwnProperty('colspan') && meta[row][col].colspan > 1) {
          var merge = {};
          merge.row = row;
          merge.col = col;
          merge.rowspan = meta[row][col].rowspan;
          merge.colspan = meta[row][col].colspan;
          merges.push(merge);
        }
      }
    }
    return merges;
  };
  edittable.isTargetInMerge = function isTargetInMerge(merges, target, direction) {
    return merges.some(function (merge) {
      return (merge[direction] < target && target < merge[direction] + merge[direction + 'span']);
    });
  };
  edittable.loadEditor = function () {
    var $container = jQuery('#edittable__editor');
    if (!$container.length) {
      return;
    }
    var $form = jQuery('#dw__editform');
    var $datafield = $form.find('input[name=edittable_data]');
    var $metafield = $form.find('input[name=edittable_meta]');
    var data = JSON.parse($datafield.val());
    var meta = JSON.parse($metafield.val());

    function getMeta() {
      return meta;
    }

    function getData() {
      return data;
    }
    var merges = edittable.getMerges(meta);
    if (merges === []) {
      merges = true;
    }
    var lastselect = {
      row: 0,
      col: 0
    };
    var handsontable_config = {
      data: data,
      startRows: 5,
      startCols: 5,
      colHeaders: true,
      rowHeaders: true,
      manualColumnResize: true,
      outsideClickDeselects: false,
      contextMenu: edittable.getEditTableContextMenu(getData, getMeta),
      manualColumnMove: true,
      manualRowMove: true,
      mergeCells: merges,
      afterLoadData: function () {
        var i;
        this.raw = {
          data: data,
          meta: meta,
          colinfo: [],
          rowinfo: []
        };
        for (i = 0; i < data.length; i += 1) {
          this.raw.rowinfo[i] = {};
        }
        for (i = 0; i < data[0].length; i += 1) {
          this.raw.colinfo[i] = {};
        }
      },
      cells: function (row, col) {
        return meta[row][col];
      },
      renderer: function (instance, td, row, col) {
        var cellMeta = meta[row][col];
        var $td = jQuery(td);
        if (cellMeta.colspan) {
          $td.attr('colspan', cellMeta.colspan);
        } else {
          $td.removeAttr('colspan');
        }
        if (cellMeta.rowspan) {
          $td.attr('rowspan', cellMeta.rowspan);
        } else {
          $td.removeAttr('rowspan');
        }
        if (cellMeta.hide) {
          $td.hide();
        } else {
          $td.show();
        }
        if (cellMeta.align === 'right') {
          $td.addClass('right');
          $td.removeClass('center');
        } else if (cellMeta.align === 'center') {
          $td.addClass('center');
          $td.removeClass('right');
        } else {
          $td.removeClass('center');
          $td.removeClass('right');
        }
        if (cellMeta.tag === 'th') {
          $td.addClass('header');
        } else {
          $td.removeClass('header');
        }
        Handsontable.renderers.TextRenderer.apply(this, arguments);
      },
      afterInit: function () {
        this.selectCell(0, 0);
        jQuery('textarea.handsontableInput').attr('id', 'handsontable__input');
        initToolbar('tool__bar', 'handsontable__input', window.toolbar, false);
        var original_pasteText = window.pasteText;
        window.pasteText = function (selection, text, opts) {
          original_pasteText(selection, text, opts);
          jQuery('#handsontable__input').data('AutoResizer').check();
        };
        window.pasteText = original_pasteText;
        var _this = this;
        this.addHookOnce('afterOnCellMouseOver', function () {
          _this.updateSettings({});
        });
      },
      beforeRender: function () {
        var row, r, c, col, i;
        this.raw.rowinfo = [];
        this.raw.colinfo = [];
        for (i = 0; i < data.length; i += 1) {
          this.raw.rowinfo[i] = {};
        }
        for (i = 0; i < data[0].length; i += 1) {
          this.raw.colinfo[i] = {};
        }
        for (row = 0; row < data.length; row += 1) {
          for (col = 0; col < data[0].length; col += 1) {
            if (meta[row][col].hide) {
              meta[row][col].hide = false;
              data[row][col] = '';
            }
            meta[row][col].colspan = 1;
            meta[row][col].rowspan = 1;
            if (!data[row][col]) {
              data[row][col] = '';
            }
          }
        }
        for (var merge = 0; merge < this.mergeCells.mergedCellInfoCollection.length; merge += 1) {
          row = this.mergeCells.mergedCellInfoCollection[merge].row;
          col = this.mergeCells.mergedCellInfoCollection[merge].col;
          var colspan = this.mergeCells.mergedCellInfoCollection[merge].colspan;
          var rowspan = this.mergeCells.mergedCellInfoCollection[merge].rowspan;
          meta[row][col].colspan = colspan;
          meta[row][col].rowspan = rowspan;
          for (r = row; r < row + rowspan; r += 1) {
            for (c = col; c < col + colspan; c += 1) {
              if (r === row && c === col) {
                continue;
              }
              meta[r][c].hide = true;
              meta[r][c].rowspan = 1;
              meta[r][c].colspan = 1;
              if (data[r][c] && data[r][c] !== ':::') {
                data[row][col] += ' ' + data[r][c];
              }
              if (r === row) {
                data[r][c] = '';
              } else {
                data[r][c] = ':::';
              }
            }
          }
        }
        var dataLBFixed = jQuery.extend(true, {}, data);
        for (row = 0; row < data.length; row += 1) {
          for (col = 0; col < data[0].length; col += 1) {
            dataLBFixed[row][col] = data[row][col].replace(/(\r\n|\n|\r)/g, '\\\\ ');
            data[row][col] = data[row][col].replace(/\\\\\s/g, '\n');
          }
        }
        $datafield.val(JSON.stringify(dataLBFixed));
        $metafield.val(JSON.stringify(meta));
      },
      beforeKeyDown: function (e) {
        if (jQuery('.ui-dialog:visible').length) {
          e.stopImmediatePropagation();
          e.preventDefault();
        }
      },
      beforeColumnMove: function (movingCols, target) {
        var disallowMove = edittable.isTargetInMerge(this.mergeCells.mergedCellInfoCollection, target, 'col');
        if (disallowMove) {
          return false;
        }
        meta = edittable.moveCol(movingCols, target, meta);
        data = edittable.moveCol(movingCols, target, data);
        this.updateSettings({
          mergeCells: edittable.getMerges(meta),
          data: data
        });
        return false;
      },
      beforeRowMove: function (movingRows, target) {
        var disallowMove = edittable.isTargetInMerge(this.mergeCells.mergedCellInfoCollection, target, 'row');
        if (disallowMove) {
          return false;
        }
        meta = edittable.moveRow(movingRows, target, meta);
        data = edittable.moveRow(movingRows, target, data);
        this.updateSettings({
          mergeCells: edittable.getMerges(meta),
          data: data
        });
        return false;
      },
      afterCreateRow: function (index, amount) {
        meta = edittable.addRowToMeta(index, amount, meta);
      },
      afterBeginEditing: function () {
        if (jQuery('textarea.handsontableInput').length > 1) {
          jQuery('textarea.handsontableInput:not(:last)').remove();
          jQuery('textarea.handsontableInput').attr('id', 'handsontable__input');
        }
      },
      afterRemoveRow: function (index, amount) {
        meta.splice(index, amount);
      },
      afterCreateCol: function (index, amount) {
        for (var row = 0; row < data.length; row += 1) {
          for (var i = 0; i < amount; i += 1) {
            meta[row].splice(index, 0, {
              rowspan: 1,
              colspan: 1
            });
          }
        }
      },
      afterRemoveCol: function (index, amount) {
        for (var row = 0; row < data.length; row += 1) {
          meta[row].splice(index, amount);
        }
      },
      afterSelection: function (r, c) {
        if (meta[r][c].hide) {
          var x = 0;
          var v = r - lastselect.row;
          if (v > 0) {
            v = 1;
          }
          if (v < 0) {
            v = -1;
          }
          var h = c - lastselect.col;
          if (h > 0) {
            h = 1;
          }
          if (h < 0) {
            h = -1;
          }
          if (v !== 0) {
            x = r;
            do {
              x += v;
              if (!meta[x][c].hide) {
                this.selectCell(x, c);
                return;
              }
            } while (x > 0 && x < data.length);
            this.deselectCell();
          } else if (h !== 0) {
            x = c;
            do {
              x += h;
              if (!meta[r][x].hide) {
                this.selectCell(r, x);
                return;
              }
            } while (x > 0 && x < data[0].length);
            this.deselectCell();
          }
        } else {
          lastselect.row = r;
          lastselect.col = c;
        }
      },
      beforePaste: function (pasteData, coords) {
        var startRow = coords[0].startRow;
        var startCol = coords[0].startCol;
        var totalRows = this.countRows();
        var totalCols = this.countCols();
        var missingRows = (startRow + pasteData.length) - totalRows;
        var missingCols = (startCol + pasteData[0].length) - totalCols;
        if (missingRows > 0) {
          this.alter('insert_row', undefined, missingRows, 'paste');
        }
        if (missingCols > 0) {
          this.alter('insert_col', undefined, missingCols, 'paste');
        }
        return true;
      }
    };
    if (window.JSINFO.plugins.edittable['default columnwidth']) {
      handsontable_config.colWidths = window.JSINFO.plugins.edittable['default columnwidth'];
    }
    for (var plugin in edittable_plugins) {
      if (edittable_plugins.hasOwnProperty(plugin)) {
        if (typeof edittable_plugins[plugin].modifyHandsontableConfig === 'function') {
          edittable_plugins[plugin].modifyHandsontableConfig(handsontable_config, $form);
        }
      }
    }
    $container.handsontable(handsontable_config);
  };
  jQuery(document).ready(edittable.loadEditor);
}(window.edittable, window.edittable_plugins));
window.addBtnActionNewTable = function addBtnActionNewTable($btn, props, edid) {
  'use strict';
  $btn.click(function () {
    var editform = jQuery('#dw__editform')[0];
    var ed = jQuery('#' + edid)[0];

    function addField(name, val) {
      var pos_field = document.createElement('textarea');
      pos_field.name = 'edittable__new[' + name + ']';
      pos_field.value = val;
      pos_field.style.display = 'none';
      editform.appendChild(pos_field);
    }
    var sel;
    if (window.DWgetSelection) {
      sel = window.DWgetSelection(ed);
    } else {
      sel = window.getSelection(ed);
    }
    addField('pre', ed.value.substr(0, sel.start));
    addField('text', ed.value.substr(sel.start, sel.end - sel.start));
    addField('suf', ed.value.substr(sel.end));
    var range = document.createElement('input');
    range.name = 'range';
    range.value = '0-0';
    range.type = 'hidden';
    editform.appendChild(range);
    var editbutton = document.createElement('input');
    editbutton.name = 'do[edit]';
    editbutton.type = 'submit';
    editbutton.style.display = 'none';
    editform.appendChild(editbutton);
    window.textChanged = false;
    editbutton.click();
  });
  return 'click';
};
jQuery(function () {
  'use strict';
  var $editbutton = jQuery('.dokuwiki div.editbutton_table');
  if (!$editbutton.length) {
    return;
  }
  $editbutton.show();
  var margin = 0;
  var $tablediv = $editbutton.prev('div.table');
  if (!$tablediv.length) {
    return;
  }
  margin += parseFloat($tablediv.css('margin-bottom'));
  margin += parseFloat($tablediv.find('table').css('margin-bottom'));
  margin += 1;
  $editbutton.css('margin-top', margin * -1);
});
jQuery(function () {
  const $extmgr = jQuery('#extension__manager');
  $extmgr.on('click', 'button.uninstall', function (e) {
    if (!window.confirm(LANG.plugins.extension.reallydel)) {
      e.preventDefault();
      return false;
    }
    return true;
  });
  $extmgr.on('click', 'a.extension_screenshot', function (e) {
    e.preventDefault();
    const image_href = jQuery(this).attr("href");
    let $lightbox = jQuery('#plugin__extensionlightbox');
    if (!$lightbox.length) {
      $lightbox = jQuery('<div id="plugin__extensionlightbox"><p>' + LANG.plugins.extension.close + '</p><div></div></div>').appendTo(jQuery('body')).hide().on('click', function () {
        $lightbox.hide();
      });
    }
    $lightbox.show().find('div').html('<img src="' + image_href + '" />');
    return false;
  });
  $extmgr.on('click', 'button.disable, button.enable', function (e) {
    e.preventDefault();
    const $btn = jQuery(this);
    const $section = $btn.parents('section');
    $btn.attr('disabled', 'disabled');
    $btn.css('cursor', 'wait');
    jQuery.get(DOKU_BASE + 'lib/exe/ajax.php', {
      call: 'plugin_extension',
      ext: $section.data('ext'),
      act: 'toggle',
      sectok: $btn.parents('form').find('input[name=sectok]').val()
    }, function (html) {
      $section.replaceWith(html);
    }).fail(function (data) {
      $btn.css('cursor', '').removeAttr('disabled');
      window.alert(data.responseText);
    });
  });
  if ($extmgr.find('.plugins, .templates').hasClass('active')) {
    const $extlist = jQuery('#extension__list');
    const $displayOpts = jQuery('<p>').appendTo($extmgr.find('.panelHeader'));
    const $label = jQuery('<label />').appendTo($displayOpts);
    const $checkbox = jQuery('<input />', {
      type: 'checkbox'
    }).appendTo($label);
    $label.append(' ' + LANG.plugins.extension.filter);
    let filter = !!window.localStorage.getItem('ext_filter');
    $checkbox.prop('checked', filter);
    $extlist.toggleClass('filter', filter);
    $checkbox.on('change', function () {
      filter = this.checked;
      window.localStorage.setItem('ext_filter', filter ? '1' : '');
      $extlist.toggleClass('filter', filter);
    });
  }
});
jQuery(function () {
  var $dl = jQuery('#plugin__logviewer').find('dl');
  if (!$dl.length) return;
  $dl.animate({
    scrollTop: $dl.prop("scrollHeight")
  }, 500);
  var $filter = jQuery('<input>');
  $filter.on('keyup', function (e) {
    var re = new RegExp($filter.val(), 'i');
    $dl.find('dt').each(function (idx, elem) {
      if (elem.innerText.match(re)) {
        jQuery(elem).removeClass('hidden');
      } else {
        jQuery(elem).addClass('hidden');
      }
    });
  });
  $dl.before($filter);
  $filter.wrap('<label></label>');
  $filter.before(LANG.plugins.logviewer.filter + ' ');
});
jQuery(function () {
  function applyPreview(target) {
    var $style = target.jQuery('link[rel=stylesheet][href*="lib/exe/css.php"]');
    $style.attr('href', '');
    var $loader = target.jQuery('#plugin__styling_loader');
    if (!$loader.length) {
      $loader = target.jQuery('<div id="plugin__styling_loader">' + LANG.plugins.styling.loader + '</div>');
      $loader.css({
        'position': 'absolute',
        'width': '100%',
        'height': '100%',
        'top': 0,
        'left': 0,
        'z-index': 5000,
        'background-color': '#fff',
        'opacity': '0.7',
        'color': '#000',
        'font-size': '2.5em',
        'text-align': 'center',
        'line-height': 1.5,
        'padding-top': '2em'
      });
      target.jQuery('body').append($loader);
    }
    setTimeout(function () {
      var now = new Date().getTime();
      $style.attr('href', DOKU_BASE + 'lib/exe/css.php?preview=1&tseed=' + now);
    }, 500);
  }
  var doreload = 1;
  var $styling_plugin = jQuery('#plugin__styling');
  if (!$styling_plugin.length) {
    if (DokuCookie.getValue('styling_plugin') == 1) {
      applyPreview(window);
    }
    return;
  }
  if (!$styling_plugin.hasClass('ispopup')) {
    var $form = $styling_plugin.find('form.styling').first();
    var $btn = jQuery('<button>' + LANG.plugins.styling.popup + '</button>');
    $form.prepend($btn);
    $btn.on('click', function (e) {
      var windowFeatures = "menubar=no,location=no,resizable=yes,scrollbars=yes,status=false,width=500,height=500";
      window.open(DOKU_BASE + 'lib/plugins/styling/popup.php', 'styling_popup', windowFeatures);
      e.preventDefault();
      e.stopPropagation();
    }).wrap('<p></p>');
    return;
  }
  window.onunload = function (e) {
    if (doreload) {
      DokuCookie.setValue('styling_plugin', 0);
      if (window.opener) window.opener.document.location.reload();
    }
    return null;
  };
  jQuery(':button').click(function (e) {
    doreload = false;
  });
  if (window.opener) applyPreview(window.opener);
  DokuCookie.setValue('styling_plugin', 1);
});
jQuery(function () {
  jQuery('#usrmgr__del').on('click', function () {
    return confirm(LANG.del_confirm);
  });
});
jQuery(function () {
  dw_locktimer.init(840, 1);
});