jnpf-web-datareport/node_modules/handsontable/test/dist/e2e.entry.js

/*!
 * (The MIT License)
 * 
 * Copyright (c) 2012-2014 Marcin Warpechowski
 * Copyright (c) 2015 Handsoncode sp. z o.o. <hello@handsoncode.net>
 * 
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * 'Software'), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 * 
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 * 
 * Version: 0.32.0-beta2
 * Date: Tue May 30 2017 12:10:57 GMT+0200 (CEST)
 */
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// identity function for calling harmony imports with the correct context
/******/ 	__webpack_require__.i = function(value) { return value; };
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__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;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 216);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

var global    = __webpack_require__(2)
  , core      = __webpack_require__(20)
  , hide      = __webpack_require__(13)
  , redefine  = __webpack_require__(14)
  , ctx       = __webpack_require__(10)
  , PROTOTYPE = 'prototype';

var $export = function(type, name, source){
  var IS_FORCED = type & $export.F
    , IS_GLOBAL = type & $export.G
    , IS_STATIC = type & $export.S
    , IS_PROTO  = type & $export.P
    , IS_BIND   = type & $export.B
    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE]
    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})
    , expProto  = exports[PROTOTYPE] || (exports[PROTOTYPE] = {})
    , key, own, out, exp;
  if(IS_GLOBAL)source = name;
  for(key in source){
    // contains in native
    own = !IS_FORCED && target && target[key] !== undefined;
    // export native or passed
    out = (own ? target : source)[key];
    // bind timers to global for call from export context
    exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
    // extend global
    if(target)redefine(target, key, out, type & $export.U);
    // export
    if(exports[key] != out)hide(exports, key, exp);
    if(IS_PROTO && expProto[key] != out)expProto[key] = out;
  }
};
global.core = core;
// type bitmap
$export.F = 1;   // forced
$export.G = 2;   // global
$export.S = 4;   // static
$export.P = 8;   // proto
$export.B = 16;  // bind
$export.W = 32;  // wrap
$export.U = 64;  // safe
$export.R = 128; // real proto method for `library` 
module.exports = $export;

/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {

var store      = __webpack_require__(47)('wks')
  , uid        = __webpack_require__(25)
  , Symbol     = __webpack_require__(2).Symbol
  , 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;

/***/ }),
/* 2 */
/***/ (function(module, exports) {

// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
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; // eslint-disable-line no-undef

/***/ }),
/* 3 */
/***/ (function(module, exports) {

module.exports = function(it){
  return typeof it === 'object' ? it !== null : typeof it === 'function';
};

/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(3);
module.exports = function(it){
  if(!isObject(it))throw TypeError(it + ' is not an object!');
  return it;
};

/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {

var anObject       = __webpack_require__(4)
  , IE8_DOM_DEFINE = __webpack_require__(57)
  , toPrimitive    = __webpack_require__(50)
  , dP             = Object.defineProperty;

exports.f = __webpack_require__(6) ? 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){ /* empty */ }
  if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');
  if('value' in Attributes)O[P] = Attributes.value;
  return O;
};

/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {

// Thank's IE8 for his funny defineProperty
module.exports = !__webpack_require__(12)(function(){
  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
});

/***/ }),
/* 7 */
/***/ (function(module, exports) {

var hasOwnProperty = {}.hasOwnProperty;
module.exports = function(it, key){
  return hasOwnProperty.call(it, key);
};

/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {

// to indexed object, toObject with fallback for non-array-like ES3 strings
var IObject = __webpack_require__(41)
  , defined = __webpack_require__(11);
module.exports = function(it){
  return IObject(defined(it));
};

/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {

// 7.1.15 ToLength
var toInteger = __webpack_require__(35)
  , min       = Math.min;
module.exports = function(it){
  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
};

/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {

// optional / simple context binding
var aFunction = __webpack_require__(36);
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(/* ...args */){
    return fn.apply(that, arguments);
  };
};

/***/ }),
/* 11 */
/***/ (function(module, exports) {

// 7.2.1 RequireObjectCoercible(argument)
module.exports = function(it){
  if(it == undefined)throw TypeError("Can't call method on  " + it);
  return it;
};

/***/ }),
/* 12 */
/***/ (function(module, exports) {

module.exports = function(exec){
  try {
    return !!exec();
  } catch(e){
    return true;
  }
};

/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {

var dP         = __webpack_require__(5)
  , createDesc = __webpack_require__(18);
module.exports = __webpack_require__(6) ? function(object, key, value){
  return dP.f(object, key, createDesc(1, value));
} : function(object, key, value){
  object[key] = value;
  return object;
};

/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {

var global    = __webpack_require__(2)
  , hide      = __webpack_require__(13)
  , has       = __webpack_require__(7)
  , SRC       = __webpack_require__(25)('src')
  , TO_STRING = 'toString'
  , $toString = Function[TO_STRING]
  , TPL       = ('' + $toString).split(TO_STRING);

__webpack_require__(20).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);
    }
  }
// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
})(Function.prototype, TO_STRING, function toString(){
  return typeof this == 'function' && this[SRC] || $toString.call(this);
});

/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {

// 22.1.3.31 Array.prototype[@@unscopables]
var UNSCOPABLES = __webpack_require__(1)('unscopables')
  , ArrayProto  = Array.prototype;
if(ArrayProto[UNSCOPABLES] == undefined)__webpack_require__(13)(ArrayProto, UNSCOPABLES, {});
module.exports = function(key){
  ArrayProto[UNSCOPABLES][key] = true;
};

/***/ }),
/* 16 */
/***/ (function(module, exports) {

var toString = {}.toString;

module.exports = function(it){
  return toString.call(it).slice(8, -1);
};

/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.14 / 15.2.3.14 Object.keys(O)
var $keys       = __webpack_require__(66)
  , enumBugKeys = __webpack_require__(39);

module.exports = Object.keys || function keys(O){
  return $keys(O, enumBugKeys);
};

/***/ }),
/* 18 */
/***/ (function(module, exports) {

module.exports = function(bitmap, value){
  return {
    enumerable  : !(bitmap & 1),
    configurable: !(bitmap & 2),
    writable    : !(bitmap & 4),
    value       : value
  };
};

/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {

// 7.1.13 ToObject(argument)
var defined = __webpack_require__(11);
module.exports = function(it){
  return Object(defined(it));
};

/***/ }),
/* 20 */
/***/ (function(module, exports) {

var core = module.exports = {version: '2.4.0'};
if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef

/***/ }),
/* 21 */
/***/ (function(module, exports) {

module.exports = {};

/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {

var META     = __webpack_require__(25)('meta')
  , isObject = __webpack_require__(3)
  , has      = __webpack_require__(7)
  , setDesc  = __webpack_require__(5).f
  , id       = 0;
var isExtensible = Object.isExtensible || function(){
  return true;
};
var FREEZE = !__webpack_require__(12)(function(){
  return isExtensible(Object.preventExtensions({}));
});
var setMeta = function(it){
  setDesc(it, META, {value: {
    i: 'O' + ++id, // object ID
    w: {}          // weak collections IDs
  }});
};
var fastKey = function(it, create){
  // return primitive with prefix
  if(!isObject(it))return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
  if(!has(it, META)){
    // can't set metadata to uncaught frozen object
    if(!isExtensible(it))return 'F';
    // not necessary to add metadata
    if(!create)return 'E';
    // add missing metadata
    setMeta(it);
  // return object ID
  } return it[META].i;
};
var getWeak = function(it, create){
  if(!has(it, META)){
    // can't set metadata to uncaught frozen object
    if(!isExtensible(it))return true;
    // not necessary to add metadata
    if(!create)return false;
    // add missing metadata
    setMeta(it);
  // return hash weak collections IDs
  } return it[META].w;
};
// add metadata on freeze-family methods calling
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
};

/***/ }),
/* 23 */
/***/ (function(module, exports) {

exports.f = {}.propertyIsEnumerable;

/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {

var def = __webpack_require__(5).f
  , has = __webpack_require__(7)
  , TAG = __webpack_require__(1)('toStringTag');

module.exports = function(it, tag, stat){
  if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});
};

/***/ }),
/* 25 */
/***/ (function(module, exports) {

var id = 0
  , px = Math.random();
module.exports = function(key){
  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
};

/***/ }),
/* 26 */
/***/ (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;
};

/***/ }),
/* 27 */
/***/ (function(module, exports, __webpack_require__) {

// 0 -> Array#forEach
// 1 -> Array#map
// 2 -> Array#filter
// 3 -> Array#some
// 4 -> Array#every
// 5 -> Array#find
// 6 -> Array#findIndex
var ctx      = __webpack_require__(10)
  , IObject  = __webpack_require__(41)
  , toObject = __webpack_require__(19)
  , toLength = __webpack_require__(9)
  , asc      = __webpack_require__(250);
module.exports = function(TYPE, $create){
  var IS_MAP        = TYPE == 1
    , IS_FILTER     = TYPE == 2
    , IS_SOME       = TYPE == 3
    , IS_EVERY      = TYPE == 4
    , IS_FIND_INDEX = TYPE == 6
    , NO_HOLES      = TYPE == 5 || IS_FIND_INDEX
    , create        = $create || asc;
  return function($this, callbackfn, that){
    var O      = toObject($this)
      , self   = IObject(O)
      , f      = ctx(callbackfn, that, 3)
      , length = toLength(self.length)
      , index  = 0
      , result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined
      , 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;            // map
        else if(res)switch(TYPE){
          case 3: return true;                    // some
          case 5: return val;                     // find
          case 6: return index;                   // findIndex
          case 2: result.push(val);               // filter
        } else if(IS_EVERY)return false;          // every
      }
    }
    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
  };
};

/***/ }),
/* 28 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var global            = __webpack_require__(2)
  , $export           = __webpack_require__(0)
  , redefine          = __webpack_require__(14)
  , redefineAll       = __webpack_require__(33)
  , meta              = __webpack_require__(22)
  , forOf             = __webpack_require__(30)
  , anInstance        = __webpack_require__(26)
  , isObject          = __webpack_require__(3)
  , fails             = __webpack_require__(12)
  , $iterDetect       = __webpack_require__(42)
  , setToStringTag    = __webpack_require__(24)
  , inheritIfRequired = __webpack_require__(253);

module.exports = function(NAME, wrapper, methods, common, IS_MAP, IS_WEAK){
  var Base  = global[NAME]
    , C     = Base
    , ADDER = IS_MAP ? 'set' : 'add'
    , proto = C && C.prototype
    , 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();
  }))){
    // create collection constructor
    C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
    redefineAll(C.prototype, methods);
    meta.NEED = true;
  } else {
    var instance             = new C
      // early implementations not supports chaining
      , HASNT_CHAINING       = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance
      // V8 ~  Chromium 40- weak-collections throws on primitives, but should return false
      , THROWS_ON_PRIMITIVES = fails(function(){ instance.has(1); })
      // most early implementations doesn't supports iterables, most modern - not close it correctly
      , ACCEPT_ITERABLES     = $iterDetect(function(iter){ new C(iter); }) // eslint-disable-line no-new
      // for early implementations -0 and +0 not the same
      , BUGGY_ZERO = !IS_WEAK && fails(function(){
        // V8 ~ Chromium 42- fails only with 5+ elements
        var $instance = new C()
          , 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);
    // weak collections should not contains .clear method
    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;
};

/***/ }),
/* 29 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var hide     = __webpack_require__(13)
  , redefine = __webpack_require__(14)
  , fails    = __webpack_require__(12)
  , defined  = __webpack_require__(11)
  , wks      = __webpack_require__(1);

module.exports = function(KEY, length, exec){
  var SYMBOL   = wks(KEY)
    , fns      = exec(defined, SYMBOL, ''[KEY])
    , strfn    = fns[0]
    , 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
      // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue)
      // 21.2.5.11 RegExp.prototype[@@split](string, limit)
      ? function(string, arg){ return rxfn.call(string, this, arg); }
      // 21.2.5.6 RegExp.prototype[@@match](string)
      // 21.2.5.9 RegExp.prototype[@@search](string)
      : function(string){ return rxfn.call(string, this); }
    );
  }
};

/***/ }),
/* 30 */
/***/ (function(module, exports, __webpack_require__) {

var ctx         = __webpack_require__(10)
  , call        = __webpack_require__(62)
  , isArrayIter = __webpack_require__(58)
  , anObject    = __webpack_require__(4)
  , toLength    = __webpack_require__(9)
  , getIterFn   = __webpack_require__(73)
  , BREAK       = {}
  , RETURN      = {};
var exports = module.exports = function(iterable, entries, fn, that, ITERATOR){
  var iterFn = ITERATOR ? function(){ return iterable; } : getIterFn(iterable)
    , f      = ctx(fn, that, entries ? 2 : 1)
    , index  = 0
    , length, step, iterator, result;
  if(typeof iterFn != 'function')throw TypeError(iterable + ' is not iterable!');
  // fast case for arrays with default iterator
  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;

/***/ }),
/* 31 */
/***/ (function(module, exports) {

module.exports = false;

/***/ }),
/* 32 */
/***/ (function(module, exports) {

exports.f = Object.getOwnPropertySymbols;

/***/ }),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {

var redefine = __webpack_require__(14);
module.exports = function(target, src, safe){
  for(var key in src)redefine(target, key, src[key], safe);
  return target;
};

/***/ }),
/* 34 */
/***/ (function(module, exports, __webpack_require__) {

var toInteger = __webpack_require__(35)
  , max       = Math.max
  , min       = Math.min;
module.exports = function(index, length){
  index = toInteger(index);
  return index < 0 ? max(index + length, 0) : min(index, length);
};

/***/ }),
/* 35 */
/***/ (function(module, exports) {

// 7.1.4 ToInteger
var ceil  = Math.ceil
  , floor = Math.floor;
module.exports = function(it){
  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
};

/***/ }),
/* 36 */
/***/ (function(module, exports) {

module.exports = function(it){
  if(typeof it != 'function')throw TypeError(it + ' is not a function!');
  return it;
};

/***/ }),
/* 37 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $defineProperty = __webpack_require__(5)
  , createDesc      = __webpack_require__(18);

module.exports = function(object, index, value){
  if(index in object)$defineProperty.f(object, index, createDesc(0, value));
  else object[index] = value;
};

/***/ }),
/* 38 */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(3)
  , document = __webpack_require__(2).document
  // in old IE typeof document.createElement is 'object'
  , is = isObject(document) && isObject(document.createElement);
module.exports = function(it){
  return is ? document.createElement(it) : {};
};

/***/ }),
/* 39 */
/***/ (function(module, exports) {

// IE 8- don't enum bug keys
module.exports = (
  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
).split(',');

/***/ }),
/* 40 */
/***/ (function(module, exports, __webpack_require__) {

var MATCH = __webpack_require__(1)('match');
module.exports = function(KEY){
  var re = /./;
  try {
    '/./'[KEY](re);
  } catch(e){
    try {
      re[MATCH] = false;
      return !'/./'[KEY](re);
    } catch(f){ /* empty */ }
  } return true;
};

/***/ }),
/* 41 */
/***/ (function(module, exports, __webpack_require__) {

// fallback for non-array-like ES3 and non-enumerable old V8 strings
var cof = __webpack_require__(16);
module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){
  return cof(it) == 'String' ? it.split('') : Object(it);
};

/***/ }),
/* 42 */
/***/ (function(module, exports, __webpack_require__) {

var ITERATOR     = __webpack_require__(1)('iterator')
  , SAFE_CLOSING = false;

try {
  var riter = [7][ITERATOR]();
  riter['return'] = function(){ SAFE_CLOSING = true; };
  Array.from(riter, function(){ throw 2; });
} catch(e){ /* empty */ }

module.exports = function(exec, skipClosing){
  if(!skipClosing && !SAFE_CLOSING)return false;
  var safe = false;
  try {
    var arr  = [7]
      , iter = arr[ITERATOR]();
    iter.next = function(){ return {done: safe = true}; };
    arr[ITERATOR] = function(){ return iter; };
    exec(arr);
  } catch(e){ /* empty */ }
  return safe;
};

/***/ }),
/* 43 */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
var anObject    = __webpack_require__(4)
  , dPs         = __webpack_require__(258)
  , enumBugKeys = __webpack_require__(39)
  , IE_PROTO    = __webpack_require__(46)('IE_PROTO')
  , Empty       = function(){ /* empty */ }
  , PROTOTYPE   = 'prototype';

// Create object with fake `null` prototype: use iframe Object with cleared prototype
var createDict = function(){
  // Thrash, waste and sodomy: IE GC bug
  var iframe = __webpack_require__(38)('iframe')
    , i      = enumBugKeys.length
    , lt     = '<'
    , gt     = '>'
    , iframeDocument;
  iframe.style.display = 'none';
  __webpack_require__(56).appendChild(iframe);
  iframe.src = 'javascript:'; // eslint-disable-line no-script-url
  // createDict = iframe.contentWindow.Object;
  // html.removeChild(iframe);
  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;
    // add "__proto__" for Object.getPrototypeOf polyfill
    result[IE_PROTO] = O;
  } else result = createDict();
  return Properties === undefined ? result : dPs(result, Properties);
};


/***/ }),
/* 44 */
/***/ (function(module, exports, __webpack_require__) {

var pIE            = __webpack_require__(23)
  , createDesc     = __webpack_require__(18)
  , toIObject      = __webpack_require__(8)
  , toPrimitive    = __webpack_require__(50)
  , has            = __webpack_require__(7)
  , IE8_DOM_DEFINE = __webpack_require__(57)
  , gOPD           = Object.getOwnPropertyDescriptor;

exports.f = __webpack_require__(6) ? gOPD : function getOwnPropertyDescriptor(O, P){
  O = toIObject(O);
  P = toPrimitive(P, true);
  if(IE8_DOM_DEFINE)try {
    return gOPD(O, P);
  } catch(e){ /* empty */ }
  if(has(O, P))return createDesc(!pIE.f.call(O, P), O[P]);
};

/***/ }),
/* 45 */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
var $keys      = __webpack_require__(66)
  , hiddenKeys = __webpack_require__(39).concat('length', 'prototype');

exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O){
  return $keys(O, hiddenKeys);
};

/***/ }),
/* 46 */
/***/ (function(module, exports, __webpack_require__) {

var shared = __webpack_require__(47)('keys')
  , uid    = __webpack_require__(25);
module.exports = function(key){
  return shared[key] || (shared[key] = uid(key));
};

/***/ }),
/* 47 */
/***/ (function(module, exports, __webpack_require__) {

var global = __webpack_require__(2)
  , SHARED = '__core-js_shared__'
  , store  = global[SHARED] || (global[SHARED] = {});
module.exports = function(key){
  return store[key] || (store[key] = {});
};

/***/ }),
/* 48 */
/***/ (function(module, exports, __webpack_require__) {

// helper for String#{startsWith, endsWith, includes}
var isRegExp = __webpack_require__(61)
  , defined  = __webpack_require__(11);

module.exports = function(that, searchString, NAME){
  if(isRegExp(searchString))throw TypeError('String#' + NAME + " doesn't accept regex!");
  return String(defined(that));
};

/***/ }),
/* 49 */
/***/ (function(module, exports, __webpack_require__) {

var ctx                = __webpack_require__(10)
  , invoke             = __webpack_require__(254)
  , html               = __webpack_require__(56)
  , cel                = __webpack_require__(38)
  , global             = __webpack_require__(2)
  , process            = global.process
  , setTask            = global.setImmediate
  , clearTask          = global.clearImmediate
  , MessageChannel     = global.MessageChannel
  , counter            = 0
  , queue              = {}
  , ONREADYSTATECHANGE = 'onreadystatechange'
  , 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);
};
// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
if(!setTask || !clearTask){
  setTask = function setImmediate(fn){
    var args = [], 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];
  };
  // Node.js 0.8-
  if(__webpack_require__(16)(process) == 'process'){
    defer = function(id){
      process.nextTick(ctx(run, id, 1));
    };
  // Browsers with MessageChannel, includes WebWorkers
  } else if(MessageChannel){
    channel = new MessageChannel;
    port    = channel.port2;
    channel.port1.onmessage = listener;
    defer = ctx(port.postMessage, port, 1);
  // Browsers with postMessage, skip WebWorkers
  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
  } else if(global.addEventListener && typeof postMessage == 'function' && !global.importScripts){
    defer = function(id){
      global.postMessage(id + '', '*');
    };
    global.addEventListener('message', listener, false);
  // IE8-
  } else if(ONREADYSTATECHANGE in cel('script')){
    defer = function(id){
      html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function(){
        html.removeChild(this);
        run.call(id);
      };
    };
  // Rest old browsers
  } else {
    defer = function(id){
      setTimeout(ctx(run, id, 1), 0);
    };
  }
}
module.exports = {
  set:   setTask,
  clear: clearTask
};

/***/ }),
/* 50 */
/***/ (function(module, exports, __webpack_require__) {

// 7.1.1 ToPrimitive(input [, PreferredType])
var isObject = __webpack_require__(3);
// instead of the ES6 spec version, we didn't implement @@toPrimitive case
// and the second argument - flag - preferred type is a string
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");
};

/***/ }),
/* 51 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var addToUnscopables = __webpack_require__(15)
  , step             = __webpack_require__(64)
  , Iterators        = __webpack_require__(21)
  , toIObject        = __webpack_require__(8);

// 22.1.3.4 Array.prototype.entries()
// 22.1.3.13 Array.prototype.keys()
// 22.1.3.29 Array.prototype.values()
// 22.1.3.30 Array.prototype[@@iterator]()
module.exports = __webpack_require__(63)(Array, 'Array', function(iterated, kind){
  this._t = toIObject(iterated); // target
  this._i = 0;                   // next index
  this._k = kind;                // kind
// 22.1.5.2.1 %ArrayIteratorPrototype%.next()
}, function(){
  var O     = this._t
    , kind  = this._k
    , 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');

// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
Iterators.Arguments = Iterators.Array;

addToUnscopables('keys');
addToUnscopables('values');
addToUnscopables('entries');

/***/ }),
/* 52 */
/***/ (function(module, exports, __webpack_require__) {

// false -> Array#indexOf
// true  -> Array#includes
var toIObject = __webpack_require__(8)
  , toLength  = __webpack_require__(9)
  , toIndex   = __webpack_require__(34);
module.exports = function(IS_INCLUDES){
  return function($this, el, fromIndex){
    var O      = toIObject($this)
      , length = toLength(O.length)
      , index  = toIndex(fromIndex, length)
      , value;
    // Array#includes uses SameValueZero equality algorithm
    if(IS_INCLUDES && el != el)while(length > index){
      value = O[index++];
      if(value != value)return true;
    // Array#toIndex ignores holes, Array#includes - not
    } else for(;length > index; index++)if(IS_INCLUDES || index in O){
      if(O[index] === el)return IS_INCLUDES || index || 0;
    } return !IS_INCLUDES && -1;
  };
};

/***/ }),
/* 53 */
/***/ (function(module, exports, __webpack_require__) {

// getting tag from 19.1.3.6 Object.prototype.toString()
var cof = __webpack_require__(16)
  , TAG = __webpack_require__(1)('toStringTag')
  // ES3 wrong here
  , ARG = cof(function(){ return arguments; }()) == 'Arguments';

// fallback for IE11 Script Access Denied error
var tryGet = function(it, key){
  try {
    return it[key];
  } catch(e){ /* empty */ }
};

module.exports = function(it){
  var O, T, B;
  return it === undefined ? 'Undefined' : it === null ? 'Null'
    // @@toStringTag case
    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T
    // builtinTag case
    : ARG ? cof(O)
    // ES3 arguments fallback
    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
};

/***/ }),
/* 54 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var dP          = __webpack_require__(5).f
  , create      = __webpack_require__(43)
  , redefineAll = __webpack_require__(33)
  , ctx         = __webpack_require__(10)
  , anInstance  = __webpack_require__(26)
  , defined     = __webpack_require__(11)
  , forOf       = __webpack_require__(30)
  , $iterDefine = __webpack_require__(63)
  , step        = __webpack_require__(64)
  , setSpecies  = __webpack_require__(69)
  , DESCRIPTORS = __webpack_require__(6)
  , fastKey     = __webpack_require__(22).fastKey
  , SIZE        = DESCRIPTORS ? '_s' : 'size';

var getEntry = function(that, key){
  // fast case
  var index = fastKey(key), entry;
  if(index !== 'F')return that._i[index];
  // frozen object case
  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._i = create(null); // index
      that._f = undefined;    // first entry
      that._l = undefined;    // last entry
      that[SIZE] = 0;         // size
      if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that);
    });
    redefineAll(C.prototype, {
      // 23.1.3.1 Map.prototype.clear()
      // 23.2.3.2 Set.prototype.clear()
      clear: function clear(){
        for(var that = this, 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;
      },
      // 23.1.3.3 Map.prototype.delete(key)
      // 23.2.3.4 Set.prototype.delete(value)
      'delete': function(key){
        var that  = this
          , entry = getEntry(that, key);
        if(entry){
          var next = entry.n
            , 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;
      },
      // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)
      // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)
      forEach: function forEach(callbackfn /*, that = undefined */){
        anInstance(this, C, 'forEach');
        var f = ctx(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3)
          , entry;
        while(entry = entry ? entry.n : this._f){
          f(entry.v, entry.k, this);
          // revert to the last existing entry
          while(entry && entry.r)entry = entry.p;
        }
      },
      // 23.1.3.7 Map.prototype.has(key)
      // 23.2.3.7 Set.prototype.has(value)
      has: function has(key){
        return !!getEntry(this, key);
      }
    });
    if(DESCRIPTORS)dP(C.prototype, 'size', {
      get: function(){
        return defined(this[SIZE]);
      }
    });
    return C;
  },
  def: function(that, key, value){
    var entry = getEntry(that, key)
      , prev, index;
    // change existing entry
    if(entry){
      entry.v = value;
    // create new entry
    } else {
      that._l = entry = {
        i: index = fastKey(key, true), // <- index
        k: key,                        // <- key
        v: value,                      // <- value
        p: prev = that._l,             // <- previous entry
        n: undefined,                  // <- next entry
        r: false                       // <- removed
      };
      if(!that._f)that._f = entry;
      if(prev)prev.n = entry;
      that[SIZE]++;
      // add to index
      if(index !== 'F')that._i[index] = entry;
    } return that;
  },
  getEntry: getEntry,
  setStrong: function(C, NAME, IS_MAP){
    // add .keys, .values, .entries, [@@iterator]
    // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11
    $iterDefine(C, NAME, function(iterated, kind){
      this._t = iterated;  // target
      this._k = kind;      // kind
      this._l = undefined; // previous
    }, function(){
      var that  = this
        , kind  = that._k
        , entry = that._l;
      // revert to the last existing entry
      while(entry && entry.r)entry = entry.p;
      // get next entry
      if(!that._t || !(that._l = entry = entry ? entry.n : that._t._f)){
        // or finish the iteration
        that._t = undefined;
        return step(1);
      }
      // return step by kind
      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);

    // add [@@species], 23.1.2.2, 23.2.2.2
    setSpecies(NAME);
  }
};

/***/ }),
/* 55 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var redefineAll       = __webpack_require__(33)
  , getWeak           = __webpack_require__(22).getWeak
  , anObject          = __webpack_require__(4)
  , isObject          = __webpack_require__(3)
  , anInstance        = __webpack_require__(26)
  , forOf             = __webpack_require__(30)
  , createArrayMethod = __webpack_require__(27)
  , $has              = __webpack_require__(7)
  , arrayFind         = createArrayMethod(5)
  , arrayFindIndex    = createArrayMethod(6)
  , id                = 0;

// fallback for uncaught frozen keys
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._i = id++;      // collection id
      that._l = undefined; // leak store for uncaught frozen objects
      if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that);
    });
    redefineAll(C.prototype, {
      // 23.3.3.2 WeakMap.prototype.delete(key)
      // 23.4.3.3 WeakSet.prototype.delete(value)
      'delete': function(key){
        if(!isObject(key))return false;
        var data = getWeak(key);
        if(data === true)return uncaughtFrozenStore(this)['delete'](key);
        return data && $has(data, this._i) && delete data[this._i];
      },
      // 23.3.3.4 WeakMap.prototype.has(key)
      // 23.4.3.4 WeakSet.prototype.has(value)
      has: function has(key){
        if(!isObject(key))return false;
        var data = getWeak(key);
        if(data === true)return uncaughtFrozenStore(this).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
};

/***/ }),
/* 56 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = __webpack_require__(2).document && document.documentElement;

/***/ }),
/* 57 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = !__webpack_require__(6) && !__webpack_require__(12)(function(){
  return Object.defineProperty(__webpack_require__(38)('div'), 'a', {get: function(){ return 7; }}).a != 7;
});

/***/ }),
/* 58 */
/***/ (function(module, exports, __webpack_require__) {

// check on default Array iterator
var Iterators  = __webpack_require__(21)
  , ITERATOR   = __webpack_require__(1)('iterator')
  , ArrayProto = Array.prototype;

module.exports = function(it){
  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
};

/***/ }),
/* 59 */
/***/ (function(module, exports, __webpack_require__) {

// 7.2.2 IsArray(argument)
var cof = __webpack_require__(16);
module.exports = Array.isArray || function isArray(arg){
  return cof(arg) == 'Array';
};

/***/ }),
/* 60 */
/***/ (function(module, exports, __webpack_require__) {

// 20.1.2.3 Number.isInteger(number)
var isObject = __webpack_require__(3)
  , floor    = Math.floor;
module.exports = function isInteger(it){
  return !isObject(it) && isFinite(it) && floor(it) === it;
};

/***/ }),
/* 61 */
/***/ (function(module, exports, __webpack_require__) {

// 7.2.8 IsRegExp(argument)
var isObject = __webpack_require__(3)
  , cof      = __webpack_require__(16)
  , MATCH    = __webpack_require__(1)('match');
module.exports = function(it){
  var isRegExp;
  return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : cof(it) == 'RegExp');
};

/***/ }),
/* 62 */
/***/ (function(module, exports, __webpack_require__) {

// call something on iterator step with safe closing on error
var anObject = __webpack_require__(4);
module.exports = function(iterator, fn, value, entries){
  try {
    return entries ? fn(anObject(value)[0], value[1]) : fn(value);
  // 7.4.6 IteratorClose(iterator, completion)
  } catch(e){
    var ret = iterator['return'];
    if(ret !== undefined)anObject(ret.call(iterator));
    throw e;
  }
};

/***/ }),
/* 63 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var LIBRARY        = __webpack_require__(31)
  , $export        = __webpack_require__(0)
  , redefine       = __webpack_require__(14)
  , hide           = __webpack_require__(13)
  , has            = __webpack_require__(7)
  , Iterators      = __webpack_require__(21)
  , $iterCreate    = __webpack_require__(255)
  , setToStringTag = __webpack_require__(24)
  , getPrototypeOf = __webpack_require__(260)
  , ITERATOR       = __webpack_require__(1)('iterator')
  , BUGGY          = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`
  , FF_ITERATOR    = '@@iterator'
  , KEYS           = 'keys'
  , 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'
    , DEF_VALUES = DEFAULT == VALUES
    , VALUES_BUG = false
    , proto      = Base.prototype
    , $native    = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]
    , $default   = $native || getMethod(DEFAULT)
    , $entries   = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined
    , $anyNative = NAME == 'Array' ? proto.entries || $native : $native
    , methods, key, IteratorPrototype;
  // Fix native
  if($anyNative){
    IteratorPrototype = getPrototypeOf($anyNative.call(new Base));
    if(IteratorPrototype !== Object.prototype){
      // Set @@toStringTag to native iterators
      setToStringTag(IteratorPrototype, TAG, true);
      // fix for some old engines
      if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);
    }
  }
  // fix Array#{values, @@iterator}.name in V8 / FF
  if(DEF_VALUES && $native && $native.name !== VALUES){
    VALUES_BUG = true;
    $default = function values(){ return $native.call(this); };
  }
  // Define iterator
  if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){
    hide(proto, ITERATOR, $default);
  }
  // Plug for library
  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;
};

/***/ }),
/* 64 */
/***/ (function(module, exports) {

module.exports = function(done, value){
  return {value: value, done: !!done};
};

/***/ }),
/* 65 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// 19.1.2.1 Object.assign(target, source, ...)
var getKeys  = __webpack_require__(17)
  , gOPS     = __webpack_require__(32)
  , pIE      = __webpack_require__(23)
  , toObject = __webpack_require__(19)
  , IObject  = __webpack_require__(41)
  , $assign  = Object.assign;

// should work with symbols and should have deterministic property order (V8 bug)
module.exports = !$assign || __webpack_require__(12)(function(){
  var A = {}
    , B = {}
    , S = Symbol()
    , 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){ // eslint-disable-line no-unused-vars
  var T     = toObject(target)
    , aLen  = arguments.length
    , index = 1
    , getSymbols = gOPS.f
    , isEnum     = pIE.f;
  while(aLen > index){
    var S      = IObject(arguments[index++])
      , keys   = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S)
      , length = keys.length
      , j      = 0
      , key;
    while(length > j)if(isEnum.call(S, key = keys[j++]))T[key] = S[key];
  } return T;
} : $assign;

/***/ }),
/* 66 */
/***/ (function(module, exports, __webpack_require__) {

var has          = __webpack_require__(7)
  , toIObject    = __webpack_require__(8)
  , arrayIndexOf = __webpack_require__(52)(false)
  , IE_PROTO     = __webpack_require__(46)('IE_PROTO');

module.exports = function(object, names){
  var O      = toIObject(object)
    , i      = 0
    , result = []
    , key;
  for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);
  // Don't enum bug & hidden keys
  while(names.length > i)if(has(O, key = names[i++])){
    ~arrayIndexOf(result, key) || result.push(key);
  }
  return result;
};

/***/ }),
/* 67 */
/***/ (function(module, exports, __webpack_require__) {

var getKeys   = __webpack_require__(17)
  , toIObject = __webpack_require__(8)
  , isEnum    = __webpack_require__(23).f;
module.exports = function(isEntries){
  return function(it){
    var O      = toIObject(it)
      , keys   = getKeys(O)
      , length = keys.length
      , i      = 0
      , result = []
      , key;
    while(length > i)if(isEnum.call(O, key = keys[i++])){
      result.push(isEntries ? [key, O[key]] : O[key]);
    } return result;
  };
};

/***/ }),
/* 68 */
/***/ (function(module, exports, __webpack_require__) {

// Works with __proto__ only. Old v8 can't work with null proto objects.
/* eslint-disable no-proto */
var isObject = __webpack_require__(3)
  , anObject = __webpack_require__(4);
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 {} ? // eslint-disable-line
    function(test, buggy, set){
      try {
        set = __webpack_require__(10)(Function.call, __webpack_require__(44).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
};

/***/ }),
/* 69 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var global      = __webpack_require__(2)
  , dP          = __webpack_require__(5)
  , DESCRIPTORS = __webpack_require__(6)
  , SPECIES     = __webpack_require__(1)('species');

module.exports = function(KEY){
  var C = global[KEY];
  if(DESCRIPTORS && C && !C[SPECIES])dP.f(C, SPECIES, {
    configurable: true,
    get: function(){ return this; }
  });
};

/***/ }),
/* 70 */
/***/ (function(module, exports, __webpack_require__) {

// https://github.com/tc39/proposal-string-pad-start-end
var toLength = __webpack_require__(9)
  , repeat   = __webpack_require__(71)
  , defined  = __webpack_require__(11);

module.exports = function(that, maxLength, fillString, left){
  var S            = String(defined(that))
    , stringLength = S.length
    , fillStr      = fillString === undefined ? ' ' : String(fillString)
    , intMaxLength = toLength(maxLength);
  if(intMaxLength <= stringLength || fillStr == '')return S;
  var fillLen = intMaxLength - stringLength
    , stringFiller = repeat.call(fillStr, Math.ceil(fillLen / fillStr.length));
  if(stringFiller.length > fillLen)stringFiller = stringFiller.slice(0, fillLen);
  return left ? stringFiller + S : S + stringFiller;
};


/***/ }),
/* 71 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var toInteger = __webpack_require__(35)
  , defined   = __webpack_require__(11);

module.exports = function repeat(count){
  var str = String(defined(this))
    , res = ''
    , 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;
};

/***/ }),
/* 72 */
/***/ (function(module, exports, __webpack_require__) {

exports.f = __webpack_require__(1);

/***/ }),
/* 73 */
/***/ (function(module, exports, __webpack_require__) {

var classof   = __webpack_require__(53)
  , ITERATOR  = __webpack_require__(1)('iterator')
  , Iterators = __webpack_require__(21);
module.exports = __webpack_require__(20).getIteratorMethod = function(it){
  if(it != undefined)return it[ITERATOR]
    || it['@@iterator']
    || Iterators[classof(it)];
};

/***/ }),
/* 74 */
/***/ (function(module, exports) {

var g;

// This works in non-strict mode
g = (function() {
	return this;
})();

try {
	// This works if eval is allowed (see CSP)
	g = g || Function("return this")() || (1,eval)("this");
} catch(e) {
	// This works if the window reference is available
	if(typeof window === "object")
		g = window;
}

// g can still be undefined, but nothing to do about it...
// We return undefined, instead of nothing here, so it's
// easier to handle this case. if(!global) { ...}

module.exports = g;


/***/ }),
/* 75 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


// this file is called MemoryLeakTest.js (not MemoryLeak.spec.js) to make sure it is manually executed as the last suite
describe('MemoryLeakTest', function () {
  it('after all Handsontable instances are destroy()\'d, there should be no more active listeners', function () {
    expect(Handsontable._getListenersCounter()).toBe(0);
  });
});

/***/ }),
/* 76 */,
/* 77 */,
/* 78 */
/***/ (function(module, exports, __webpack_require__) {

// 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length)
var $export = __webpack_require__(0);

$export($export.P, 'Array', {copyWithin: __webpack_require__(247)});

__webpack_require__(15)('copyWithin');

/***/ }),
/* 79 */
/***/ (function(module, exports, __webpack_require__) {

// 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length)
var $export = __webpack_require__(0);

$export($export.P, 'Array', {fill: __webpack_require__(248)});

__webpack_require__(15)('fill');

/***/ }),
/* 80 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// 22.1.3.9 Array.prototype.findIndex(predicate, thisArg = undefined)
var $export = __webpack_require__(0)
  , $find   = __webpack_require__(27)(6)
  , KEY     = 'findIndex'
  , forced  = true;
// Shouldn't skip holes
if(KEY in [])Array(1)[KEY](function(){ forced = false; });
$export($export.P + $export.F * forced, 'Array', {
  findIndex: function findIndex(callbackfn/*, that = undefined */){
    return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
  }
});
__webpack_require__(15)(KEY);

/***/ }),
/* 81 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// 22.1.3.8 Array.prototype.find(predicate, thisArg = undefined)
var $export = __webpack_require__(0)
  , $find   = __webpack_require__(27)(5)
  , KEY     = 'find'
  , forced  = true;
// Shouldn't skip holes
if(KEY in [])Array(1)[KEY](function(){ forced = false; });
$export($export.P + $export.F * forced, 'Array', {
  find: function find(callbackfn/*, that = undefined */){
    return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
  }
});
__webpack_require__(15)(KEY);

/***/ }),
/* 82 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var ctx            = __webpack_require__(10)
  , $export        = __webpack_require__(0)
  , toObject       = __webpack_require__(19)
  , call           = __webpack_require__(62)
  , isArrayIter    = __webpack_require__(58)
  , toLength       = __webpack_require__(9)
  , createProperty = __webpack_require__(37)
  , getIterFn      = __webpack_require__(73);

$export($export.S + $export.F * !__webpack_require__(42)(function(iter){ Array.from(iter); }), 'Array', {
  // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
  from: function from(arrayLike/*, mapfn = undefined, thisArg = undefined*/){
    var O       = toObject(arrayLike)
      , C       = typeof this == 'function' ? this : Array
      , aLen    = arguments.length
      , mapfn   = aLen > 1 ? arguments[1] : undefined
      , mapping = mapfn !== undefined
      , index   = 0
      , iterFn  = getIterFn(O)
      , length, result, step, iterator;
    if(mapping)mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);
    // if object isn't iterable or it's array with default iterator - use simple case
    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;
  }
});


/***/ }),
/* 83 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export        = __webpack_require__(0)
  , createProperty = __webpack_require__(37);

// WebKit Array.of isn't generic
$export($export.S + $export.F * __webpack_require__(12)(function(){
  function F(){}
  return !(Array.of.call(F) instanceof F);
}), 'Array', {
  // 22.1.2.3 Array.of( ...items)
  of: function of(/* ...args */){
    var index  = 0
      , aLen   = arguments.length
      , result = new (typeof this == 'function' ? this : Array)(aLen);
    while(aLen > index)createProperty(result, index, arguments[index++]);
    result.length = aLen;
    return result;
  }
});

/***/ }),
/* 84 */
/***/ (function(module, exports, __webpack_require__) {

var dP         = __webpack_require__(5).f
  , createDesc = __webpack_require__(18)
  , has        = __webpack_require__(7)
  , FProto     = Function.prototype
  , nameRE     = /^\s*function ([^ (]*)/
  , NAME       = 'name';

var isExtensible = Object.isExtensible || function(){
  return true;
};

// 19.2.4.2 name
NAME in FProto || __webpack_require__(6) && dP(FProto, NAME, {
  configurable: true,
  get: function(){
    try {
      var that = this
        , name = ('' + that).match(nameRE)[1];
      has(that, NAME) || !isExtensible(that) || dP(that, NAME, createDesc(5, name));
      return name;
    } catch(e){
      return '';
    }
  }
});

/***/ }),
/* 85 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var strong = __webpack_require__(54);

// 23.1 Map Objects
module.exports = __webpack_require__(28)('Map', function(get){
  return function Map(){ return get(this, arguments.length > 0 ? arguments[0] : undefined); };
}, {
  // 23.1.3.6 Map.prototype.get(key)
  get: function get(key){
    var entry = strong.getEntry(this, key);
    return entry && entry.v;
  },
  // 23.1.3.9 Map.prototype.set(key, value)
  set: function set(key, value){
    return strong.def(this, key === 0 ? 0 : key, value);
  }
}, strong, true);

/***/ }),
/* 86 */
/***/ (function(module, exports, __webpack_require__) {

// 20.1.2.1 Number.EPSILON
var $export = __webpack_require__(0);

$export($export.S, 'Number', {EPSILON: Math.pow(2, -52)});

/***/ }),
/* 87 */
/***/ (function(module, exports, __webpack_require__) {

// 20.1.2.2 Number.isFinite(number)
var $export   = __webpack_require__(0)
  , _isFinite = __webpack_require__(2).isFinite;

$export($export.S, 'Number', {
  isFinite: function isFinite(it){
    return typeof it == 'number' && _isFinite(it);
  }
});

/***/ }),
/* 88 */
/***/ (function(module, exports, __webpack_require__) {

// 20.1.2.3 Number.isInteger(number)
var $export = __webpack_require__(0);

$export($export.S, 'Number', {isInteger: __webpack_require__(60)});

/***/ }),
/* 89 */
/***/ (function(module, exports, __webpack_require__) {

// 20.1.2.4 Number.isNaN(number)
var $export = __webpack_require__(0);

$export($export.S, 'Number', {
  isNaN: function isNaN(number){
    return number != number;
  }
});

/***/ }),
/* 90 */
/***/ (function(module, exports, __webpack_require__) {

// 20.1.2.5 Number.isSafeInteger(number)
var $export   = __webpack_require__(0)
  , isInteger = __webpack_require__(60)
  , abs       = Math.abs;

$export($export.S, 'Number', {
  isSafeInteger: function isSafeInteger(number){
    return isInteger(number) && abs(number) <= 0x1fffffffffffff;
  }
});

/***/ }),
/* 91 */
/***/ (function(module, exports, __webpack_require__) {

// 20.1.2.6 Number.MAX_SAFE_INTEGER
var $export = __webpack_require__(0);

$export($export.S, 'Number', {MAX_SAFE_INTEGER: 0x1fffffffffffff});

/***/ }),
/* 92 */
/***/ (function(module, exports, __webpack_require__) {

// 20.1.2.10 Number.MIN_SAFE_INTEGER
var $export = __webpack_require__(0);

$export($export.S, 'Number', {MIN_SAFE_INTEGER: -0x1fffffffffffff});

/***/ }),
/* 93 */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.3.1 Object.assign(target, source)
var $export = __webpack_require__(0);

$export($export.S + $export.F, 'Object', {assign: __webpack_require__(65)});

/***/ }),
/* 94 */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.3.10 Object.is(value1, value2)
var $export = __webpack_require__(0);
$export($export.S, 'Object', {is: __webpack_require__(262)});

/***/ }),
/* 95 */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.3.19 Object.setPrototypeOf(O, proto)
var $export = __webpack_require__(0);
$export($export.S, 'Object', {setPrototypeOf: __webpack_require__(68).set});

/***/ }),
/* 96 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var LIBRARY            = __webpack_require__(31)
  , global             = __webpack_require__(2)
  , ctx                = __webpack_require__(10)
  , classof            = __webpack_require__(53)
  , $export            = __webpack_require__(0)
  , isObject           = __webpack_require__(3)
  , aFunction          = __webpack_require__(36)
  , anInstance         = __webpack_require__(26)
  , forOf              = __webpack_require__(30)
  , speciesConstructor = __webpack_require__(263)
  , task               = __webpack_require__(49).set
  , microtask          = __webpack_require__(257)()
  , PROMISE            = 'Promise'
  , TypeError          = global.TypeError
  , process            = global.process
  , $Promise           = global[PROMISE]
  , process            = global.process
  , isNode             = classof(process) == 'process'
  , empty              = function(){ /* empty */ }
  , Internal, GenericPromiseCapability, Wrapper;

var USE_NATIVE = !!function(){
  try {
    // correct subclassing with @@species support
    var promise     = $Promise.resolve(1)
      , FakePromise = (promise.constructor = {})[__webpack_require__(1)('species')] = function(exec){ exec(empty, empty); };
    // unhandled rejections tracking support, NodeJS Promise without it fails @@species test
    return (isNode || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise;
  } catch(e){ /* empty */ }
}();

// helpers
var sameConstructor = function(a, b){
  // with library wrapper special case
  return a === b || a === $Promise && b === Wrapper;
};
var isThenable = function(it){
  var then;
  return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
};
var newPromiseCapability = function(C){
  return sameConstructor($Promise, C)
    ? new PromiseCapability(C)
    : new GenericPromiseCapability(C);
};
var PromiseCapability = GenericPromiseCapability = function(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);
};
var perform = function(exec){
  try {
    exec();
  } catch(e){
    return {error: e};
  }
};
var notify = function(promise, isReject){
  if(promise._n)return;
  promise._n = true;
  var chain = promise._c;
  microtask(function(){
    var value = promise._v
      , ok    = promise._s == 1
      , i     = 0;
    var run = function(reaction){
      var handler = ok ? reaction.ok : reaction.fail
        , resolve = reaction.resolve
        , reject  = reaction.reject
        , domain  = reaction.domain
        , 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++]); // variable length - can't use forEach
    promise._c = [];
    promise._n = false;
    if(isReject && !promise._h)onUnhandled(promise);
  });
};
var onUnhandled = function(promise){
  task.call(global, function(){
    var value = promise._v
      , abrupt, handler, console;
    if(isUnhandled(promise)){
      abrupt = 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);
        }
      });
      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
      promise._h = isNode || isUnhandled(promise) ? 2 : 1;
    } promise._a = undefined;
    if(abrupt)throw abrupt.error;
  });
};
var isUnhandled = function(promise){
  if(promise._h == 1)return false;
  var chain = promise._a || promise._c
    , i     = 0
    , 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; // unwrap
  promise._v = value;
  promise._s = 2;
  if(!promise._a)promise._a = promise._c.slice();
  notify(promise, true);
};
var $resolve = function(value){
  var promise = this
    , then;
  if(promise._d)return;
  promise._d = true;
  promise = promise._w || promise; // unwrap
  try {
    if(promise === value)throw TypeError("Promise can't be resolved itself");
    if(then = isThenable(value)){
      microtask(function(){
        var wrapper = {_w: promise, _d: false}; // wrap
        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); // wrap
  }
};

// constructor polyfill
if(!USE_NATIVE){
  // 25.4.3.1 Promise(executor)
  $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 = [];             // <- awaiting reactions
    this._a = undefined;      // <- checked in isUnhandled reactions
    this._s = 0;              // <- state
    this._d = false;          // <- done
    this._v = undefined;      // <- value
    this._h = 0;              // <- rejection state, 0 - default, 1 - handled, 2 - unhandled
    this._n = false;          // <- notify
  };
  Internal.prototype = __webpack_require__(33)($Promise.prototype, {
    // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)
    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;
    },
    // 25.4.5.1 Promise.prototype.catch(onRejected)
    'catch': function(onRejected){
      return this.then(undefined, onRejected);
    }
  });
  PromiseCapability = function(){
    var promise  = new Internal;
    this.promise = promise;
    this.resolve = ctx($resolve, promise, 1);
    this.reject  = ctx($reject, promise, 1);
  };
}

$export($export.G + $export.W + $export.F * !USE_NATIVE, {Promise: $Promise});
__webpack_require__(24)($Promise, PROMISE);
__webpack_require__(69)(PROMISE);
Wrapper = __webpack_require__(20)[PROMISE];

// statics
$export($export.S + $export.F * !USE_NATIVE, PROMISE, {
  // 25.4.4.5 Promise.reject(r)
  reject: function reject(r){
    var capability = newPromiseCapability(this)
      , $$reject   = capability.reject;
    $$reject(r);
    return capability.promise;
  }
});
$export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {
  // 25.4.4.6 Promise.resolve(x)
  resolve: function resolve(x){
    // instanceof instead of internal slot check because we should fix it without replacement native Promise core
    if(x instanceof $Promise && sameConstructor(x.constructor, this))return x;
    var capability = newPromiseCapability(this)
      , $$resolve  = capability.resolve;
    $$resolve(x);
    return capability.promise;
  }
});
$export($export.S + $export.F * !(USE_NATIVE && __webpack_require__(42)(function(iter){
  $Promise.all(iter)['catch'](empty);
})), PROMISE, {
  // 25.4.4.1 Promise.all(iterable)
  all: function all(iterable){
    var C          = this
      , capability = newPromiseCapability(C)
      , resolve    = capability.resolve
      , reject     = capability.reject;
    var abrupt = perform(function(){
      var values    = []
        , index     = 0
        , remaining = 1;
      forOf(iterable, false, function(promise){
        var $index        = index++
          , 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(abrupt)reject(abrupt.error);
    return capability.promise;
  },
  // 25.4.4.4 Promise.race(iterable)
  race: function race(iterable){
    var C          = this
      , capability = newPromiseCapability(C)
      , reject     = capability.reject;
    var abrupt = perform(function(){
      forOf(iterable, false, function(promise){
        C.resolve(promise).then(capability.resolve, reject);
      });
    });
    if(abrupt)reject(abrupt.error);
    return capability.promise;
  }
});

/***/ }),
/* 97 */
/***/ (function(module, exports, __webpack_require__) {

// 21.2.5.3 get RegExp.prototype.flags()
if(__webpack_require__(6) && /./g.flags != 'g')__webpack_require__(5).f(RegExp.prototype, 'flags', {
  configurable: true,
  get: __webpack_require__(252)
});

/***/ }),
/* 98 */
/***/ (function(module, exports, __webpack_require__) {

// @@match logic
__webpack_require__(29)('match', 1, function(defined, MATCH, $match){
  // 21.1.3.11 String.prototype.match(regexp)
  return [function match(regexp){
    'use strict';
    var O  = defined(this)
      , fn = regexp == undefined ? undefined : regexp[MATCH];
    return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[MATCH](String(O));
  }, $match];
});

/***/ }),
/* 99 */
/***/ (function(module, exports, __webpack_require__) {

// @@replace logic
__webpack_require__(29)('replace', 2, function(defined, REPLACE, $replace){
  // 21.1.3.14 String.prototype.replace(searchValue, replaceValue)
  return [function replace(searchValue, replaceValue){
    'use strict';
    var O  = defined(this)
      , fn = searchValue == undefined ? undefined : searchValue[REPLACE];
    return fn !== undefined
      ? fn.call(searchValue, O, replaceValue)
      : $replace.call(String(O), searchValue, replaceValue);
  }, $replace];
});

/***/ }),
/* 100 */
/***/ (function(module, exports, __webpack_require__) {

// @@search logic
__webpack_require__(29)('search', 1, function(defined, SEARCH, $search){
  // 21.1.3.15 String.prototype.search(regexp)
  return [function search(regexp){
    'use strict';
    var O  = defined(this)
      , fn = regexp == undefined ? undefined : regexp[SEARCH];
    return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[SEARCH](String(O));
  }, $search];
});

/***/ }),
/* 101 */
/***/ (function(module, exports, __webpack_require__) {

// @@split logic
__webpack_require__(29)('split', 2, function(defined, SPLIT, $split){
  'use strict';
  var isRegExp   = __webpack_require__(61)
    , _split     = $split
    , $push      = [].push
    , $SPLIT     = 'split'
    , LENGTH     = 'length'
    , 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; // nonparticipating capturing group
    // based on es5-shim implementation, need to rework it
    $split = function(separator, limit){
      var string = String(this);
      if(separator === undefined && limit === 0)return [];
      // If `separator` is not a regex, use native split
      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;
      // Make `global` and avoid `lastIndex` issues by working with a copy
      var separatorCopy = new RegExp(separator.source, flags + 'g');
      var separator2, match, lastIndex, lastLength, i;
      // Doesn't need flags gy, but they don't hurt
      if(!NPCG)separator2 = new RegExp('^' + separatorCopy.source + '$(?!\\s)', flags);
      while(match = separatorCopy.exec(string)){
        // `separatorCopy.lastIndex` is not reliable cross-browser
        lastIndex = match.index + match[0][LENGTH];
        if(lastIndex > lastLastIndex){
          output.push(string.slice(lastLastIndex, match.index));
          // Fix browsers whose `exec` methods don't consistently return `undefined` for NPCG
          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]++; // Avoid an infinite loop
      }
      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;
    };
  // Chakra, V8
  } else if('0'[$SPLIT](undefined, 0)[LENGTH]){
    $split = function(separator, limit){
      return separator === undefined && limit === 0 ? [] : _split.call(this, separator, limit);
    };
  }
  // 21.1.3.17 String.prototype.split(separator, limit)
  return [function split(separator, limit){
    var O  = defined(this)
      , fn = separator == undefined ? undefined : separator[SPLIT];
    return fn !== undefined ? fn.call(separator, O, limit) : $split.call(String(O), separator, limit);
  }, $split];
});

/***/ }),
/* 102 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var strong = __webpack_require__(54);

// 23.2 Set Objects
module.exports = __webpack_require__(28)('Set', function(get){
  return function Set(){ return get(this, arguments.length > 0 ? arguments[0] : undefined); };
}, {
  // 23.2.3.1 Set.prototype.add(value)
  add: function add(value){
    return strong.def(this, value = value === 0 ? 0 : value, value);
  }
}, strong);

/***/ }),
/* 103 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(0)
  , $at     = __webpack_require__(264)(false);
$export($export.P, 'String', {
  // 21.1.3.3 String.prototype.codePointAt(pos)
  codePointAt: function codePointAt(pos){
    return $at(this, pos);
  }
});

/***/ }),
/* 104 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// 21.1.3.6 String.prototype.endsWith(searchString [, endPosition])

var $export   = __webpack_require__(0)
  , toLength  = __webpack_require__(9)
  , context   = __webpack_require__(48)
  , ENDS_WITH = 'endsWith'
  , $endsWith = ''[ENDS_WITH];

$export($export.P + $export.F * __webpack_require__(40)(ENDS_WITH), 'String', {
  endsWith: function endsWith(searchString /*, endPosition = @length */){
    var that = context(this, searchString, ENDS_WITH)
      , endPosition = arguments.length > 1 ? arguments[1] : undefined
      , len    = toLength(that.length)
      , end    = endPosition === undefined ? len : Math.min(toLength(endPosition), len)
      , search = String(searchString);
    return $endsWith
      ? $endsWith.call(that, search, end)
      : that.slice(end - search.length, end) === search;
  }
});

/***/ }),
/* 105 */
/***/ (function(module, exports, __webpack_require__) {

var $export        = __webpack_require__(0)
  , toIndex        = __webpack_require__(34)
  , fromCharCode   = String.fromCharCode
  , $fromCodePoint = String.fromCodePoint;

// length should be 1, old FF problem
$export($export.S + $export.F * (!!$fromCodePoint && $fromCodePoint.length != 1), 'String', {
  // 21.1.2.2 String.fromCodePoint(...codePoints)
  fromCodePoint: function fromCodePoint(x){ // eslint-disable-line no-unused-vars
    var res  = []
      , aLen = arguments.length
      , i    = 0
      , code;
    while(aLen > i){
      code = +arguments[i++];
      if(toIndex(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('');
  }
});

/***/ }),
/* 106 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// 21.1.3.7 String.prototype.includes(searchString, position = 0)

var $export  = __webpack_require__(0)
  , context  = __webpack_require__(48)
  , INCLUDES = 'includes';

$export($export.P + $export.F * __webpack_require__(40)(INCLUDES), 'String', {
  includes: function includes(searchString /*, position = 0 */){
    return !!~context(this, searchString, INCLUDES)
      .indexOf(searchString, arguments.length > 1 ? arguments[1] : undefined);
  }
});

/***/ }),
/* 107 */
/***/ (function(module, exports, __webpack_require__) {

var $export   = __webpack_require__(0)
  , toIObject = __webpack_require__(8)
  , toLength  = __webpack_require__(9);

$export($export.S, 'String', {
  // 21.1.2.4 String.raw(callSite, ...substitutions)
  raw: function raw(callSite){
    var tpl  = toIObject(callSite.raw)
      , len  = toLength(tpl.length)
      , aLen = arguments.length
      , res  = []
      , i    = 0;
    while(len > i){
      res.push(String(tpl[i++]));
      if(i < aLen)res.push(String(arguments[i]));
    } return res.join('');
  }
});

/***/ }),
/* 108 */
/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(0);

$export($export.P, 'String', {
  // 21.1.3.13 String.prototype.repeat(count)
  repeat: __webpack_require__(71)
});

/***/ }),
/* 109 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// 21.1.3.18 String.prototype.startsWith(searchString [, position ])

var $export     = __webpack_require__(0)
  , toLength    = __webpack_require__(9)
  , context     = __webpack_require__(48)
  , STARTS_WITH = 'startsWith'
  , $startsWith = ''[STARTS_WITH];

$export($export.P + $export.F * __webpack_require__(40)(STARTS_WITH), 'String', {
  startsWith: function startsWith(searchString /*, position = 0 */){
    var that   = context(this, searchString, STARTS_WITH)
      , index  = toLength(Math.min(arguments.length > 1 ? arguments[1] : undefined, that.length))
      , search = String(searchString);
    return $startsWith
      ? $startsWith.call(that, search, index)
      : that.slice(index, index + search.length) === search;
  }
});

/***/ }),
/* 110 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// ECMAScript 6 symbols shim
var global         = __webpack_require__(2)
  , has            = __webpack_require__(7)
  , DESCRIPTORS    = __webpack_require__(6)
  , $export        = __webpack_require__(0)
  , redefine       = __webpack_require__(14)
  , META           = __webpack_require__(22).KEY
  , $fails         = __webpack_require__(12)
  , shared         = __webpack_require__(47)
  , setToStringTag = __webpack_require__(24)
  , uid            = __webpack_require__(25)
  , wks            = __webpack_require__(1)
  , wksExt         = __webpack_require__(72)
  , wksDefine      = __webpack_require__(265)
  , keyOf          = __webpack_require__(256)
  , enumKeys       = __webpack_require__(251)
  , isArray        = __webpack_require__(59)
  , anObject       = __webpack_require__(4)
  , toIObject      = __webpack_require__(8)
  , toPrimitive    = __webpack_require__(50)
  , createDesc     = __webpack_require__(18)
  , _create        = __webpack_require__(43)
  , gOPNExt        = __webpack_require__(259)
  , $GOPD          = __webpack_require__(44)
  , $DP            = __webpack_require__(5)
  , $keys          = __webpack_require__(17)
  , gOPD           = $GOPD.f
  , dP             = $DP.f
  , gOPN           = gOPNExt.f
  , $Symbol        = global.Symbol
  , $JSON          = global.JSON
  , _stringify     = $JSON && $JSON.stringify
  , PROTOTYPE      = 'prototype'
  , HIDDEN         = wks('_hidden')
  , TO_PRIMITIVE   = wks('toPrimitive')
  , isEnum         = {}.propertyIsEnumerable
  , SymbolRegistry = shared('symbol-registry')
  , AllSymbols     = shared('symbols')
  , OPSymbols      = shared('op-symbols')
  , ObjectProto    = Object[PROTOTYPE]
  , USE_NATIVE     = typeof $Symbol == 'function'
  , QObject        = global.QObject;
// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173
var setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;

// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
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))
    , i    = 0
    , l = keys.length
    , 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))
    , result = []
    , i      = 0
    , 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
    , names  = gOPN(IS_OP ? OPSymbols : toIObject(it))
    , result = []
    , i      = 0
    , key;
  while(names.length > i){
    if(has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true))result.push(AllSymbols[key]);
  } return result;
};

// 19.4.1.1 Symbol([description])
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__(45).f = gOPNExt.f = $getOwnPropertyNames;
  __webpack_require__(23).f  = $propertyIsEnumerable;
  __webpack_require__(32).f = $getOwnPropertySymbols;

  if(DESCRIPTORS && !__webpack_require__(31)){
    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 symbols = (
  // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14
  'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'
).split(','), i = 0; symbols.length > i; )wks(symbols[i++]);

for(var symbols = $keys(wks.store), i = 0; symbols.length > i; )wksDefine(symbols[i++]);

$export($export.S + $export.F * !USE_NATIVE, 'Symbol', {
  // 19.4.2.1 Symbol.for(key)
  'for': function(key){
    return has(SymbolRegistry, key += '')
      ? SymbolRegistry[key]
      : SymbolRegistry[key] = $Symbol(key);
  },
  // 19.4.2.5 Symbol.keyFor(sym)
  keyFor: function keyFor(key){
    if(isSymbol(key))return keyOf(SymbolRegistry, key);
    throw TypeError(key + ' is not a symbol!');
  },
  useSetter: function(){ setter = true; },
  useSimple: function(){ setter = false; }
});

$export($export.S + $export.F * !USE_NATIVE, 'Object', {
  // 19.1.2.2 Object.create(O [, Properties])
  create: $create,
  // 19.1.2.4 Object.defineProperty(O, P, Attributes)
  defineProperty: $defineProperty,
  // 19.1.2.3 Object.defineProperties(O, Properties)
  defineProperties: $defineProperties,
  // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
  // 19.1.2.7 Object.getOwnPropertyNames(O)
  getOwnPropertyNames: $getOwnPropertyNames,
  // 19.1.2.8 Object.getOwnPropertySymbols(O)
  getOwnPropertySymbols: $getOwnPropertySymbols
});

// 24.3.2 JSON.stringify(value [, replacer [, space]])
$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function(){
  var S = $Symbol();
  // MS Edge converts symbol values to JSON as {}
  // WebKit converts symbol values to JSON as null
  // V8 throws on boxed symbols
  return _stringify([S]) != '[null]' || _stringify({a: S}) != '{}' || _stringify(Object(S)) != '{}';
})), 'JSON', {
  stringify: function stringify(it){
    if(it === undefined || isSymbol(it))return; // IE8 returns string on undefined
    var args = [it]
      , i    = 1
      , 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);
  }
});

// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)
$Symbol[PROTOTYPE][TO_PRIMITIVE] || __webpack_require__(13)($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);
// 19.4.3.5 Symbol.prototype[@@toStringTag]
setToStringTag($Symbol, 'Symbol');
// 20.2.1.9 Math[@@toStringTag]
setToStringTag(Math, 'Math', true);
// 24.3.3 JSON[@@toStringTag]
setToStringTag(global.JSON, 'JSON', true);

/***/ }),
/* 111 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var each         = __webpack_require__(27)(0)
  , redefine     = __webpack_require__(14)
  , meta         = __webpack_require__(22)
  , assign       = __webpack_require__(65)
  , weak         = __webpack_require__(55)
  , isObject     = __webpack_require__(3)
  , getWeak      = meta.getWeak
  , isExtensible = Object.isExtensible
  , uncaughtFrozenStore = weak.ufstore
  , tmp          = {}
  , InternalMap;

var wrapper = function(get){
  return function WeakMap(){
    return get(this, arguments.length > 0 ? arguments[0] : undefined);
  };
};

var methods = {
  // 23.3.3.3 WeakMap.prototype.get(key)
  get: function get(key){
    if(isObject(key)){
      var data = getWeak(key);
      if(data === true)return uncaughtFrozenStore(this).get(key);
      return data ? data[this._i] : undefined;
    }
  },
  // 23.3.3.5 WeakMap.prototype.set(key, value)
  set: function set(key, value){
    return weak.def(this, key, value);
  }
};

// 23.3 WeakMap Objects
var $WeakMap = module.exports = __webpack_require__(28)('WeakMap', wrapper, methods, weak, true, true);

// IE11 WeakMap frozen keys fix
if(new $WeakMap().set((Object.freeze || Object)(tmp), 7).get(tmp) != 7){
  InternalMap = weak.getConstructor(wrapper);
  assign(InternalMap.prototype, methods);
  meta.NEED = true;
  each(['delete', 'has', 'get', 'set'], function(key){
    var proto  = $WeakMap.prototype
      , method = proto[key];
    redefine(proto, key, function(a, b){
      // store frozen objects on internal weakmap shim
      if(isObject(a) && !isExtensible(a)){
        if(!this._f)this._f = new InternalMap;
        var result = this._f[key](a, b);
        return key == 'set' ? this : result;
      // store all the rest on native weakmap
      } return method.call(this, a, b);
    });
  });
}

/***/ }),
/* 112 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var weak = __webpack_require__(55);

// 23.4 WeakSet Objects
__webpack_require__(28)('WeakSet', function(get){
  return function WeakSet(){ return get(this, arguments.length > 0 ? arguments[0] : undefined); };
}, {
  // 23.4.3.1 WeakSet.prototype.add(value)
  add: function add(value){
    return weak.def(this, value, true);
  }
}, weak, false, true);

/***/ }),
/* 113 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// https://github.com/tc39/Array.prototype.includes
var $export   = __webpack_require__(0)
  , $includes = __webpack_require__(52)(true);

$export($export.P, 'Array', {
  includes: function includes(el /*, fromIndex = 0 */){
    return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
  }
});

__webpack_require__(15)('includes');

/***/ }),
/* 114 */
/***/ (function(module, exports, __webpack_require__) {

// https://github.com/tc39/proposal-object-values-entries
var $export  = __webpack_require__(0)
  , $entries = __webpack_require__(67)(true);

$export($export.S, 'Object', {
  entries: function entries(it){
    return $entries(it);
  }
});

/***/ }),
/* 115 */
/***/ (function(module, exports, __webpack_require__) {

// https://github.com/tc39/proposal-object-getownpropertydescriptors
var $export        = __webpack_require__(0)
  , ownKeys        = __webpack_require__(261)
  , toIObject      = __webpack_require__(8)
  , gOPD           = __webpack_require__(44)
  , createProperty = __webpack_require__(37);

$export($export.S, 'Object', {
  getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object){
    var O       = toIObject(object)
      , getDesc = gOPD.f
      , keys    = ownKeys(O)
      , result  = {}
      , i       = 0
      , key;
    while(keys.length > i)createProperty(result, key = keys[i++], getDesc(O, key));
    return result;
  }
});

/***/ }),
/* 116 */
/***/ (function(module, exports, __webpack_require__) {

// https://github.com/tc39/proposal-object-values-entries
var $export = __webpack_require__(0)
  , $values = __webpack_require__(67)(false);

$export($export.S, 'Object', {
  values: function values(it){
    return $values(it);
  }
});

/***/ }),
/* 117 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// https://github.com/tc39/proposal-string-pad-start-end
var $export = __webpack_require__(0)
  , $pad    = __webpack_require__(70);

$export($export.P, 'String', {
  padEnd: function padEnd(maxLength /*, fillString = ' ' */){
    return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, false);
  }
});

/***/ }),
/* 118 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// https://github.com/tc39/proposal-string-pad-start-end
var $export = __webpack_require__(0)
  , $pad    = __webpack_require__(70);

$export($export.P, 'String', {
  padStart: function padStart(maxLength /*, fillString = ' ' */){
    return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, true);
  }
});

/***/ }),
/* 119 */
/***/ (function(module, exports, __webpack_require__) {

var $iterators    = __webpack_require__(51)
  , redefine      = __webpack_require__(14)
  , global        = __webpack_require__(2)
  , hide          = __webpack_require__(13)
  , Iterators     = __webpack_require__(21)
  , wks           = __webpack_require__(1)
  , ITERATOR      = wks('iterator')
  , TO_STRING_TAG = wks('toStringTag')
  , ArrayValues   = Iterators.Array;

for(var collections = ['NodeList', 'DOMTokenList', 'MediaList', 'StyleSheetList', 'CSSRuleList'], i = 0; i < 5; i++){
  var NAME       = collections[i]
    , Collection = global[NAME]
    , proto      = Collection && Collection.prototype
    , key;
  if(proto){
    if(!proto[ITERATOR])hide(proto, ITERATOR, ArrayValues);
    if(!proto[TO_STRING_TAG])hide(proto, TO_STRING_TAG, NAME);
    Iterators[NAME] = ArrayValues;
    for(key in $iterators)if(!proto[key])redefine(proto, key, $iterators[key], true);
  }
}

/***/ }),
/* 120 */
/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(0)
  , $task   = __webpack_require__(49);
$export($export.G + $export.B, {
  setImmediate:   $task.set,
  clearImmediate: $task.clear
});

/***/ }),
/* 121 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global) {var co = __webpack_require__(246),
    isGeneratorFn = __webpack_require__(266).fn;

var DEFAULT_METHODS = [
    'afterAll',
    'afterEach',
    'beforeAll',
    'beforeEach',
    'it', 'fit', //'xit',
];
var EXPECTS_NAME = ['it', 'fit', 'xit'];

var originalMethods = {},
    overrideMethods, installed;

module.exports = function jasmineCo(userFn) {
    return wrapFn(userFn);
};
module.exports.install = function install() {
    (overrideMethods || DEFAULT_METHODS).forEach(function(fname) {
        coifyJasmineFn(fname);
    });
    installed = true;
};
module.exports.uninstall = function uninstall() {
    Object.keys(originalMethods).forEach(function(key) {
        global[key] = originalMethods[key];
    });
    originalMethods = {};
    installed = false;
};
module.exports.isInstalled = function isInstalled() {
    return installed;
};
module.exports.setOverrideMethods = function setOverrideMethods(methods) {
    overrideMethods = Array.isArray(methods) ? methods : DEFAULT_METHODS;
};

function coifyJasmineFn(fname) {
    // don't process methods that don't exist globally or have already been overridden
    if (!global[fname] || originalMethods[fname]) { return; }

    var origFn = originalMethods[fname] = global[fname];
    global[fname] = wrapFn(origFn, EXPECTS_NAME.indexOf(fname) !== -1);
}

function wrapFn(origFn, expectsName) {
    return function() {
        var userFn = expectsName ? arguments[1] : arguments[0];
        var restParams = [].slice.call(arguments, expectsName ? 2 : 1);
        var args;
        if (isGeneratorFn(userFn)) {
            // if the user method is a generator:
            //   1. call it with the correct `this` context object
            //   2. wrap it in a co function which fails the spec if an exception is
            //      encountered and notifies jasmine that the spec is done when the co
            //      promise settles
            args = [function(done) {
                return co(userFn.bind(this)).then(done, done.fail);
            }];
            if (expectsName) { args.unshift(arguments[0]); }
            if (restParams.length) { args.push.apply(args, restParams); }
            return origFn.apply(null, args);
        } else if (userFn && !userFn.length) {
            // if the user method is a standard function that doesn't expect to be asynchronous
            // (i.e. it doesn't take `done` as a parameter), wrap it with a function that *is*
            // asynchronous and retrofit it to support returning a promise from the function
            args = [function(done) {
                var result = userFn.call(this);
                if (!(result && typeof result.then === 'function')) {
                    done();
                    return result;
                } else {
                    result.then(done, done.fail);
                }
            }];
            if (expectsName) { args.unshift(arguments[0]); }
            if (restParams.length) { args.push.apply(args, restParams); }
            return origFn.apply(null, args);
        } else {
            // if the user method is already asynchronous, just call the standard jasmine method
            // and let the user method take care of itself
            return origFn.apply(null, arguments);
        }
    };
}

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(74)))

/***/ }),
/* 122 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global) {/**
 * Copyright (c) 2014, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
 * additional grant of patent rights can be found in the PATENTS file in
 * the same directory.
 */

!(function(global) {
  "use strict";

  var Op = Object.prototype;
  var hasOwn = Op.hasOwnProperty;
  var undefined; // More compressible than void 0.
  var $Symbol = typeof Symbol === "function" ? Symbol : {};
  var iteratorSymbol = $Symbol.iterator || "@@iterator";
  var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";

  var inModule = typeof module === "object";
  var runtime = global.regeneratorRuntime;
  if (runtime) {
    if (inModule) {
      // If regeneratorRuntime is defined globally and we're in a module,
      // make the exports object identical to regeneratorRuntime.
      module.exports = runtime;
    }
    // Don't bother evaluating the rest of this file if the runtime was
    // already defined globally.
    return;
  }

  // Define the runtime globally (as expected by generated code) as either
  // module.exports (if we're in a module) or a new, empty object.
  runtime = global.regeneratorRuntime = inModule ? module.exports : {};

  function wrap(innerFn, outerFn, self, tryLocsList) {
    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
    var generator = Object.create(protoGenerator.prototype);
    var context = new Context(tryLocsList || []);

    // The ._invoke method unifies the implementations of the .next,
    // .throw, and .return methods.
    generator._invoke = makeInvokeMethod(innerFn, self, context);

    return generator;
  }
  runtime.wrap = wrap;

  // Try/catch helper to minimize deoptimizations. Returns a completion
  // record like context.tryEntries[i].completion. This interface could
  // have been (and was previously) designed to take a closure to be
  // invoked without arguments, but in all the cases we care about we
  // already have an existing method we want to call, so there's no need
  // to create a new function object. We can even get away with assuming
  // the method takes exactly one argument, since that happens to be true
  // in every case, so we don't have to touch the arguments object. The
  // only additional allocation required is the completion record, which
  // has a stable shape and so hopefully should be cheap to allocate.
  function tryCatch(fn, obj, arg) {
    try {
      return { type: "normal", arg: fn.call(obj, arg) };
    } catch (err) {
      return { type: "throw", arg: err };
    }
  }

  var GenStateSuspendedStart = "suspendedStart";
  var GenStateSuspendedYield = "suspendedYield";
  var GenStateExecuting = "executing";
  var GenStateCompleted = "completed";

  // Returning this object from the innerFn has the same effect as
  // breaking out of the dispatch switch statement.
  var ContinueSentinel = {};

  // Dummy constructor functions that we use as the .constructor and
  // .constructor.prototype properties for functions that return Generator
  // objects. For full spec compliance, you may wish to configure your
  // minifier not to mangle the names of these two functions.
  function Generator() {}
  function GeneratorFunction() {}
  function GeneratorFunctionPrototype() {}

  // This is a polyfill for %IteratorPrototype% for environments that
  // don't natively support it.
  var IteratorPrototype = {};
  IteratorPrototype[iteratorSymbol] = function () {
    return this;
  };

  var getProto = Object.getPrototypeOf;
  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
  if (NativeIteratorPrototype &&
      NativeIteratorPrototype !== Op &&
      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
    // This environment has a native %IteratorPrototype%; use it instead
    // of the polyfill.
    IteratorPrototype = NativeIteratorPrototype;
  }

  var Gp = GeneratorFunctionPrototype.prototype =
    Generator.prototype = Object.create(IteratorPrototype);
  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
  GeneratorFunctionPrototype.constructor = GeneratorFunction;
  GeneratorFunctionPrototype[toStringTagSymbol] =
    GeneratorFunction.displayName = "GeneratorFunction";

  // Helper for defining the .next, .throw, and .return methods of the
  // Iterator interface in terms of a single ._invoke method.
  function defineIteratorMethods(prototype) {
    ["next", "throw", "return"].forEach(function(method) {
      prototype[method] = function(arg) {
        return this._invoke(method, arg);
      };
    });
  }

  runtime.isGeneratorFunction = function(genFun) {
    var ctor = typeof genFun === "function" && genFun.constructor;
    return ctor
      ? ctor === GeneratorFunction ||
        // For the native GeneratorFunction constructor, the best we can
        // do is to check its .name property.
        (ctor.displayName || ctor.name) === "GeneratorFunction"
      : false;
  };

  runtime.mark = function(genFun) {
    if (Object.setPrototypeOf) {
      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
    } else {
      genFun.__proto__ = GeneratorFunctionPrototype;
      if (!(toStringTagSymbol in genFun)) {
        genFun[toStringTagSymbol] = "GeneratorFunction";
      }
    }
    genFun.prototype = Object.create(Gp);
    return genFun;
  };

  // Within the body of any async function, `await x` is transformed to
  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
  // `hasOwn.call(value, "__await")` to determine if the yielded value is
  // meant to be awaited.
  runtime.awrap = function(arg) {
    return { __await: arg };
  };

  function AsyncIterator(generator) {
    function invoke(method, arg, resolve, reject) {
      var record = tryCatch(generator[method], generator, arg);
      if (record.type === "throw") {
        reject(record.arg);
      } else {
        var result = record.arg;
        var value = result.value;
        if (value &&
            typeof value === "object" &&
            hasOwn.call(value, "__await")) {
          return Promise.resolve(value.__await).then(function(value) {
            invoke("next", value, resolve, reject);
          }, function(err) {
            invoke("throw", err, resolve, reject);
          });
        }

        return Promise.resolve(value).then(function(unwrapped) {
          // When a yielded Promise is resolved, its final value becomes
          // the .value of the Promise<{value,done}> result for the
          // current iteration. If the Promise is rejected, however, the
          // result for this iteration will be rejected with the same
          // reason. Note that rejections of yielded Promises are not
          // thrown back into the generator function, as is the case
          // when an awaited Promise is rejected. This difference in
          // behavior between yield and await is important, because it
          // allows the consumer to decide what to do with the yielded
          // rejection (swallow it and continue, manually .throw it back
          // into the generator, abandon iteration, whatever). With
          // await, by contrast, there is no opportunity to examine the
          // rejection reason outside the generator function, so the
          // only option is to throw it from the await expression, and
          // let the generator function handle the exception.
          result.value = unwrapped;
          resolve(result);
        }, reject);
      }
    }

    if (typeof global.process === "object" && global.process.domain) {
      invoke = global.process.domain.bind(invoke);
    }

    var previousPromise;

    function enqueue(method, arg) {
      function callInvokeWithMethodAndArg() {
        return new Promise(function(resolve, reject) {
          invoke(method, arg, resolve, reject);
        });
      }

      return previousPromise =
        // If enqueue has been called before, then we want to wait until
        // all previous Promises have been resolved before calling invoke,
        // so that results are always delivered in the correct order. If
        // enqueue has not been called before, then it is important to
        // call invoke immediately, without waiting on a callback to fire,
        // so that the async generator function has the opportunity to do
        // any necessary setup in a predictable way. This predictability
        // is why the Promise constructor synchronously invokes its
        // executor callback, and why async functions synchronously
        // execute code before the first await. Since we implement simple
        // async functions in terms of async generators, it is especially
        // important to get this right, even though it requires care.
        previousPromise ? previousPromise.then(
          callInvokeWithMethodAndArg,
          // Avoid propagating failures to Promises returned by later
          // invocations of the iterator.
          callInvokeWithMethodAndArg
        ) : callInvokeWithMethodAndArg();
    }

    // Define the unified helper method that is used to implement .next,
    // .throw, and .return (see defineIteratorMethods).
    this._invoke = enqueue;
  }

  defineIteratorMethods(AsyncIterator.prototype);
  AsyncIterator.prototype[asyncIteratorSymbol] = function () {
    return this;
  };
  runtime.AsyncIterator = AsyncIterator;

  // Note that simple async functions are implemented on top of
  // AsyncIterator objects; they just return a Promise for the value of
  // the final result produced by the iterator.
  runtime.async = function(innerFn, outerFn, self, tryLocsList) {
    var iter = new AsyncIterator(
      wrap(innerFn, outerFn, self, tryLocsList)
    );

    return runtime.isGeneratorFunction(outerFn)
      ? iter // If outerFn is a generator, return the full iterator.
      : iter.next().then(function(result) {
          return result.done ? result.value : iter.next();
        });
  };

  function makeInvokeMethod(innerFn, self, context) {
    var state = GenStateSuspendedStart;

    return function invoke(method, arg) {
      if (state === GenStateExecuting) {
        throw new Error("Generator is already running");
      }

      if (state === GenStateCompleted) {
        if (method === "throw") {
          throw arg;
        }

        // Be forgiving, per 25.3.3.3.3 of the spec:
        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
        return doneResult();
      }

      context.method = method;
      context.arg = arg;

      while (true) {
        var delegate = context.delegate;
        if (delegate) {
          var delegateResult = maybeInvokeDelegate(delegate, context);
          if (delegateResult) {
            if (delegateResult === ContinueSentinel) continue;
            return delegateResult;
          }
        }

        if (context.method === "next") {
          // Setting context._sent for legacy support of Babel's
          // function.sent implementation.
          context.sent = context._sent = context.arg;

        } else if (context.method === "throw") {
          if (state === GenStateSuspendedStart) {
            state = GenStateCompleted;
            throw context.arg;
          }

          context.dispatchException(context.arg);

        } else if (context.method === "return") {
          context.abrupt("return", context.arg);
        }

        state = GenStateExecuting;

        var record = tryCatch(innerFn, self, context);
        if (record.type === "normal") {
          // If an exception is thrown from innerFn, we leave state ===
          // GenStateExecuting and loop back for another invocation.
          state = context.done
            ? GenStateCompleted
            : GenStateSuspendedYield;

          if (record.arg === ContinueSentinel) {
            continue;
          }

          return {
            value: record.arg,
            done: context.done
          };

        } else if (record.type === "throw") {
          state = GenStateCompleted;
          // Dispatch the exception by looping back around to the
          // context.dispatchException(context.arg) call above.
          context.method = "throw";
          context.arg = record.arg;
        }
      }
    };
  }

  // Call delegate.iterator[context.method](context.arg) and handle the
  // result, either by returning a { value, done } result from the
  // delegate iterator, or by modifying context.method and context.arg,
  // setting context.delegate to null, and returning the ContinueSentinel.
  function maybeInvokeDelegate(delegate, context) {
    var method = delegate.iterator[context.method];
    if (method === undefined) {
      // A .throw or .return when the delegate iterator has no .throw
      // method always terminates the yield* loop.
      context.delegate = null;

      if (context.method === "throw") {
        if (delegate.iterator.return) {
          // If the delegate iterator has a return method, give it a
          // chance to clean up.
          context.method = "return";
          context.arg = undefined;
          maybeInvokeDelegate(delegate, context);

          if (context.method === "throw") {
            // If maybeInvokeDelegate(context) changed context.method from
            // "return" to "throw", let that override the TypeError below.
            return ContinueSentinel;
          }
        }

        context.method = "throw";
        context.arg = new TypeError(
          "The iterator does not provide a 'throw' method");
      }

      return ContinueSentinel;
    }

    var record = tryCatch(method, delegate.iterator, context.arg);

    if (record.type === "throw") {
      context.method = "throw";
      context.arg = record.arg;
      context.delegate = null;
      return ContinueSentinel;
    }

    var info = record.arg;

    if (! info) {
      context.method = "throw";
      context.arg = new TypeError("iterator result is not an object");
      context.delegate = null;
      return ContinueSentinel;
    }

    if (info.done) {
      // Assign the result of the finished delegate to the temporary
      // variable specified by delegate.resultName (see delegateYield).
      context[delegate.resultName] = info.value;

      // Resume execution at the desired location (see delegateYield).
      context.next = delegate.nextLoc;

      // If context.method was "throw" but the delegate handled the
      // exception, let the outer generator proceed normally. If
      // context.method was "next", forget context.arg since it has been
      // "consumed" by the delegate iterator. If context.method was
      // "return", allow the original .return call to continue in the
      // outer generator.
      if (context.method !== "return") {
        context.method = "next";
        context.arg = undefined;
      }

    } else {
      // Re-yield the result returned by the delegate method.
      return info;
    }

    // The delegate iterator is finished, so forget it and continue with
    // the outer generator.
    context.delegate = null;
    return ContinueSentinel;
  }

  // Define Generator.prototype.{next,throw,return} in terms of the
  // unified ._invoke helper method.
  defineIteratorMethods(Gp);

  Gp[toStringTagSymbol] = "Generator";

  // A Generator should always return itself as the iterator object when the
  // @@iterator function is called on it. Some browsers' implementations of the
  // iterator prototype chain incorrectly implement this, causing the Generator
  // object to not be returned from this call. This ensures that doesn't happen.
  // See https://github.com/facebook/regenerator/issues/274 for more details.
  Gp[iteratorSymbol] = function() {
    return this;
  };

  Gp.toString = function() {
    return "[object Generator]";
  };

  function pushTryEntry(locs) {
    var entry = { tryLoc: locs[0] };

    if (1 in locs) {
      entry.catchLoc = locs[1];
    }

    if (2 in locs) {
      entry.finallyLoc = locs[2];
      entry.afterLoc = locs[3];
    }

    this.tryEntries.push(entry);
  }

  function resetTryEntry(entry) {
    var record = entry.completion || {};
    record.type = "normal";
    delete record.arg;
    entry.completion = record;
  }

  function Context(tryLocsList) {
    // The root entry object (effectively a try statement without a catch
    // or a finally block) gives us a place to store values thrown from
    // locations where there is no enclosing try statement.
    this.tryEntries = [{ tryLoc: "root" }];
    tryLocsList.forEach(pushTryEntry, this);
    this.reset(true);
  }

  runtime.keys = function(object) {
    var keys = [];
    for (var key in object) {
      keys.push(key);
    }
    keys.reverse();

    // Rather than returning an object with a next method, we keep
    // things simple and return the next function itself.
    return function next() {
      while (keys.length) {
        var key = keys.pop();
        if (key in object) {
          next.value = key;
          next.done = false;
          return next;
        }
      }

      // To avoid creating an additional object, we just hang the .value
      // and .done properties off the next function object itself. This
      // also ensures that the minifier will not anonymize the function.
      next.done = true;
      return next;
    };
  };

  function values(iterable) {
    if (iterable) {
      var iteratorMethod = iterable[iteratorSymbol];
      if (iteratorMethod) {
        return iteratorMethod.call(iterable);
      }

      if (typeof iterable.next === "function") {
        return iterable;
      }

      if (!isNaN(iterable.length)) {
        var i = -1, next = function next() {
          while (++i < iterable.length) {
            if (hasOwn.call(iterable, i)) {
              next.value = iterable[i];
              next.done = false;
              return next;
            }
          }

          next.value = undefined;
          next.done = true;

          return next;
        };

        return next.next = next;
      }
    }

    // Return an iterator with no values.
    return { next: doneResult };
  }
  runtime.values = values;

  function doneResult() {
    return { value: undefined, done: true };
  }

  Context.prototype = {
    constructor: Context,

    reset: function(skipTempReset) {
      this.prev = 0;
      this.next = 0;
      // Resetting context._sent for legacy support of Babel's
      // function.sent implementation.
      this.sent = this._sent = undefined;
      this.done = false;
      this.delegate = null;

      this.method = "next";
      this.arg = undefined;

      this.tryEntries.forEach(resetTryEntry);

      if (!skipTempReset) {
        for (var name in this) {
          // Not sure about the optimal order of these conditions:
          if (name.charAt(0) === "t" &&
              hasOwn.call(this, name) &&
              !isNaN(+name.slice(1))) {
            this[name] = undefined;
          }
        }
      }
    },

    stop: function() {
      this.done = true;

      var rootEntry = this.tryEntries[0];
      var rootRecord = rootEntry.completion;
      if (rootRecord.type === "throw") {
        throw rootRecord.arg;
      }

      return this.rval;
    },

    dispatchException: function(exception) {
      if (this.done) {
        throw exception;
      }

      var context = this;
      function handle(loc, caught) {
        record.type = "throw";
        record.arg = exception;
        context.next = loc;

        if (caught) {
          // If the dispatched exception was caught by a catch block,
          // then let that catch block handle the exception normally.
          context.method = "next";
          context.arg = undefined;
        }

        return !! caught;
      }

      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        var record = entry.completion;

        if (entry.tryLoc === "root") {
          // Exception thrown outside of any try block that could handle
          // it, so set the completion value of the entire function to
          // throw the exception.
          return handle("end");
        }

        if (entry.tryLoc <= this.prev) {
          var hasCatch = hasOwn.call(entry, "catchLoc");
          var hasFinally = hasOwn.call(entry, "finallyLoc");

          if (hasCatch && hasFinally) {
            if (this.prev < entry.catchLoc) {
              return handle(entry.catchLoc, true);
            } else if (this.prev < entry.finallyLoc) {
              return handle(entry.finallyLoc);
            }

          } else if (hasCatch) {
            if (this.prev < entry.catchLoc) {
              return handle(entry.catchLoc, true);
            }

          } else if (hasFinally) {
            if (this.prev < entry.finallyLoc) {
              return handle(entry.finallyLoc);
            }

          } else {
            throw new Error("try statement without catch or finally");
          }
        }
      }
    },

    abrupt: function(type, arg) {
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        if (entry.tryLoc <= this.prev &&
            hasOwn.call(entry, "finallyLoc") &&
            this.prev < entry.finallyLoc) {
          var finallyEntry = entry;
          break;
        }
      }

      if (finallyEntry &&
          (type === "break" ||
           type === "continue") &&
          finallyEntry.tryLoc <= arg &&
          arg <= finallyEntry.finallyLoc) {
        // Ignore the finally entry if control is not jumping to a
        // location outside the try/catch block.
        finallyEntry = null;
      }

      var record = finallyEntry ? finallyEntry.completion : {};
      record.type = type;
      record.arg = arg;

      if (finallyEntry) {
        this.method = "next";
        this.next = finallyEntry.finallyLoc;
        return ContinueSentinel;
      }

      return this.complete(record);
    },

    complete: function(record, afterLoc) {
      if (record.type === "throw") {
        throw record.arg;
      }

      if (record.type === "break" ||
          record.type === "continue") {
        this.next = record.arg;
      } else if (record.type === "return") {
        this.rval = this.arg = record.arg;
        this.method = "return";
        this.next = "end";
      } else if (record.type === "normal" && afterLoc) {
        this.next = afterLoc;
      }

      return ContinueSentinel;
    },

    finish: function(finallyLoc) {
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        if (entry.finallyLoc === finallyLoc) {
          this.complete(entry.completion, entry.afterLoc);
          resetTryEntry(entry);
          return ContinueSentinel;
        }
      }
    },

    "catch": function(tryLoc) {
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        if (entry.tryLoc === tryLoc) {
          var record = entry.completion;
          if (record.type === "throw") {
            var thrown = record.arg;
            resetTryEntry(entry);
          }
          return thrown;
        }
      }

      // The context.catch method must only be called with a location
      // argument that corresponds to a known catch block.
      throw new Error("illegal catch attempt");
    },

    delegateYield: function(iterable, resultName, nextLoc) {
      this.delegate = {
        iterator: values(iterable),
        resultName: resultName,
        nextLoc: nextLoc
      };

      if (this.method === "next") {
        // Deliberately forget the last sent value so that we don't
        // accidentally pass it on to the delegate.
        this.arg = undefined;
      }

      return ContinueSentinel;
    }
  };
})(
  // Among the various tricks for obtaining a reference to the global
  // object, this seems to be the most reliable technique that does not
  // use indirect eval (which violates Content Security Policy).
  typeof global === "object" ? global :
  typeof window === "object" ? window :
  typeof self === "object" ? self : this
);

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(74)))

/***/ }),
/* 123 */
/***/ (function(module, exports, __webpack_require__) {

var map = {
	"./autoColumnSize/test/autoColumnSize.e2e.js": 126,
	"./autoRowSize/test/autoRowSize.e2e.js": 127,
	"./columnSorting/test/columnSorting.e2e.js": 128,
	"./comments/test/comments.e2e.js": 129,
	"./contextMenu/test/alignment.e2e.js": 130,
	"./contextMenu/test/contextMenu.e2e.js": 131,
	"./contextMenu/test/predefinedItems/readOnly.e2e.js": 132,
	"./contextMenuCopyPaste/test/contextMenuCopyPaste.e2e.js": 133,
	"./copyPaste/test/copyPaste.e2e.js": 134,
	"./customBorders/test/customBorders.e2e.js": 135,
	"./dragToScroll/test/dragToScroll.e2e.js": 136,
	"./manualColumnFreeze/test/manualColumnFreeze.e2e.js": 137,
	"./manualColumnMove/test/manualColumnMove.e2e.js": 138,
	"./manualColumnMove/test/manualColumnMoveUI.e2e.js": 139,
	"./manualColumnResize/test/manualColumnResize.e2e.js": 140,
	"./manualRowMove/test/manualRowMove.e2e.js": 141,
	"./manualRowMove/test/manualRowMoveUI.e2e.js": 142,
	"./manualRowResize/test/manualRowResize.e2e.js": 143,
	"./mergeCells/test/canMergeRange.e2e.js": 144,
	"./observeChanges/test/observeChanges.e2e.js": 145,
	"./persistentState/test/persistentState.e2e.js": 146,
	"./search/test/search.e2e.js": 147,
	"./undoRedo/test/UndoRedo.e2e.js": 148
};
function webpackContext(req) {
	return __webpack_require__(webpackContextResolve(req));
};
function webpackContextResolve(req) {
	var id = map[req];
	if(!(id + 1)) // check for number or string
		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 = 123;

/***/ }),
/* 124 */
/***/ (function(module, exports, __webpack_require__) {

var map = {
	"./ColHeader.spec.js": 149,
	"./Core_alter.spec.js": 150,
	"./Core_beforeKeyDown.spec.js": 151,
	"./Core_beforechange.spec.js": 152,
	"./Core_copy.spec.js": 153,
	"./Core_count.spec.js": 154,
	"./Core_dataSchema.spec.js": 155,
	"./Core_datachange.spec.js": 156,
	"./Core_destroy.spec.js": 157,
	"./Core_destroyEditor.spec.js": 158,
	"./Core_getCellMeta.spec.js": 159,
	"./Core_getColHeader.spec.js": 160,
	"./Core_getDataAt.spec.js": 161,
	"./Core_getDataType.spec.js": 162,
	"./Core_getRowHeader.spec.js": 163,
	"./Core_init.spec.js": 164,
	"./Core_isEmpty.spec.js": 165,
	"./Core_keepEmptyRows.spec.js": 166,
	"./Core_listen.spec.js": 167,
	"./Core_loadData.spec.js": 168,
	"./Core_navigation.spec.js": 169,
	"./Core_onKeyDown.spec.js": 170,
	"./Core_paste.spec.js": 171,
	"./Core_populateFromArray.spec.js": 172,
	"./Core_reCreate.spec.js": 173,
	"./Core_removeCellMeta.spec.js": 174,
	"./Core_render.spec.js": 175,
	"./Core_selection.spec.js": 176,
	"./Core_setDataAtCell.spec.js": 177,
	"./Core_splice.spec.js": 178,
	"./Core_update.spec.js": 179,
	"./Core_validate.spec.js": 180,
	"./Core_view.spec.js": 181,
	"./Dom.spec.js": 182,
	"./FillHandle.spec.js": 183,
	"./Performance.spec.js": 184,
	"./PluginHooks.spec.js": 185,
	"./RowHeader.spec.js": 186,
	"./cellTypes/index.spec.js": 187,
	"./core/colToProp.spec.js": 188,
	"./core/countSourceCols.spec.js": 189,
	"./core/getCellMetaAtRow.spec.js": 190,
	"./core/getCellsMeta.spec.js": 191,
	"./core/getCopyableData.spec.js": 192,
	"./core/getCopyableText.spec.js": 193,
	"./core/getSourceDataArray.spec.js": 194,
	"./core/getSourceDataAtCell.spec.js": 195,
	"./core/propToCol.spec.js": 196,
	"./core/setCellMeta.spec.js": 197,
	"./core/spliceCellsMeta.spec.js": 198,
	"./core/spliceCol.spec.js": 199,
	"./core/spliceRow.spec.js": 200,
	"./core/toPhysicalColumn.spec.js": 201,
	"./core/toPhysicalRow.spec.js": 202,
	"./core/toVisualColumn.spec.js": 203,
	"./core/toVisualRow.spec.js": 204,
	"./editors/autocompleteEditor.spec.js": 205,
	"./editors/baseEditor.spec.js": 206,
	"./editors/dateEditor.spec.js": 207,
	"./editors/dropdownEditor.spec.js": 208,
	"./editors/handsontableEditor.spec.js": 209,
	"./editors/index.spec.js": 210,
	"./editors/noEditor.spec.js": 211,
	"./editors/numericEditor.spec.js": 212,
	"./editors/passwordEditor.spec.js": 213,
	"./editors/selectEditor.spec.js": 214,
	"./editors/textEditor.spec.js": 215,
	"./publicAPI.spec.js": 217,
	"./renderers/autocompleteRenderer.spec.js": 218,
	"./renderers/cellDecorator.spec.js": 219,
	"./renderers/checkboxRenderer.spec.js": 220,
	"./renderers/htmlRenderer.spec.js": 221,
	"./renderers/index.spec.js": 222,
	"./renderers/numericRenderer.spec.js": 223,
	"./renderers/passwordRenderer.spec.js": 224,
	"./renderers/textRenderer.spec.js": 225,
	"./settings/colWidths.spec.js": 226,
	"./settings/columns.spec.js": 227,
	"./settings/copyable.spec.js": 228,
	"./settings/currentHeaderClassName.spec.js": 229,
	"./settings/currentRowClassName.spec.js": 230,
	"./settings/editor.spec.js": 231,
	"./settings/fixedColumnsLeft.spec.js": 232,
	"./settings/fixedRowsTop.spec.js": 233,
	"./settings/fragmentSelection.spec.js": 234,
	"./settings/maxCols.spec.js": 235,
	"./settings/maxRows.spec.js": 236,
	"./settings/renderer.spec.js": 237,
	"./settings/tableClassName.spec.js": 238,
	"./utils/ghostTable.spec.js": 239,
	"./validators/autocompleteValidator.spec.js": 240,
	"./validators/dateValidator.spec.js": 241,
	"./validators/index.spec.js": 242,
	"./validators/numericValidator.spec.js": 243,
	"./validators/timeValidator.spec.js": 244
};
function webpackContext(req) {
	return __webpack_require__(webpackContextResolve(req));
};
function webpackContextResolve(req) {
	var id = map[req];
	if(!(id + 1)) // check for number or string
		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 = 124;

/***/ }),
/* 125 */,
/* 126 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

describe('AutoColumnSize', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  var arrayOfObjects = function arrayOfObjects() {
    return [{ id: 'Short', name: 'Somewhat long', lastName: 'The very very very longest one', nestedData: [{ id: 1000 }] }];
  };

  it('should apply auto size by default', function () {
    handsontable({
      data: arrayOfObjects()
    });

    var width0 = colWidth(this.$container, 0);
    var width1 = colWidth(this.$container, 1);
    var width2 = colWidth(this.$container, 2);

    expect(width0).toBeLessThan(width1);
    expect(width1).toBeLessThan(width2);
  });

  it('should update column width after update value in cell (array of objects)', function () {
    handsontable({
      data: arrayOfObjects(),
      autoColumnSize: true,
      columns: [{ data: 'id' }, { data: 'name' }, { data: 'lastName' }]
    });

    expect(colWidth(this.$container, 0)).toBeAroundValue(50, 3);
    expect([117, 120, 121, 129, 135]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 1)]));
    expect([216, 229, 247, 260]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 2)]));

    setDataAtRowProp(0, 'id', 'foo bar foo bar foo bar');
    setDataAtRowProp(0, 'name', 'foo');

    expect([165, 168, 169, 189, 191]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 0)]));
    expect(colWidth(this.$container, 1)).toBeAroundValue(50, 3);
    expect([216, 229, 247, 260]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 2)]));
  });

  it('should correctly detect column widths with colHeaders', function () {
    handsontable({
      data: arrayOfObjects(),
      autoColumnSize: true,
      colHeaders: ['Identifier Longer text'],
      columns: [{ data: 'id' }, { data: 'name' }]
    });

    expect([149, 155, 174, 178]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 0)]));
  });

  it('should correctly detect column widths after update colHeaders when headers were passed as an array', function () {
    handsontable({
      data: arrayOfObjects(),
      autoColumnSize: true,
      colHeaders: true,
      columns: [{ data: 'id' }, { data: 'name' }]
    });

    expect([50, 51, 53]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 0)]));

    updateSettings({ colHeaders: ['Identifier Longer text', 'Identifier Longer and longer text'] });

    expect([149, 155, 174, 178]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 0)]));
    expect([226, 235, 263, 270]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 1)]));
  });

  it('should correctly detect column widths after update colHeaders when headers were passed as a string', function () {
    handsontable({
      data: arrayOfObjects(),
      autoColumnSize: true,
      colHeaders: true,
      columns: [{ data: 'id' }, { data: 'name' }]
    });

    expect([50, 51, 53]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 0)]));

    updateSettings({ colHeaders: 'Identifier Longer text' });

    expect([149, 155, 174, 178]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 0)]));
    expect([149, 155, 174, 178]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 1)]));
  });

  it('should correctly detect column widths after update colHeaders when headers were passed as a function', function () {
    handsontable({
      data: arrayOfObjects(),
      autoColumnSize: true,
      colHeaders: true,
      columns: [{ data: 'id' }, { data: 'name' }]
    });

    expect([50, 51, 53]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 0)]));

    updateSettings({
      colHeaders: function colHeaders(index) {
        return index === 0 ? 'Identifier Longer text' : 'Identifier Longer and longer text';
      }
    });

    expect([149, 155, 174, 178]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 0)]));
    expect([226, 235, 263, 270]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 1)]));
  });

  it('should correctly detect column width with colHeaders and the useHeaders option set to false (not taking the header widths into calculation)', function () {
    handsontable({
      data: [{ id: 'ab' }],
      autoColumnSize: {
        useHeaders: false
      },
      colHeaders: ['Identifier'],
      columns: [{ data: 'id' }]
    });

    expect(colWidth(this.$container, 0)).toBe(50);
  });

  it('should correctly detect column width with columns.title', function () {
    handsontable({
      data: arrayOfObjects(),
      autoColumnSize: true,
      columns: [{ data: 'id', title: 'Identifier' }]
    });

    expect([68, 70, 71, 80, 82]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 0)]));
  });

  it('should correctly detect column widths after update columns.title', function () {
    handsontable({
      data: arrayOfObjects(),
      autoColumnSize: true,
      columns: [{ data: 'id', title: 'Identifier' }]
    });

    updateSettings({
      columns: [{ data: 'id', title: 'Identifier with longer text' }]
    });

    expect([174, 182, 183, 208, 213]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 0)]));
  });

  // https://github.com/handsontable/handsontable/issues/2684
  it('should correctly detect column width when table is hidden on init (display: none)', _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
    var hot;
    return regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            spec().$container.css('display', 'none');
            hot = handsontable({
              data: arrayOfObjects(),
              autoColumnSize: true,
              colHeaders: ['Identifier', 'First Name']
            });
            _context.next = 4;
            return sleep(200);

          case 4:

            spec().$container.css('display', 'block');
            hot.render();

            expect([68, 70, 71, 80, 82]).toEqual(jasmine.arrayContaining([colWidth(spec().$container, 0)]));

          case 7:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, undefined);
  })));

  it('should keep last columns width unchanged if all rows was removed', function () {
    var hot = handsontable({
      data: arrayOfObjects(),
      autoColumnSize: true,
      columns: [{ data: 'id', title: 'Identifier' }, { data: 'name', title: 'Name' }, { data: 'lastName', title: 'Last Name' }]
    });

    expect([68, 70, 71, 80, 82]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 0)]));
    expect([117, 120, 121, 129, 135]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 1)]));
    expect([216, 229, 247, 260]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 2)]));

    hot.alter('remove_row', 0);

    expect([68, 70, 71, 80, 82]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 0)]));
    expect([117, 120, 121, 129, 135]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 1)]));
    expect([216, 229, 247, 260]).toEqual(jasmine.arrayContaining([colWidth(this.$container, 2)]));
  });

  it('should be possible to disable plugin using updateSettings', function () {
    handsontable({
      data: arrayOfObjects()
    });

    var width0 = colWidth(this.$container, 0);
    var width1 = colWidth(this.$container, 1);
    var width2 = colWidth(this.$container, 2);

    expect(width0).toBeLessThan(width1);
    expect(width1).toBeLessThan(width2);

    updateSettings({
      autoColumnSize: false
    });

    width0 = colWidth(this.$container, 0);
    width1 = colWidth(this.$container, 1);
    width2 = colWidth(this.$container, 2);

    expect(width0).toEqual(width1);
    expect(width0).toEqual(width2);
    expect(width1).toEqual(width2);
  });

  it('should apply disabling/enabling plugin using updateSettings, only to a particular HOT instance', function () {
    this.$container2 = $('<div id="' + id + '-2"></div>').appendTo('body');

    handsontable({
      data: arrayOfObjects()
    });

    this.$container2.handsontable({
      data: arrayOfObjects()
    });

    var widths = {
      1: [],
      2: []
    };

    widths[1][0] = colWidth(this.$container, 0);
    widths[1][1] = colWidth(this.$container, 1);
    widths[1][2] = colWidth(this.$container, 2);

    widths[2][0] = colWidth(this.$container2, 0);
    widths[2][1] = colWidth(this.$container2, 1);
    widths[2][2] = colWidth(this.$container2, 2);

    expect(widths[1][0]).toBeLessThan(widths[1][1]);
    expect(widths[1][1]).toBeLessThan(widths[1][2]);

    expect(widths[2][0]).toBeLessThan(widths[2][1]);
    expect(widths[2][1]).toBeLessThan(widths[2][2]);

    updateSettings({
      autoColumnSize: false
    });

    widths[1][0] = colWidth(this.$container, 0);
    widths[1][1] = colWidth(this.$container, 1);
    widths[1][2] = colWidth(this.$container, 2);

    widths[2][0] = colWidth(this.$container2, 0);
    widths[2][1] = colWidth(this.$container2, 1);
    widths[2][2] = colWidth(this.$container2, 2);

    expect(widths[1][0]).toEqual(widths[1][1]);
    expect(widths[1][0]).toEqual(widths[1][2]);
    expect(widths[1][1]).toEqual(widths[1][2]);

    expect(widths[2][0]).toBeLessThan(widths[2][1]);
    expect(widths[2][1]).toBeLessThan(widths[2][2]);

    this.$container2.handsontable('destroy');
    this.$container2.remove();
  });

  it('should be possible to enable plugin using updateSettings', function () {
    handsontable({
      data: arrayOfObjects(),
      autoColumnSize: false
    });

    var width0 = colWidth(this.$container, 0);
    var width1 = colWidth(this.$container, 1);
    var width2 = colWidth(this.$container, 2);

    expect(width0).toEqual(width1);
    expect(width0).toEqual(width2);
    expect(width1).toEqual(width2);

    updateSettings({
      autoColumnSize: true
    });

    width0 = colWidth(this.$container, 0);
    width1 = colWidth(this.$container, 1);
    width2 = colWidth(this.$container, 2);

    expect(width0).toBeLessThan(width1);
    expect(width1).toBeLessThan(width2);
  });

  it('should consider CSS style of each instance separately', function () {
    var $style = $('<style>.big .htCore td {font-size: 40px; line-height: 1.1;}</style>').appendTo('head');
    var $container1 = $('<div id="hot1"></div>').appendTo('body').handsontable({
      data: arrayOfObjects()
    });
    var $container2 = $('<div id="hot2"></div>').appendTo('body').handsontable({
      data: arrayOfObjects()
    });
    var hot1 = $container1.handsontable('getInstance');
    var hot2 = $container2.handsontable('getInstance');

    expect(colWidth($container1, 0)).toEqual(colWidth($container2, 0));

    $container1.addClass('big');
    hot1.render();
    hot2.render();
    expect(colWidth($container1, 0)).toBeGreaterThan(colWidth($container2, 0));

    $container1.removeClass('big').handsontable('render');
    $container2.addClass('big').handsontable('render');
    expect(colWidth($container1, 0)).toBeLessThan(colWidth($container2, 0));

    $style.remove();
    $container1.handsontable('destroy');
    $container1.remove();
    $container2.handsontable('destroy');
    $container2.remove();
  });

  it('should consider CSS class of the <table> element (e.g. when used with Bootstrap)', function () {
    var $style = $('<style>.htCore.big-table td {font-size: 32px}</style>').appendTo('head');

    handsontable({
      data: arrayOfObjects(),
      autoColumnSize: true
    });

    var width = colWidth(this.$container, 0);

    this.$container.find('table').addClass('big-table');
    render();
    expect(colWidth(this.$container, 0)).toBeGreaterThan(width);

    $style.remove();
  });

  it('should destroy temporary element', function () {
    handsontable({
      autoColumnSize: true
    });

    expect(document.querySelector('.htAutoSize')).toBe(null);
  });

  it('should not trigger autoColumnSize when column width is defined (through colWidths)', function () {
    handsontable({
      data: arrayOfObjects(),
      autoColumnSize: true,
      colWidths: [70, 70, 70],
      width: 500,
      height: 100,
      rowHeaders: true
    });

    setDataAtCell(0, 0, 'LongLongLongLong');

    expect(colWidth(this.$container, 0)).toBe(70);
  });

  it('should not trigger autoColumnSize when column width is defined (through columns.width)', function () {
    handsontable({
      data: arrayOfObjects(),
      autoColumnSize: true,
      colWidth: 77,
      columns: [{ width: 70 }, { width: 70 }, { width: 70 }],
      width: 500,
      height: 100,
      rowHeaders: true
    });

    setDataAtCell(0, 0, 'LongLongLongLong');

    expect(colWidth(this.$container, 0)).toBe(70);
  });

  it('should consider renderer that uses conditional formatting for specific row & column index', function () {
    var data = arrayOfObjects();
    data.push({ id: '2', name: 'Rocket Man', lastName: 'In a tin can' });
    handsontable({
      data: data,
      columns: [{ data: 'id' }, { data: 'name' }],
      autoColumnSize: true,
      renderer: function renderer(instance, td, row, col, prop, value, cellProperties) {
        // taken from demo/renderers.html
        Handsontable.renderers.TextRenderer.apply(this, arguments);
        if (row === 1 && col === 0) {
          td.style.padding = '100px';
        }
      }
    });

    expect(colWidth(this.$container, 0)).toBeGreaterThan(colWidth(this.$container, 1));
  });

  it('should\'t serialize value if it is array (nested data sources)', function () {
    var spy = jasmine.createSpy('renderer');

    handsontable({
      data: arrayOfObjects(),
      autoColumnSize: true,
      columns: [{ data: 'nestedData' }],
      renderer: spy
    });

    expect(spy.calls.mostRecent().args[5]).toEqual([{ id: 1000 }]);
  });
});

/***/ }),
/* 127 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('AutoRowSize', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  function arrayOfObjects() {
    return [{ id: 'Short' }, { id: 'Somewhat\nlong' }, { id: 'The\nvery\nvery\nvery\nlongest one' }];
  }
  function arrayOfObjects2() {
    return [{ id: 'Short', name: 'Somewhat long' }, { id: 'Somewhat long', name: 'The very very longest one' }, { id: 'The very very very longest one', name: 'Short' }];
  }

  it('should apply auto size by default', function () {
    handsontable({
      data: arrayOfObjects()
    });

    var height0 = rowHeight(this.$container, 0);
    var height1 = rowHeight(this.$container, 1);
    var height2 = rowHeight(this.$container, 2);

    expect(height0).toBeLessThan(height1);
    expect(height1).toBeLessThan(height2);
  });

  it('should draw scrollbar correctly (proper height) after calculation when autoRowSize option is set (long text in row) #4000', function (done) {
    var row = ['This is very long text which will break this cell text into two lines'];
    var data = [];
    var nrOfRows = 200;
    var columnWidth = 100;

    for (var i = 0; i < nrOfRows; i += 1) {
      data.push(row);
    }

    handsontable({
      data: data,
      colWidths: function colWidths() {
        return columnWidth;
      },

      autoRowSize: true
    });

    var oldHeight = spec().$container[0].scrollHeight;

    setTimeout(function () {
      var newHeight = spec().$container[0].scrollHeight;
      expect(oldHeight).toBeLessThan(newHeight);
      done();
    }, 200);
  });

  describe('should draw scrollbar correctly (proper height) after calculation when autoRowSize option is set (`table td` element height set by CSS) #4000', function () {
    var cellHeightInPx = 100;
    var nrOfRows = null;
    var nrOfColumns = 200,
        style;

    var SYNC_CALCULATION_LIMIT = Handsontable.plugins.AutoRowSize.SYNC_CALCULATION_LIMIT;
    var CALCULATION_STEP = Handsontable.plugins.AutoRowSize.CALCULATION_STEP;

    beforeEach(function () {
      if (!this.$container) {
        this.$container = $('<div id="' + id + '"></div>').appendTo('body');
      }

      var css = '.handsontable table td { height: ' + cellHeightInPx + 'px !important }',
          head = document.head;

      style = document.createElement('style');
      style.type = 'text/css';

      if (style.styleSheet) {
        style.styleSheet.cssText = css;
      } else {
        style.appendChild(document.createTextNode(css));
      }

      $(head).append(style);
    });

    afterEach(function () {
      if (this.$container) {
        destroy();
        this.$container.remove();
      }

      if (style) {
        $(style).remove();
      }
    });

    it('(SYNC_CALCULATION_LIMIT - 1 rows)', function (done) {
      nrOfRows = SYNC_CALCULATION_LIMIT - 1;

      handsontable({
        data: Handsontable.helper.createSpreadsheetData(nrOfRows, nrOfColumns),
        autoRowSize: true
      });

      setTimeout(function () {
        var newHeight = spec().$container[0].scrollHeight;

        expect(newHeight).toEqual((cellHeightInPx + 1) * nrOfRows + 1);
        done();
      }, 200);
    });

    it('(SYNC_CALCULATION_LIMIT + 1 rows)', function (done) {
      nrOfRows = SYNC_CALCULATION_LIMIT + 1;

      handsontable({
        data: Handsontable.helper.createSpreadsheetData(nrOfRows, nrOfColumns),
        autoRowSize: true
      });

      setTimeout(function () {
        var newHeight = spec().$container[0].scrollHeight;

        expect(newHeight).toEqual((cellHeightInPx + 1) * nrOfRows + 1);
        done();
      }, 200);
    });

    it('(SYNC_CALCULATION_LIMIT + CALCULATION_STEP - 1 rows)', function (done) {

      nrOfRows = SYNC_CALCULATION_LIMIT + CALCULATION_STEP - 1;

      handsontable({
        data: Handsontable.helper.createSpreadsheetData(nrOfRows, nrOfColumns),
        autoRowSize: true
      });

      setTimeout(function () {
        var newHeight = spec().$container[0].scrollHeight;

        expect(newHeight).toEqual((cellHeightInPx + 1) * nrOfRows + 1);
        done();
      }, 200);
    });

    it('(SYNC_CALCULATION_LIMIT + CALCULATION_STEP + 1 rows)', function (done) {

      nrOfRows = SYNC_CALCULATION_LIMIT + CALCULATION_STEP + 1;

      handsontable({
        data: Handsontable.helper.createSpreadsheetData(nrOfRows, nrOfColumns),
        autoRowSize: true
      });

      setTimeout(function () {
        var newHeight = spec().$container[0].scrollHeight;

        expect(newHeight).toEqual((cellHeightInPx + 1) * nrOfRows + 1);
        done();
      }, 200);
    });
  });

  it('should correctly detect row height when table is hidden on init (display: none)', function (done) {
    this.$container.css('display', 'none');
    var hot = handsontable({
      data: arrayOfObjects(),
      rowHeaders: true,
      autoRowSize: true
    });

    setTimeout(function () {
      spec().$container.css('display', 'block');
      hot.render();

      expect(rowHeight(spec().$container, 0)).toBe(24);
      expect(rowHeight(spec().$container, 1)).toBe(43);
      expect([106, 127]).toEqual(jasmine.arrayContaining([rowHeight(spec().$container, 2)]));
      done();
    }, 200);
  });

  it('should be possible to disable plugin using updateSettings', function () {
    var hot = handsontable({
      data: arrayOfObjects()
    });

    var height0 = rowHeight(this.$container, 0);
    var height1 = rowHeight(this.$container, 1);
    var height2 = rowHeight(this.$container, 2);

    expect(height0).toBeLessThan(height1);
    expect(height1).toBeLessThan(height2);

    updateSettings({
      autoRowSize: false
    });
    hot.setDataAtCell(0, 0, 'A\nB\nC');

    var height4 = rowHeight(this.$container, 0);

    expect(height4).toBeGreaterThan(height0);
  });

  it('should be possible to enable plugin using updateSettings', function () {
    handsontable({
      data: arrayOfObjects(),
      autoRowSize: false
    });

    var height0 = parseInt(getCell(0, 0).style.height, 10);
    var height1 = parseInt(getCell(1, 0).style.height, 10);
    var height2 = parseInt(getCell(2, 0).style.height, 10);

    expect(height0).toEqual(height1);
    expect(height0).toEqual(height2);
    expect(height1).toEqual(height2);

    updateSettings({
      autoRowSize: true
    });

    height0 = parseInt(getCell(0, 0).style.height, 10);
    height1 = parseInt(getCell(1, 0).style.height, 10);
    height2 = parseInt(getCell(2, 0).style.height, 10);

    expect(height0).toBeLessThan(height1);
    expect(height1).toBeLessThan(height2);
  });

  it('should consider CSS style of each instance separately', function () {
    var $style = $('<style>.big .htCore td {font-size: 40px;line-height: 1.1}</style>').appendTo('head');
    var $container1 = $('<div id="hot1"></div>').appendTo('body').handsontable({
      data: arrayOfObjects(),
      autoRowSize: true
    });
    var $container2 = $('<div id="hot2"></div>').appendTo('body').handsontable({
      data: arrayOfObjects(),
      autoRowSize: true
    });
    var hot1 = $container1.handsontable('getInstance');
    var hot2 = $container2.handsontable('getInstance');

    expect(parseInt(hot1.getCell(0, 0).style.height, 10)).toEqual(parseInt(hot2.getCell(0, 0).style.height, 10));

    $container1.addClass('big');
    hot1.render();
    hot2.render();

    expect(parseInt(hot1.getCell(2, 0).style.height, 10)).toBeGreaterThan(parseInt(hot2.getCell(2, 0).style.height, 10));

    $container1.removeClass('big');
    hot1.render();
    $container2.addClass('big');
    hot2.render();

    expect(parseInt(hot1.getCell(2, 0).style.height, 10)).toBeLessThan(parseInt(hot2.getCell(2, 0).style.height, 10));

    $style.remove();
    $container1.handsontable('destroy');
    $container1.remove();
    $container2.handsontable('destroy');
    $container2.remove();
  });

  it('should consider CSS class of the <table> element (e.g. when used with Bootstrap)', function () {
    var $style = $('<style>.htCore.big-table td {font-size: 32px;line-height: 1.1}</style>').appendTo('head');

    var hot = handsontable({
      data: arrayOfObjects(),
      autoRowSize: true
    });
    var height = parseInt(hot.getCell(2, 0).style.height, 10);

    this.$container.find('table').addClass('big-table');
    hot.getPlugin('autoRowSize').clearCache();
    render();
    expect(parseInt(hot.getCell(2, 0).style.height, 10)).toBeGreaterThan(height);

    $style.remove();
  });

  it('should not trigger autoColumnSize when column width is defined (through colWidths)', function () {
    var hot = handsontable({
      data: arrayOfObjects(),
      autoRowSize: true,
      rowHeights: [70, 70, 70],
      width: 500,
      height: 100,
      rowHeaders: true
    });

    setDataAtCell(0, 0, 'LongLongLongLong');

    expect(parseInt(hot.getCell(0, -1).style.height, 10)).toBe(69); // -1px of cell border
  });

  // Currently columns.height is not supported
  xit('should not trigger autoRowSize when column height is defined (through columns.height)', function () {
    var hot = handsontable({
      data: arrayOfObjects(),
      autoRowSize: true,
      rowHeights: 77,
      columns: [{ height: 70 }, { height: 70 }, { height: 70 }],
      width: 500,
      height: 100,
      rowHeaders: true
    });

    setDataAtCell(0, 0, 'LongLongLongLong');

    expect(parseInt(hot.getCell(0, -1).style.height, 10)).toBe(69); // -1px of cell border
  });

  it('should consider renderer that uses conditional formatting for specific row & column index', function () {
    var data = arrayOfObjects();
    data.push({ id: '2', name: 'Rocket Man', lastName: 'In a tin can' });

    var hot = handsontable({
      data: data,
      columns: [{ data: 'id' }, { data: 'name' }],
      autoRowSize: true,
      renderer: function renderer(instance, td, row, col, prop, value, cellProperties) {
        // taken from demo/renderers.html
        Handsontable.renderers.TextRenderer.apply(this, arguments);

        if (row === 1 && col === 0) {
          td.style.padding = '100px';
        }
      }
    });

    expect(parseInt(hot.getCell(1, 0).style.height || 0, 10)).toBe(242);
  });

  it('should destroy temporary element', function () {
    handsontable({
      autoRowSize: true
    });

    expect(document.querySelector('.htAutoSize')).toBe(null);
  });

  it('should recalculate heights after column resize', function () {
    var hot = handsontable({
      data: arrayOfObjects2(),
      colWidths: 250,
      manualColumnResize: true,
      autoRowSize: true,
      rowHeaders: true,
      colHeaders: true
    });

    expect(parseInt(hot.getCell(0, -1).style.height, 10)).toBe(22); // -1px of cell border
    expect(parseInt(hot.getCell(1, -1).style.height, 10)).toBe(22); // -1px of cell border
    expect(parseInt(hot.getCell(2, -1).style.height, 10)).toBeInArray([22, 42]); // -1px of cell border

    resizeColumn.call(this, 1, 100);

    expect(parseInt(hot.getCell(0, -1).style.height, 10)).toBe(22);
    expect(parseInt(hot.getCell(1, -1).style.height, 10)).toBe(42);
    expect([63, 84]).toEqual(jasmine.arrayContaining([parseInt(hot.getCell(2, -1).style.height, 10)]));

    resizeColumn.call(this, 1, 50);

    expect(parseInt(hot.getCell(0, -1).style.height, 10)).toBe(22);
    expect(parseInt(hot.getCell(1, -1).style.height, 10)).toBe(42);
    expect(parseInt(hot.getCell(2, -1).style.height, 10)).toBe(126);

    resizeColumn.call(this, 1, 200);

    expect(parseInt(hot.getCell(0, -1).style.height, 10)).toBe(22);
    expect(parseInt(hot.getCell(1, -1).style.height, 10)).toBe(22);
    expect(parseInt(hot.getCell(2, -1).style.height, 10)).toBe(42);
  });

  it('should recalculate heights after column moved', function () {
    var hot = handsontable({
      data: arrayOfObjects2(),
      colWidths: [250, 50],
      manualColumnMove: true,
      autoRowSize: true,
      rowHeaders: true,
      colHeaders: true
    });

    var plugin = hot.getPlugin('manualColumnMove');

    expect(parseInt(hot.getCell(0, -1).style.height, 10)).toBe(42); // -1px of cell border
    expect(parseInt(hot.getCell(1, -1).style.height, 10)).toBe(105); // -1px of cell border
    expect(parseInt(hot.getCell(2, -1).style.height, 10)).toBeInArray([22, 42]); // -1px of cell border

    plugin.moveColumn(0, 2);
    hot.render();

    expect(parseInt(hot.getCell(0, -1).style.height, 10)).toBe(22);
    expect(parseInt(hot.getCell(1, -1).style.height, 10)).toBe(42);
    expect(parseInt(hot.getCell(2, -1).style.height, 10)).toBe(126);
  });

  it('should recalculate heights with manualRowResize when changing text to multiline', function () {
    var hot = handsontable({
      data: arrayOfObjects2(),
      colWidths: 250,
      manualRowResize: [23, 50],
      autoRowSize: true,
      rowHeaders: true,
      colHeaders: true
    });

    expect(parseInt(hot.getCell(0, -1).style.height, 10)).toBe(22); // -1px of cell border
    expect(parseInt(hot.getCell(1, -1).style.height, 10)).toBe(49); // -1px of cell border
    expect(parseInt(hot.getCell(2, -1).style.height, 10)).toBeInArray([22, 42]); // -1px of cell border

    hot.setDataAtCell(1, 0, 'A\nB\nC\nD\nE');

    expect(parseInt(hot.getCell(0, -1).style.height, 10)).toBe(22);
    expect(parseInt(hot.getCell(1, -1).style.height, 10)).toBe(105);
    expect(parseInt(hot.getCell(2, -1).style.height, 10)).toBeInArray([22, 42]);
  });

  it('should recalculate heights after moved row', function () {
    var hot = handsontable({
      data: arrayOfObjects2(),
      colWidths: 250,
      manualRowResize: [23, 50],
      manualRowMove: true,
      autoRowSize: true,
      rowHeaders: true,
      colHeaders: true
    });

    expect(parseInt(hot.getCell(0, -1).style.height, 10)).toBe(22); // -1px of cell border
    expect(parseInt(hot.getCell(1, -1).style.height, 10)).toBe(49); // -1px of cell border
    expect(parseInt(hot.getCell(2, -1).style.height, 10)).toBeInArray([22, 42]); // -1px of cell border

    var plugin = hot.getPlugin('manualRowMove');
    plugin.moveRow(1, 0);
    hot.render();

    expect(parseInt(hot.getCell(0, -1).style.height, 10)).toBe(49);
    expect(parseInt(hot.getCell(1, -1).style.height, 10)).toBe(22);
    expect(parseInt(hot.getCell(2, -1).style.height, 10)).toBeInArray([22, 42]); // -1px of cell border
  });

  it('should resize the column headers properly, according the their content sizes', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(30, 30),
      colHeaders: function colHeaders(index) {
        if (index === 22) {
          return 'a<br>much<br>longer<br>label';
        }
        return 'test';
      },

      autoRowSize: true,
      rowHeaders: true,
      width: 300,
      height: 300
    });

    expect(rowHeight(spec().$container, -1)).toBe(89);
  });
});

/***/ }),
/* 128 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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; };

describe('ColumnSorting', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '" style="overflow: auto; width: 300px; height: 200px;"></div>').appendTo('body');

    this.sortByColumn = function (columnIndex) {
      var element = this.$container.find('th span.columnSorting:eq(' + columnIndex + ')');

      element.simulate('mousedown');
      element.simulate('mouseup');
    };
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  var arrayOfObjects = function arrayOfObjects() {
    return [{ id: 1, name: 'Ted', lastName: 'Right' }, { id: 2, name: 'Frank', lastName: 'Honest' }, { id: 3, name: 'Joan', lastName: 'Well' }, { id: 4, name: 'Sid', lastName: 'Strong' }, { id: 5, name: 'Jane', lastName: 'Neat' }, { id: 6, name: 'Chuck', lastName: 'Jackson' }, { id: 7, name: 'Meg', lastName: 'Jansen' }, { id: 8, name: 'Rob', lastName: 'Norris' }, { id: 9, name: 'Sean', lastName: 'O\'Hara' }, { id: 10, name: 'Eve', lastName: 'Branson' }];
  };

  it('should sort table by first visible column', function () {
    var hot = handsontable({
      data: [[1, 9, 3, 4, 5, 6, 7, 8, 9], [9, 8, 7, 6, 5, 4, 3, 2, 1], [8, 7, 6, 5, 4, 3, 3, 1, 9], [0, 3, 0, 5, 6, 7, 8, 9, 1]],
      colHeaders: true,
      columnSorting: true
    });

    var htCore = getHtCore();

    expect(htCore.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
    expect(htCore.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('9');
    expect(htCore.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('3');
    expect(htCore.find('tbody tr:eq(0) td:eq(3)').text()).toEqual('4');

    this.sortByColumn(0);

    expect(htCore.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('0');
    expect(htCore.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('3');
    expect(htCore.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('0');
    expect(htCore.find('tbody tr:eq(0) td:eq(3)').text()).toEqual('5');
  });

  it('should apply stable sort function #3606', function () {
    var hot = handsontable({
      data: [['mercedes1', 'Mercedes', 'A 160', '01/14/2007'], ['citroen1', 'Citroen', 'C4 Coupe', '12/01/2007'], ['opel1', 'Opel', 'Astra', '02/02/2006'], ['bmw1', 'BMW', '320i Coupe', '07/24/2009'], ['citroen2', 'Citroen', 'C4 Coupe', '12/01/2012'], ['opel2', 'Opel', 'Astra', '02/02/2004'], ['mercedes2', 'Mercedes', 'A 160', '01/14/2008'], ['citroen3', 'Citroen', 'C4 Coupe', '12/01/2007'], ['mercedes3', 'Mercedes', 'A 160', '01/14/2009'], ['opel3', 'Opel', 'Astra', '02/02/2006'], ['bmw2', 'BMW', '320i Coupe', '07/24/2013'], ['bmw3', 'BMW', '320i Coupe', '07/24/2012']],
      columns: [{}, {}, {
        type: 'date',
        dateFormat: 'mm/dd/yy'
      }, {
        type: 'numeric'
      }],
      columnSorting: true
    });

    hot.sort(1, true); // ASC

    expect(hot.getDataAtCol(0)).toEqual(['bmw1', 'bmw2', 'bmw3', 'citroen1', 'citroen2', 'citroen3', 'mercedes1', 'mercedes2', 'mercedes3', 'opel1', 'opel2', 'opel3']);

    hot.sort(1, false); // DESC

    expect(hot.getDataAtCol(0)).toEqual(['opel1', 'opel2', 'opel3', 'mercedes1', 'mercedes2', 'mercedes3', 'citroen1', 'citroen2', 'citroen3', 'bmw1', 'bmw2', 'bmw3']);
  });

  it('should not throw error when trying run handsontable with columnSorting and autoRowSize in the same time.', function () {
    var errors = 0;

    try {
      handsontable({
        data: arrayOfObjects(),
        autoRowSize: true,
        columnSorting: true
      });
    } catch (e) {
      errors++;
    }

    expect(errors).toBe(0);
  });

  it('should sort numbers descending after 2 clicks on table header', function () {
    handsontable({
      data: arrayOfObjects(),
      colHeaders: true,
      columnSorting: true
    });

    this.sortByColumn(0);
    this.sortByColumn(0);

    expect(this.$container.find('tr td').first().html()).toEqual('10');
  });

  it('should remove specified row from sorted table and NOT sort the table again', function () {
    var hot = handsontable({
      data: [[1, 'B'], [3, 'D'], [2, 'A'], [0, 'C']],
      colHeaders: true,
      columnSorting: true
    });

    this.sortByColumn(0);

    var htCore = getHtCore();

    expect(htCore.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('0');
    expect(htCore.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('1');
    expect(htCore.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('2');
    expect(htCore.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('3');

    expect(htCore.find('tbody tr').length).toEqual(4);

    // Now if sort is launched, sorting ordered will be reversed
    hot.sortOrder = false;

    hot.alter('remove_row', 0);

    expect(htCore.find('tbody tr').length).toEqual(3);
    expect(htCore.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
    expect(htCore.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('2');
    expect(htCore.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('3');
  });

  it('should add an empty row to sorted table', function () {
    var hot = handsontable({
      data: [[1, 'B'], [0, 'A'], [3, 'D'], [2, 'C']],
      colHeaders: true,
      columnSorting: true
    });

    this.sortByColumn(0);

    var htCore = getHtCore();

    expect(htCore.find('tbody tr').length).toEqual(4);

    expect(htCore.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('0');
    expect(htCore.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('1');
    expect(htCore.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('2');
    expect(htCore.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('3');

    hot.alter('insert_row', 1, 2);

    expect(htCore.find('tbody tr').length).toEqual(6);
    expect(htCore.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('0');
    expect(htCore.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('');
    expect(htCore.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('');
    expect(htCore.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('1');
    expect(htCore.find('tbody tr:eq(4) td:eq(0)').text()).toEqual('2');
    expect(htCore.find('tbody tr:eq(5) td:eq(0)').text()).toEqual('3');
  });

  it('should add an empty row to sorted table at a given index', function () {
    var hot = handsontable({
      data: [[1, 'B'], [0, 'A'], [3, 'D'], [2, 'C']],
      colHeaders: true,
      columnSorting: true
    });

    var htCore = getHtCore();

    this.sortByColumn(0);

    expect(htCore.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('3');
    expect(htCore.find('tbody tr:eq(4) td:eq(0)').text()).toEqual('');

    hot.alter('insert_row', 2);

    expect(htCore.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('0');
    expect(htCore.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('1');

    expect(htCore.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('');
    expect(htCore.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('');
    expect(htCore.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('');

    expect(htCore.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('2');
  });

  it('should NOT sort the table after value update in sorted column', function () {
    var hot = handsontable({
      data: [[1, 'B'], [0, 'A'], [3, 'D'], [2, 'C']],
      colHeaders: true,
      columnSorting: true
    });

    var htCore = getHtCore();

    expect(htCore.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');

    this.sortByColumn(0);
    this.sortByColumn(0);

    expect(htCore.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('3');
    expect(htCore.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('2');

    hot.setDataAtCell(1, 0, 20);

    render();

    expect(htCore.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('3');
    expect(htCore.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('20');
  });

  it('defaultSort comparing function shouldn\'t change order when comparing empty string, null and undefined', function () {
    var hot = handsontable({});
    var defaultSort = hot.getPlugin('columnSorting').defaultSort;

    expect(defaultSort(false, {})(['key1', null], ['key2', null])).toEqual(0);
    expect(defaultSort(false, {})(['key1', ''], ['key2', ''])).toEqual(0);
    expect(defaultSort(false, {})(['key1', undefined], ['key2', undefined])).toEqual(0);

    expect(defaultSort(false, {})(['key1', ''], ['key2', null])).toEqual(0);
    expect(defaultSort(false, {})(['key1', null], ['key2', ''])).toEqual(0);

    expect(defaultSort(false, {})(['key1', ''], ['key2', undefined])).toEqual(0);
    expect(defaultSort(false, {})(['key1', undefined], ['key2', ''])).toEqual(0);

    expect(defaultSort(false, {})(['key1', null], ['key2', undefined])).toEqual(0);
    expect(defaultSort(false, {})(['key1', undefined], ['key2', null])).toEqual(0);
  });

  it('should place empty strings, null and undefined values at proper position (stability of default comparing function)', function () {
    var hot = handsontable({
      data: [[null, 'Ted Right'], [undefined, 'Jane Neat'], [null, 'Meg Jansen'], ['', 'Sean Hara'], ['', 'Eve Branson'], [6, 'Frank Honest'], [7, 'Joan Well'], [8, 'Sid Strong'], [9, 'Chuck Jackson'], [10, 'Rob Norris'], [11, 'Eve Well']],
      columnSorting: true
    });

    hot.sort(0, true); // ASC

    expect(hot.getDataAtCol(1)).toEqual(['Frank Honest', 'Joan Well', 'Sid Strong', 'Chuck Jackson', 'Rob Norris', 'Eve Well',
    // empty cells below
    'Ted Right', 'Jane Neat', 'Meg Jansen', 'Sean Hara', 'Eve Branson']);

    hot.sort(0, false); // DESC

    expect(hot.getDataAtCol(1)).toEqual(['Eve Well', 'Rob Norris', 'Chuck Jackson', 'Sid Strong', 'Joan Well', 'Frank Honest',
    // empty cells below
    'Ted Right', 'Jane Neat', 'Meg Jansen', 'Sean Hara', 'Eve Branson']);
  });

  it('should place empty strings, null and undefined values at proper position when `sortEmptyCells` option is enabled ' + '(API call, data type: default)', function () {
    var hot = handsontable({
      data: [[6, 'Frank Honest'], [null, 'Ted Right'], [7, 'Joan Well'], [8, 'Sid Strong'], [undefined, 'Jane Neat'], [9, 'Chuck Jackson'], [null, 'Meg Jansen'], [10, 'Rob Norris'], ['', 'Sean Hara'], ['', 'Eve Branson']],
      columnSorting: {
        sortEmptyCells: true
      }
    });

    hot.sort(0, true); // ASC

    expect(hot.getDataAtCol(1)).toEqual(['Ted Right', 'Jane Neat', 'Meg Jansen', 'Sean Hara', 'Eve Branson',
    // empty cells above
    'Frank Honest', 'Joan Well', 'Sid Strong', 'Chuck Jackson', 'Rob Norris']);

    hot.sort(0, false); // DESC

    expect(hot.getDataAtCol(1)).toEqual(['Rob Norris', 'Chuck Jackson', 'Sid Strong', 'Joan Well', 'Frank Honest',
    // empty cells below
    'Ted Right', 'Jane Neat', 'Meg Jansen', 'Sean Hara', 'Eve Branson']);
  });

  it('should place empty strings, null and undefined values at proper position when `sortEmptyCells` ' + 'option is enabled and `column` property of `columnSorting` option is set (data type: default)', function () {
    var hot = handsontable({
      data: [[6, 'Frank Honest'], [null, 'Ted Right'], [7, 'Joan Well'], [8, 'Sid Strong'], [undefined, 'Jane Neat'], [9, 'Chuck Jackson'], [null, 'Meg Jansen'], [10, 'Rob Norris'], ['', 'Sean Hara'], ['', 'Eve Branson']],
      columnSorting: {
        sortEmptyCells: true,
        sortOrder: true,
        column: 0
      }
    });

    // ASC

    expect(hot.getDataAtCol(1)).toEqual(['Ted Right', 'Jane Neat', 'Meg Jansen', 'Sean Hara', 'Eve Branson',
    // empty cells above
    'Frank Honest', 'Joan Well', 'Sid Strong', 'Chuck Jackson', 'Rob Norris']);

    if (this.$container) {
      destroy();
      this.$container.remove();
    }

    hot = handsontable({
      data: [[6, 'Frank Honest'], [null, 'Ted Right'], [7, 'Joan Well'], [8, 'Sid Strong'], [undefined, 'Jane Neat'], [9, 'Chuck Jackson'], [null, 'Meg Jansen'], [10, 'Rob Norris'], ['', 'Sean Hara'], ['', 'Eve Branson']],
      columnSorting: {
        sortEmptyCells: true,
        sortOrder: false,
        column: 0
      }
    });

    // DESC

    expect(hot.getDataAtCol(1)).toEqual(['Rob Norris', 'Chuck Jackson', 'Sid Strong', 'Joan Well', 'Frank Honest',
    // empty cells below
    'Ted Right', 'Jane Neat', 'Meg Jansen', 'Sean Hara', 'Eve Branson']);
  });

  it('should place empty strings, null and undefined values at proper position when `sortEmptyCells` ' + 'option is enabled and `column` property of `columnSorting` option is set (data type: numeric)', function () {
    var hot = handsontable({
      data: [[6, 'Frank Honest'], [null, 'Ted Right'], [7, 'Joan Well'], [8, 'Sid Strong'], [undefined, 'Jane Neat'], [9, 'Chuck Jackson'], [null, 'Meg Jansen'], [10, 'Rob Norris'], ['', 'Sean Hara'], ['', 'Eve Branson']],
      columns: [{
        type: 'numeric'
      }, {}],
      columnSorting: {
        sortEmptyCells: true,
        sortOrder: true,
        column: 0
      }
    });

    // ASC

    expect(hot.getDataAtCol(1)).toEqual(['Ted Right', 'Jane Neat', 'Meg Jansen', 'Sean Hara', 'Eve Branson',
    // empty cells above
    'Frank Honest', 'Joan Well', 'Sid Strong', 'Chuck Jackson', 'Rob Norris']);

    if (this.$container) {
      destroy();
      this.$container.remove();
    }

    hot = handsontable({
      data: [[6, 'Frank Honest'], [null, 'Ted Right'], [7, 'Joan Well'], [8, 'Sid Strong'], [undefined, 'Jane Neat'], [9, 'Chuck Jackson'], [null, 'Meg Jansen'], [10, 'Rob Norris'], ['', 'Sean Hara'], ['', 'Eve Branson']],
      columnSorting: {
        sortEmptyCells: true,
        sortOrder: false,
        column: 0
      }
    });

    // DESC

    expect(hot.getDataAtCol(1)).toEqual(['Rob Norris', 'Chuck Jackson', 'Sid Strong', 'Joan Well', 'Frank Honest',
    // empty cells below
    'Ted Right', 'Jane Neat', 'Meg Jansen', 'Sean Hara', 'Eve Branson']);
  });

  describe('data type: date', function () {
    it('dateSort comparing function shouldn\'t change order when comparing empty string, null and undefined', function () {
      var hot = handsontable({});
      var dateSort = hot.getPlugin('columnSorting').dateSort;

      expect(dateSort(false, {})(['key1', null], ['key2', null])).toEqual(0);
      expect(dateSort(false, {})(['key1', ''], ['key2', ''])).toEqual(0);
      expect(dateSort(false, {})(['key1', undefined], ['key2', undefined])).toEqual(0);

      expect(dateSort(false, {})(['key1', ''], ['key2', null])).toEqual(0);
      expect(dateSort(false, {})(['key1', null], ['key2', ''])).toEqual(0);

      expect(dateSort(false, {})(['key1', ''], ['key2', undefined])).toEqual(0);
      expect(dateSort(false, {})(['key1', undefined], ['key2', ''])).toEqual(0);

      expect(dateSort(false, {})(['key1', null], ['key2', undefined])).toEqual(0);
      expect(dateSort(false, {})(['key1', undefined], ['key2', null])).toEqual(0);
    });

    it('should place empty strings, null and undefined values at proper position when `sortEmptyCells` ' + 'option is enabled and `column` property of `columnSorting` option is set', function () {
      var hot = handsontable({
        data: [['Citroen1', 'C4 Coupe', null], ['Mercedes1', 'A 160', '12/01/2008'], ['Mercedes2', 'A 160', '01/14/2006'], ['Citroen2', 'C4 Coupe', undefined], ['Audi1', 'A4 Avant', '11/19/2011'], ['Opel1', 'Astra', '02/02/2004'], ['Citroen3', 'C4 Coupe', null], ['BMW1', '320i Coupe', '07/24/2011'], ['Citroen4', 'C4 Coupe', ''], ['Citroen5', 'C4 Coupe', '']],
        columns: [{}, {}, {
          type: 'date',
          dateFormat: 'MM/DD/YYYY'
        }],
        columnSorting: {
          sortEmptyCells: true,
          sortOrder: true,
          column: 2
        }
      });

      // ASC

      expect(hot.getDataAtCol(0)).toEqual(['Citroen1', 'Citroen2', 'Citroen3', 'Citroen4', 'Citroen5',
      // empty cells above
      'Opel1', 'Mercedes2', 'Mercedes1', 'BMW1', 'Audi1']);

      if (this.$container) {
        destroy();
        this.$container.remove();
      }

      hot = handsontable({
        data: [['Citroen1', 'C4 Coupe', null], ['Mercedes1', 'A 160', '12/01/2008'], ['Mercedes2', 'A 160', '01/14/2006'], ['Citroen2', 'C4 Coupe', undefined], ['Audi1', 'A4 Avant', '11/19/2011'], ['Opel1', 'Astra', '02/02/2004'], ['Citroen3', 'C4 Coupe', null], ['BMW1', '320i Coupe', '07/24/2011'], ['Citroen4', 'C4 Coupe', ''], ['Citroen5', 'C4 Coupe', '']],
        columns: [{}, {}, {
          type: 'date',
          dateFormat: 'MM/DD/YYYY'
        }],
        columnSorting: {
          sortEmptyCells: true,
          sortOrder: false,
          column: 2
        }
      });

      // DESC

      expect(hot.getDataAtCol(0)).toEqual(['Audi1', 'BMW1', 'Mercedes1', 'Mercedes2', 'Opel1',
      // empty cells below
      'Citroen1', 'Citroen2', 'Citroen3', 'Citroen4', 'Citroen5']);
    });

    it('should sort date columns (MM/DD/YYYY)', function () {
      var hot = handsontable({
        data: [['Mercedes', 'A 160', '01/14/2006', 6999.9999], ['Citroen', 'C4 Coupe', '12/01/2008', 8330], ['Audi', 'A4 Avant', '11/19/2011', 33900], ['Opel', 'Astra', '02/02/2004', 7000], ['BMW', '320i Coupe', '07/24/2011', 30500]],
        columns: [{}, {}, {
          type: 'date',
          dateFormat: 'MM/DD/YYYY'
        }, {
          type: 'numeric'
        }],
        colHeaders: true,
        columnSorting: true
      });

      hot.sort(2, true); // ASC

      expect(hot.getDataAtRow(0)).toEqual(['Opel', 'Astra', '02/02/2004', 7000]);
      expect(hot.getDataAtRow(1)).toEqual(['Mercedes', 'A 160', '01/14/2006', 6999.9999]);
      expect(hot.getDataAtRow(2)).toEqual(['Citroen', 'C4 Coupe', '12/01/2008', 8330]);
      expect(hot.getDataAtRow(3)).toEqual(['BMW', '320i Coupe', '07/24/2011', 30500]);
      expect(hot.getDataAtRow(4)).toEqual(['Audi', 'A4 Avant', '11/19/2011', 33900]);

      hot.sort(2, false); // DESC

      expect(hot.getDataAtRow(0)).toEqual(['Audi', 'A4 Avant', '11/19/2011', 33900]);
      expect(hot.getDataAtRow(1)).toEqual(['BMW', '320i Coupe', '07/24/2011', 30500]);
      expect(hot.getDataAtRow(2)).toEqual(['Citroen', 'C4 Coupe', '12/01/2008', 8330]);
      expect(hot.getDataAtRow(3)).toEqual(['Mercedes', 'A 160', '01/14/2006', 6999.9999]);
      expect(hot.getDataAtRow(4)).toEqual(['Opel', 'Astra', '02/02/2004', 7000]);
    });

    it('should sort date columns (DD/MM/YYYY)', function () {
      var hot = handsontable({
        data: [['Mercedes', 'A 160', '01/12/2012', 6999.9999], ['Citroen', 'C4 Coupe', '12/01/2013', 8330], ['Audi', 'A4 Avant', '11/10/2014', 33900], ['Opel', 'Astra', '02/02/2015', 7000], ['BMW', '320i Coupe', '07/02/2013', 30500]],
        columns: [{}, {}, {
          type: 'date',
          dateFormat: 'DD/MM/YYYY'
        }, {
          type: 'numeric'
        }],
        colHeaders: true,
        columnSorting: true
      });

      hot.sort(2, true); // ASC

      expect(hot.getDataAtRow(0)).toEqual(['Mercedes', 'A 160', '01/12/2012', 6999.9999]);
      expect(hot.getDataAtRow(1)).toEqual(['Citroen', 'C4 Coupe', '12/01/2013', 8330]);
      expect(hot.getDataAtRow(2)).toEqual(['BMW', '320i Coupe', '07/02/2013', 30500]);
      expect(hot.getDataAtRow(3)).toEqual(['Audi', 'A4 Avant', '11/10/2014', 33900]);
      expect(hot.getDataAtRow(4)).toEqual(['Opel', 'Astra', '02/02/2015', 7000]);

      hot.sort(2, false); // DESC

      expect(hot.getDataAtRow(0)).toEqual(['Opel', 'Astra', '02/02/2015', 7000]);
      expect(hot.getDataAtRow(1)).toEqual(['Audi', 'A4 Avant', '11/10/2014', 33900]);
      expect(hot.getDataAtRow(2)).toEqual(['BMW', '320i Coupe', '07/02/2013', 30500]);
      expect(hot.getDataAtRow(3)).toEqual(['Citroen', 'C4 Coupe', '12/01/2013', 8330]);
      expect(hot.getDataAtRow(4)).toEqual(['Mercedes', 'A 160', '01/12/2012', 6999.9999]);
    });

    it('should sort date columns (MMMM Do YYYY)', function () {
      var hot = handsontable({
        data: [['Mercedes', 'A 160', 'October 28th 2016', 6999.9999], ['Citroen', 'C4 Coupe', 'October 27th 2001', 8330], ['Audi', 'A4 Avant', 'July 8th 1999', 33900], ['Opel', 'Astra', 'June 1st 2001', 7000], ['BMW', '320i Coupe', 'August 3rd 2001', 30500]],
        columns: [{}, {}, {
          type: 'date',
          dateFormat: 'MMMM Do YYYY'
        }, {
          type: 'numeric'
        }],
        colHeaders: true,
        columnSorting: true
      });

      hot.sort(2, true); // ASC

      expect(hot.getDataAtRow(0)).toEqual(['Audi', 'A4 Avant', 'July 8th 1999', 33900]);
      expect(hot.getDataAtRow(1)).toEqual(['Opel', 'Astra', 'June 1st 2001', 7000]);
      expect(hot.getDataAtRow(2)).toEqual(['BMW', '320i Coupe', 'August 3rd 2001', 30500]);
      expect(hot.getDataAtRow(3)).toEqual(['Citroen', 'C4 Coupe', 'October 27th 2001', 8330]);
      expect(hot.getDataAtRow(4)).toEqual(['Mercedes', 'A 160', 'October 28th 2016', 6999.9999]);

      hot.sort(2, false); // DESC

      expect(hot.getDataAtRow(0)).toEqual(['Mercedes', 'A 160', 'October 28th 2016', 6999.9999]);
      expect(hot.getDataAtRow(1)).toEqual(['Citroen', 'C4 Coupe', 'October 27th 2001', 8330]);
      expect(hot.getDataAtRow(2)).toEqual(['BMW', '320i Coupe', 'August 3rd 2001', 30500]);
      expect(hot.getDataAtRow(3)).toEqual(['Opel', 'Astra', 'June 1st 2001', 7000]);
      expect(hot.getDataAtRow(4)).toEqual(['Audi', 'A4 Avant', 'July 8th 1999', 33900]);
    });

    it('should sort date columns along with empty and null values', function () {
      var hot = handsontable({
        data: [['Mercedes', 'A 160', '01/14/2006', 6999.9999], ['Citroen', 'C4 Coupe', '12/01/2008', 8330], ['Citroen', 'C4 Coupe null', null, 8330], ['Citroen', 'C4 Coupe empty', '', 8330], ['Audi', 'A4 Avant', '11/19/2011', 33900], ['Opel', 'Astra', '02/02/2004', 7000], ['BMW', '320i Coupe', '07/24/2011', 30500]],
        columns: [{}, {}, {
          type: 'date',
          dateFormat: 'mm/dd/yy'
        }, {
          type: 'numeric'
        }],
        colHeaders: true,
        columnSorting: true
      });

      hot.sort(2, true); // ASC

      expect(hot.getDataAtRow(0)).toEqual(['Mercedes', 'A 160', '01/14/2006', 6999.9999]);
      expect(hot.getDataAtRow(1)).toEqual(['Opel', 'Astra', '02/02/2004', 7000]);
      expect(hot.getDataAtRow(2)).toEqual(['BMW', '320i Coupe', '07/24/2011', 30500]);
      expect(hot.getDataAtRow(3)).toEqual(['Audi', 'A4 Avant', '11/19/2011', 33900]);
      expect(hot.getDataAtRow(4)).toEqual(['Citroen', 'C4 Coupe', '12/01/2008', 8330]);

      hot.sort(2, false); // DESC

      expect(hot.getDataAtRow(0)).toEqual(['Citroen', 'C4 Coupe', '12/01/2008', 8330]);
      expect(hot.getDataAtRow(1)).toEqual(['Audi', 'A4 Avant', '11/19/2011', 33900]);
      expect(hot.getDataAtRow(2)).toEqual(['BMW', '320i Coupe', '07/24/2011', 30500]);
      expect(hot.getDataAtRow(3)).toEqual(['Opel', 'Astra', '02/02/2004', 7000]);
      expect(hot.getDataAtRow(4)).toEqual(['Mercedes', 'A 160', '01/14/2006', 6999.9999]);
    });
  });

  describe('data type: time', function () {
    it('should properly rewrite time into correct format after sort', function (done) {
      var hot = handsontable({
        data: [['0:00:01 am'], ['5:30:14 pm'], ['8:00:00 pm'], ['11:15:05 am'], ['4:07:48 am']],
        columns: [{
          type: 'time',
          dateFormat: 'h:mm:ss a',
          correctFormat: true
        }],
        colHeaders: true,
        columnSorting: {
          column: 0,
          sortOrder: false
        }
      });

      hot.setDataAtCell(0, 0, '19:55', 'edit');

      setTimeout(function () {
        expect(hot.getDataAtCell(0, 0)).toEqual('7:55:00 pm');
        done();
      }, 250);
    });
  });

  it('should properly sort numeric data', function () {
    var hot = handsontable({
      data: [['Mercedes', 'A 160', '01/14/2006', '6999.9999'], ['Citroen', 'C4 Coupe', '12/01/2008', 8330], ['Citroen', 'C4 Coupe null', null, '8330'], ['Citroen', 'C4 Coupe empty', '', 8333], ['Audi', 'A4 Avant', '11/19/2011', '33900'], ['Opel', 'Astra', '02/02/2004', '7000'], ['BMW', '320i Coupe', '07/24/2011', 30500]],
      columns: [{}, {}, {}, {
        type: 'numeric'
      }],
      colHeaders: true,
      columnSorting: true
    });

    var htCore = getHtCore();

    this.sortByColumn(3);

    expect(hot.getDataAtCol(3)).toEqual(['6999.9999', '7000', 8330, '8330', 8333, 30500, '33900']);

    this.sortByColumn(3);

    expect(hot.getDataAtCol(3)).toEqual(['33900', 30500, 8333, 8330, '8330', '7000', '6999.9999']);

    this.sortByColumn(3);

    expect(hot.getDataAtCol(3)).toEqual(['6999.9999', 8330, '8330', 8333, '33900', '7000', 30500]);
  });

  it('numericSort comparing function shouldn\'t change order when comparing empty string, null and undefined', function () {
    var hot = handsontable({});
    var numericSort = hot.getPlugin('columnSorting').numericSort;

    expect(numericSort(false, {})(['key1', null], ['key2', null])).toEqual(0);
    expect(numericSort(false, {})(['key1', ''], ['key2', ''])).toEqual(0);
    expect(numericSort(false, {})(['key1', undefined], ['key2', undefined])).toEqual(0);

    expect(numericSort(false, {})(['key1', ''], ['key2', null])).toEqual(0);
    expect(numericSort(false, {})(['key1', null], ['key2', ''])).toEqual(0);

    expect(numericSort(false, {})(['key1', ''], ['key2', undefined])).toEqual(0);
    expect(numericSort(false, {})(['key1', undefined], ['key2', ''])).toEqual(0);

    expect(numericSort(false, {})(['key1', null], ['key2', undefined])).toEqual(0);
    expect(numericSort(false, {})(['key1', undefined], ['key2', null])).toEqual(0);
  });

  it('should sort table with multiple row headers', function () {
    var hot = handsontable({
      data: [[1, 'B'], [0, 'D'], [3, 'A'], [2, 'C']],
      columns: [{}, {}, {
        type: 'date',
        dateFormat: 'mm/dd/yy'
      }, {
        type: 'numeric'
      }],
      colHeaders: true,
      columnSorting: true,
      removeRowPlugin: true // this plugin ads an extra row header, so now we have 2 instead of 1
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');

    this.sortByColumn(0); // sort by first column

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('0');

    expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('D');

    this.sortByColumn(1); // sort by second column

    expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('A');
  });

  it('should allow to define sorting column and order during initialization', function () {
    var hot = handsontable({
      data: [[1, 'B'], [0, 'D'], [3, 'A'], [2, 'C']],
      colHeaders: true,
      columnSorting: {
        column: 0,
        sortOrder: true
      }
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('0');
    expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('D');
  });

  it('should allow to change sorting column with updateSettings', function () {
    var hot = handsontable({
      data: [[1, 'B'], [0, 'D'], [3, 'A'], [2, 'C']],
      colHeaders: true,
      columnSorting: {
        column: 0,
        sortOrder: true
      }
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('0');
    expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('D');

    updateSettings({
      columnSorting: {
        column: 1,
        sortOrder: true
      }
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('3');
    expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('A');
  });

  it('should allow to change sorting order with updateSettings', function () {
    var hot = handsontable({
      data: [[1, 'B'], [0, 'D'], [3, 'A'], [2, 'C']],
      colHeaders: true,
      columnSorting: {
        column: 0,
        sortOrder: true
      }
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('0');

    updateSettings({
      columnSorting: {
        column: 0,
        sortOrder: false
      }
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('3');
  });

  it('should allow to change if sorting empty cells with updateSettings', function () {
    var hot = handsontable({
      data: [[1, 'B'], [2, ''], [3, 'A'], [4, ''], [6, 'E'], [7, ''], [8, 'F']],
      colHeaders: true,
      columnSorting: {
        column: 1,
        sortOrder: false,
        sortEmptyCells: false
      }
    });

    updateSettings({
      columnSorting: {
        column: 1,
        sortOrder: true,
        sortEmptyCells: true
      }
    });

    // ASC with empty cells sorting
    expect(hot.getDataAtCol(0)).toEqual([2, 4, 7, 3, 1, 6, 8]);

    updateSettings({
      columnSorting: {
        column: 1,
        sortOrder: true,
        sortEmptyCells: false
      }
    });

    // ASC without empty cells sorting
    expect(hot.getDataAtCol(0)).toEqual([3, 1, 6, 8, 2, 4, 7]);
  });

  it('should NOT sort spare rows', function () {
    var myData = [{ a: 'aaa', b: 2, c: 3 }, { a: 'z', b: 11, c: -4 }, { a: 'dddd', b: 13, c: 13 }, { a: 'bbbb', b: 10, c: 11 }];

    function customIsEmptyRow(row) {
      var data = this.getSourceData();
      return data[row].isNew;
    }

    handsontable({
      data: myData,
      rowHeaders: true,
      colHeaders: ['A', 'B', 'C'],
      columns: [{ data: 'a', type: 'text' }, { data: 'b', type: 'text' }, { data: 'c', type: 'text' }],
      dataSchema: { isNew: true, a: false }, // default for a to avoid #bad value#
      columnSorting: true,
      minSpareRows: 3,
      isEmptyRow: customIsEmptyRow
    });

    // ASC

    updateSettings({
      columnSorting: {
        column: 0,
        sortOrder: true
      }
    });

    expect(getData()).toEqual([['aaa', 2, 3], ['bbbb', 10, 11], ['dddd', 13, 13], ['z', 11, -4], [false, null, null], [false, null, null], [false, null, null]]);

    updateSettings({
      columnSorting: {
        column: 0,
        sortOrder: false
      }
    });

    expect(getData()).toEqual([['z', 11, -4], ['dddd', 13, 13], ['bbbb', 10, 11], ['aaa', 2, 3], [false, null, null], [false, null, null], [false, null, null]]);
  });

  it('should reset column sorting with updateSettings', function () {
    var hot = handsontable({
      data: [[1, 'B'], [0, 'D'], [3, 'A'], [2, 'C']],
      colHeaders: true,
      columnSorting: {
        column: 0,
        sortOrder: true
      }
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('0');

    updateSettings({
      columnSorting: void 0
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
  });

  it('should expose sort method when columnSorting is enabled', function () {
    var hot = handsontable();

    expect(hot.getSettings().columnSorting).toBeFalsy();
    expect(hot.sort).toBeUndefined();

    updateSettings({
      columnSorting: true
    });

    expect(hot.getSettings().columnSorting).toBe(true);
    expect(hot.sort).toBeDefined();
    expect(_typeof(hot.sort)).toBe('function');

    updateSettings({
      columnSorting: false
    });

    expect(hot.getSettings().columnSorting).toBeFalsy();
    expect(hot.sort).toBeUndefined();
  });

  it('should sort table using HOT.sort method', function () {
    var hot = handsontable({
      data: [[1, 'B'], [0, 'D'], [3, 'A'], [2, 'C']],
      columnSorting: true
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
    expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('0');
    expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('3');
    expect(this.$container.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('2');

    hot.sort(0, true);

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('0');
    expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('1');
    expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('2');
    expect(this.$container.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('3');
  });

  it('should reset column sorting with updateSettings', function () {
    var hot = handsontable({
      data: [[1, 'B'], [0, 'D'], [3, 'A'], [2, 'C']],
      colHeaders: true,
      columnSorting: {
        column: 0,
        sortOrder: true
      }
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('0');

    updateSettings({
      columnSorting: void 0
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
  });

  it('should fire beforeColumnSort event before sorting data', function () {
    var hot = handsontable({
      data: [[2], [4], [1], [3]],
      columnSorting: true
    });

    this.beforeColumnSortHandler = function () {
      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('2');
      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('4');
      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('3');
    };

    spyOn(this, 'beforeColumnSortHandler');

    hot.addHook('beforeColumnSort', this.beforeColumnSortHandler);

    var sortColumn = 0;
    var sortOrder = true;

    hot.sort(sortColumn, sortOrder);

    expect(this.beforeColumnSortHandler.calls.count()).toEqual(1);
    expect(this.beforeColumnSortHandler).toHaveBeenCalledWith(sortColumn, sortOrder, void 0, void 0, void 0, void 0);
  });

  it('should not sorting column when beforeColumnSort returns false', function (done) {
    var hot = handsontable({
      data: [[2], [4], [1], [3]],
      columnSorting: true,
      beforeColumnSort: function beforeColumnSort() {
        return false;
      }
    });

    hot.sort(0, true);

    setTimeout(function () {
      expect(spec().$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('2');
      expect(spec().$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('4');
      expect(spec().$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('1');
      expect(spec().$container.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('3');
      done();
    }, 200);
  });

  it('should add beforeColumnSort event listener in constructor', function () {
    var beforeColumnSortCallback = jasmine.createSpy('beforeColumnSortHandler');

    var hot = handsontable({
      data: [[2], [4], [1], [3]],
      columnSorting: true,
      beforeColumnSort: beforeColumnSortCallback
    });

    var sortColumn = 0;
    var sortOrder = true;

    hot.sort(sortColumn, sortOrder);

    expect(beforeColumnSortCallback.calls.count()).toEqual(1);
    expect(beforeColumnSortCallback).toHaveBeenCalledWith(sortColumn, sortOrder, void 0, void 0, void 0, void 0);
  });

  it('should fire afterColumnSort event before data has been sorted but before table render', function () {
    var hot = handsontable({
      data: [[2], [4], [1], [3]],
      columnSorting: true
    });
    var rendered = false;
    var afterColumnSortHandler = jasmine.createSpy('afterColumnSortHandler');
    var afterRenderSpy = jasmine.createSpy('afterRender');

    hot.addHook('afterColumnSort', function () {
      expect(rendered).toBe(false);
      afterColumnSortHandler.apply(afterColumnSortHandler, arguments);
    });
    hot.addHook('afterRender', function () {
      rendered = true;
      afterRenderSpy.apply(afterRenderSpy, arguments);
    });

    var sortColumn = 0;
    var sortOrder = true;
    afterRenderSpy.calls.reset();

    hot.sort(sortColumn, sortOrder);

    expect(afterColumnSortHandler.calls.count()).toBe(1);
    expect(afterColumnSortHandler).toHaveBeenCalledWith(sortColumn, sortOrder, void 0, void 0, void 0, void 0);
    expect(afterRenderSpy.calls.count()).toBe(1);
  });

  it('should add afterColumnSort event listener in constructor', function () {
    var afterColumnSortCallback = jasmine.createSpy('afterColumnSortHandler');

    var hot = handsontable({
      data: [[2], [4], [1], [3]],
      columnSorting: true,
      afterColumnSort: afterColumnSortCallback
    });

    var sortColumn = 0;
    var sortOrder = true;

    hot.sort(sortColumn, sortOrder);

    expect(afterColumnSortCallback.calls.count()).toEqual(1);
    expect(afterColumnSortCallback).toHaveBeenCalledWith(sortColumn, sortOrder, void 0, void 0, void 0, void 0);
  });

  it('should insert row when plugin is enabled, but table hasn\'t been sorted', function () {
    var hot = handsontable({
      data: [[1, 'B'], [0, 'D'], [3, 'A'], [2, 'C']],
      columnSorting: true
    });

    expect(countRows()).toEqual(4);
    expect(hot.sortColumn).toBeUndefined();

    alter('insert_row');

    expect(countRows()).toEqual(5);
  });

  it('should remove row when plugin is enabled, but table hasn\'t been sorted', function () {
    var hot = handsontable({
      data: [[1, 'B'], [0, 'D'], [3, 'A'], [2, 'C']],
      columnSorting: true
    });

    expect(countRows()).toEqual(4);
    expect(hot.sortColumn).toBeUndefined();

    alter('remove_row');

    expect(countRows()).toEqual(3);
  });

  it('should display new row added directly to dataSource, when observeChanges plugin is enabled', function (done) {
    var data = [[1, 'B'], [0, 'A'], [3, 'D'], [2, 'C']];

    var hot = handsontable({
      data: data,
      colHeaders: true,
      columnSorting: true,
      observeChanges: true
    });

    var htCore = getHtCore();

    expect(htCore.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
    expect(htCore.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('0');
    expect(htCore.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('3');
    expect(htCore.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('2');

    this.sortByColumn(0);

    expect(htCore.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('0');
    expect(htCore.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('1');
    expect(htCore.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('2');
    expect(htCore.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('3');

    expect(htCore.find('tbody tr').length).toEqual(4);

    var afterChangesObservedCallback = jasmine.createSpy('afterChangesObservedCallback');
    hot.addHook('afterChangesObserved', afterChangesObservedCallback);

    data.push([5, 'E']);

    setTimeout(function () {
      expect(countRows()).toEqual(5);
      expect(spec().$container.find('tbody tr:eq(4) td:eq(0)').text()).toEqual('5');
      expect(spec().$container.find('tbody tr:eq(4) td:eq(1)').text()).toEqual('E');
      done();
    }, 200);
  });

  it('should not display new row added directly to dataSource, when observeChanges plugin is explicitly disabled', function (done) {
    var data = [[1, 'B'], [0, 'A'], [3, 'D'], [2, 'C']];

    var hot = handsontable({
      data: data,
      colHeaders: true,
      columnSorting: true,
      observeChanges: false
    });

    var afterChangesObservedCallback = jasmine.createSpy('afterChangesObservedCallback');
    hot.addHook('afterChangesObserved', afterChangesObservedCallback);

    var htCore = getHtCore();

    expect(htCore.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
    expect(htCore.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('0');
    expect(htCore.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('3');
    expect(htCore.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('2');

    this.sortByColumn(0);

    expect(htCore.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('0');
    expect(htCore.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('1');
    expect(htCore.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('2');
    expect(htCore.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('3');
    expect(htCore.find('tbody tr').length).toEqual(4);

    data.push([5, 'E']);

    setTimeout(function () {
      expect(htCore.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('0');
      expect(htCore.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('1');
      expect(htCore.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('2');
      expect(htCore.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('3');
      expect(htCore.find('tbody tr').length).toEqual(4);
      expect(afterChangesObservedCallback).not.toHaveBeenCalled();
      done();
    }, 100);
  });

  it('should display new row added directly to dataSource, when observeChanges plugin status is undefined', function (done) {
    var data = [[1, 'B'], [0, 'A'], [3, 'D'], [2, 'C']];

    var onUpdateSettings = jasmine.createSpy('onUpdateSettings');

    var hot = handsontable({
      data: data,
      colHeaders: true,
      columnSorting: true,
      afterUpdateSettings: onUpdateSettings
    });

    var afterChangesObservedCallback = jasmine.createSpy('afterChangesObservedCallback');
    hot.addHook('afterChangesObserved', afterChangesObservedCallback);

    var htCore = getHtCore();

    // columnSorting enables observeChanges plugin by asynchronously invoking updateSettings
    setTimeout(function () {
      expect(htCore.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
      expect(htCore.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('0');
      expect(htCore.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('3');
      expect(htCore.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('2');

      spec().sortByColumn(0);

      expect(htCore.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('0');
      expect(htCore.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('1');
      expect(htCore.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('2');
      expect(htCore.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('3');
      expect(htCore.find('tbody tr').length).toEqual(4);

      data.push([5, 'E']);
    }, 100);

    setTimeout(function () {
      expect(countRows()).toEqual(5);
      expect(htCore.find('tbody tr:eq(4) td:eq(0)').text()).toEqual('5');
      expect(htCore.find('tbody tr:eq(4) td:eq(1)').text()).toEqual('E');
      done();
    }, 2000); // 2s delayed needs for safari env
  });

  it('should apply sorting when there are two tables and only one has sorting enabled and has been already sorted (#1020)', function () {
    var hot = handsontable({
      data: [[1, 'B'], [0, 'D'], [3, 'A'], [2, 'C']],
      columnSorting: {
        column: 1
      }
    });

    this.$container2 = $('<div id="' + id + '-2"></div>').appendTo('body');
    this.$container2.handsontable();
    var hot2 = this.$container2.handsontable('getInstance');

    selectCell(0, 1);
    keyDown('enter');
    expect($('.handsontableInput').val()).toEqual('A');

    this.$container2.handsontable('destroy');
    this.$container2.remove();
  });

  it('should reset sorting after loading new data', function () {
    var hot = handsontable({
      data: [[1, 'B'], [0, 'D'], [3, 'A'], [2, 'C']],
      columnSorting: true
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
    expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('0');
    expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('3');
    expect(this.$container.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('2');

    hot.sort(0, true);

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('0');
    expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('1');
    expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('2');
    expect(this.$container.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('3');

    loadData([[50, 'E'], [10, 'G'], [30, 'F'], [60, 'I'], [40, 'J'], [20, 'H']]);

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('50');
    expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('10');
    expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('30');
    expect(this.$container.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('60');
    expect(this.$container.find('tbody tr:eq(4) td:eq(0)').text()).toEqual('40');
    expect(this.$container.find('tbody tr:eq(5) td:eq(0)').text()).toEqual('20');
  });

  it('should reset sorting after loading new data (default sorting column and order set)', function () {
    var hot = handsontable({
      data: [[1, 'B'], [0, 'D'], [3, 'A'], [2, 'C']],
      columnSorting: {
        column: 1,
        sortOrder: true
      }
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('3');
    expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('1');
    expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('2');
    expect(this.$container.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('0');

    expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('A');
    expect(this.$container.find('tbody tr:eq(1) td:eq(1)').text()).toEqual('B');
    expect(this.$container.find('tbody tr:eq(2) td:eq(1)').text()).toEqual('C');
    expect(this.$container.find('tbody tr:eq(3) td:eq(1)').text()).toEqual('D');

    hot.sort(0, true);

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('0');
    expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('1');
    expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('2');
    expect(this.$container.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('3');

    loadData([[50, 'E'], [10, 'G'], [30, 'F'], [60, 'I'], [40, 'J'], [20, 'H']]);

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('50');
    expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('30');
    expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('10');
    expect(this.$container.find('tbody tr:eq(3) td:eq(0)').text()).toEqual('20');
    expect(this.$container.find('tbody tr:eq(4) td:eq(0)').text()).toEqual('60');
    expect(this.$container.find('tbody tr:eq(5) td:eq(0)').text()).toEqual('40');

    expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('E');
    expect(this.$container.find('tbody tr:eq(1) td:eq(1)').text()).toEqual('F');
    expect(this.$container.find('tbody tr:eq(2) td:eq(1)').text()).toEqual('G');
    expect(this.$container.find('tbody tr:eq(3) td:eq(1)').text()).toEqual('H');
    expect(this.$container.find('tbody tr:eq(4) td:eq(1)').text()).toEqual('I');
    expect(this.$container.find('tbody tr:eq(5) td:eq(1)').text()).toEqual('J');
  });

  it('should return updated data at specyfied row after sorted', function () {
    var hot = handsontable({
      data: [[1, 'Ted', 'Right'], [2, 'Frank', 'Honest'], [3, 'Joan', 'Well'], [4, 'Sid', 'Strong'], [5, 'Jane', 'Neat']],
      colHeaders: true,
      rowHeaders: true,
      columnSorting: true
    });

    this.sortByColumn(0);

    expect(getDataAtRow(0)).toEqual([1, 'Ted', 'Right']);
    expect(getDataAtRow(4)).toEqual([5, 'Jane', 'Neat']);

    this.sortByColumn(0);

    expect(getDataAtRow(0)).toEqual([5, 'Jane', 'Neat']);
    expect(getDataAtRow(4)).toEqual([1, 'Ted', 'Right']);

    this.sortByColumn(0);

    expect(getDataAtRow(0)).toEqual([1, 'Ted', 'Right']);
    expect(getDataAtRow(4)).toEqual([5, 'Jane', 'Neat']);
  });

  it('should return updated data at specyfied col after sorted', function () {
    var hot = handsontable({
      data: [[1, 'Ted', 'Right'], [2, 'Frank', 'Honest'], [3, 'Joan', 'Well'], [4, 'Sid', 'Strong'], [5, 'Jane', 'Neat']],
      colHeaders: true,
      rowHeaders: true,
      columnSorting: true
    });

    this.sortByColumn(0);

    expect(getDataAtCol(0)).toEqual([1, 2, 3, 4, 5]);
    expect(getDataAtCol(1)).toEqual(['Ted', 'Frank', 'Joan', 'Sid', 'Jane']);

    this.sortByColumn(0);

    expect(getDataAtCol(0)).toEqual([5, 4, 3, 2, 1]);
    expect(getDataAtCol(1)).toEqual(['Jane', 'Sid', 'Joan', 'Frank', 'Ted']);

    this.sortByColumn(0);

    expect(getDataAtCol(0)).toEqual([1, 2, 3, 4, 5]);
    expect(getDataAtCol(1)).toEqual(['Ted', 'Frank', 'Joan', 'Sid', 'Jane']);
  });

  it('should return original data source at specified row after sorted', function () {
    var hot = handsontable({
      data: [[1, 'Ted', 'Right'], [2, 'Frank', 'Honest'], [3, 'Joan', 'Well'], [4, 'Sid', 'Strong'], [5, 'Jane', 'Neat']],
      colHeaders: true,
      rowHeaders: true,
      columnSorting: true
    });

    this.sortByColumn(0);

    expect(getDataAtRow(0)).toEqual([1, 'Ted', 'Right']);
    expect(getDataAtRow(4)).toEqual([5, 'Jane', 'Neat']);

    expect(getSourceDataAtRow(0)).toEqual([1, 'Ted', 'Right']);
    expect(getSourceDataAtRow(4)).toEqual([5, 'Jane', 'Neat']);

    this.sortByColumn(0);

    expect(getDataAtRow(0)).toEqual([5, 'Jane', 'Neat']);
    expect(getDataAtRow(4)).toEqual([1, 'Ted', 'Right']);

    expect(getSourceDataAtRow(0)).toEqual([1, 'Ted', 'Right']);
    expect(getSourceDataAtRow(4)).toEqual([5, 'Jane', 'Neat']);
  });

  it('should return original data source at specified col after sorted', function () {
    var hot = handsontable({
      data: [[1, 'Ted', 'Right'], [2, 'Frank', 'Honest'], [3, 'Joan', 'Well'], [4, 'Sid', 'Strong'], [5, 'Jane', 'Neat']],
      colHeaders: true,
      rowHeaders: true,
      columnSorting: true
    });

    this.sortByColumn(0);

    expect(getDataAtCol(0)).toEqual([1, 2, 3, 4, 5]);
    expect(getDataAtCol(1)).toEqual(['Ted', 'Frank', 'Joan', 'Sid', 'Jane']);

    expect(getSourceDataAtCol(0)).toEqual([1, 2, 3, 4, 5]);
    expect(getSourceDataAtCol(1)).toEqual(['Ted', 'Frank', 'Joan', 'Sid', 'Jane']);

    this.sortByColumn(0);

    expect(getDataAtCol(0)).toEqual([5, 4, 3, 2, 1]);
    expect(getDataAtCol(1)).toEqual(['Jane', 'Sid', 'Joan', 'Frank', 'Ted']);

    expect(getSourceDataAtCol(0)).toEqual([1, 2, 3, 4, 5]);
    expect(getSourceDataAtCol(1)).toEqual(['Ted', 'Frank', 'Joan', 'Sid', 'Jane']);

    this.sortByColumn(0);

    expect(getDataAtCol(0)).toEqual([1, 2, 3, 4, 5]);
    expect(getDataAtCol(1)).toEqual(['Ted', 'Frank', 'Joan', 'Sid', 'Jane']);

    expect(getSourceDataAtCol(0)).toEqual([1, 2, 3, 4, 5]);
    expect(getSourceDataAtCol(1)).toEqual(['Ted', 'Frank', 'Joan', 'Sid', 'Jane']);
  });

  it('should ignore case when sorting', function () {
    var hot = handsontable({
      data: [[1, 'albuquerque'], [2, 'Alabama'], [3, 'Missouri']],
      colHeaders: true,
      columnSorting: true
    });

    this.sortByColumn(1);
    expect(getDataAtCol(0)).toEqual([2, 1, 3]);
    expect(getDataAtCol(1)).toEqual(['Alabama', 'albuquerque', 'Missouri']);

    this.sortByColumn(1);
    expect(getDataAtCol(0)).toEqual([3, 1, 2]);
    expect(getDataAtCol(1)).toEqual(['Missouri', 'albuquerque', 'Alabama']);
  });

  it('should push empty cells to the end of sorted column', function () {
    var hot = handsontable({
      data: [[1, 'Ted', 'Right'], [2, '', 'Honest'], [3, '', 'Well'], [4, 'Sid', 'Strong'], [5, 'Jane', 'Neat']],
      colHeaders: true,
      rowHeaders: true,
      columnSorting: true,
      minSpareRows: 1
    });

    this.sortByColumn(1);
    expect(getDataAtCol(0)).toEqual([5, 4, 1, 2, 3, null]);
    expect(getDataAtCol(1)).toEqual(['Jane', 'Sid', 'Ted', '', '', null]);

    this.sortByColumn(1);
    expect(getDataAtCol(0)).toEqual([1, 4, 5, 2, 3, null]);
    expect(getDataAtCol(1)).toEqual(['Ted', 'Sid', 'Jane', '', '', null]);
  });

  it('should push numeric values before non-numeric values, when sorting ascending using the default sorting function', function () {
    var hot = handsontable({
      data: [[1, 'Ted', 123], [2, '', 'Some'], [3, '', 321], [4, 'Sid', 'String'], [5, 'Jane', 46]],
      colHeaders: true,
      columnSorting: true
    });

    this.sortByColumn(2);
    expect(getDataAtCol(2)).toEqual([46, 123, 321, 'Some', 'String']);

    this.sortByColumn(2);
    expect(getDataAtCol(2)).toEqual(['String', 'Some', 321, 123, 46]);
  });

  it('should add a sorting indicator to the column header after it\'s been sorted, only if sortIndicator property is set to true', function () {
    var hot = handsontable({
      data: [[1, 'Ted', 'Right'], [2, '', 'Honest'], [3, '', 'Well'], [4, 'Sid', 'Strong'], [5, 'Jane', 'Neat']],
      colHeaders: true,
      columnSorting: true
    });

    this.sortByColumn(1);

    var sortedColumn = this.$container.find('th span.columnSorting')[1],
        afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');

    expect(afterValue === '' || afterValue === 'none').toBe(true);

    // ---------------------------------
    // INDICATOR SET FOR THE WHOLE TABLE
    // ---------------------------------

    hot.updateSettings({
      sortIndicator: true
    });

    this.sortByColumn(1);

    // descending (updateSettings doesn't reset sorting stack)
    sortedColumn = this.$container.find('th span.columnSorting')[1];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue.indexOf(String.fromCharCode(9660))).toBeGreaterThan(-1);

    this.sortByColumn(1);

    sortedColumn = this.$container.find('th span.columnSorting')[1];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue === '' || afterValue === 'none').toBe(true);

    this.sortByColumn(1);

    // ascending
    sortedColumn = this.$container.find('th span.columnSorting')[1];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');

    expect(afterValue.indexOf(String.fromCharCode(9650))).toBeGreaterThan(-1);

    // ---------------------------------
    // INDICATOR SET FOR A SINGLE COLUMN
    // ---------------------------------

    hot.updateSettings({
      sortIndicator: void 0,
      columns: [{}, {}, { sortIndicator: true }]
    });

    this.sortByColumn(0);

    sortedColumn = this.$container.find('th span.columnSorting')[0];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue === '' || afterValue === 'none').toBe(true);

    this.sortByColumn(1);

    // descending
    sortedColumn = this.$container.find('th span.columnSorting')[1];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue === '' || afterValue === 'none').toBe(true);

    this.sortByColumn(2);

    sortedColumn = this.$container.find('th span.columnSorting')[2];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue.indexOf(String.fromCharCode(9650))).toBeGreaterThan(-1);
  });

  it('should change sorting indicator state on every `hot.sort()` method call (continuously for the same column)', function () {
    var hot = handsontable({
      data: [[1, 'Ted', 'Right'], [2, '', 'Honest'], [3, '', 'Well'], [4, 'Sid', 'Strong'], [5, 'Jane', 'Neat']],
      colHeaders: true,
      columnSorting: true,
      sortIndicator: true
    });

    hot.sort(1);

    // ascending
    var sortedColumn = this.$container.find('th span.columnSorting')[1];
    var afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue.indexOf(String.fromCharCode(9650))).toBeGreaterThan(-1);

    hot.sort(1);

    // descending
    sortedColumn = this.$container.find('th span.columnSorting')[1];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue.indexOf(String.fromCharCode(9660))).toBeGreaterThan(-1);

    hot.sort(1);

    sortedColumn = this.$container.find('th span.columnSorting')[1];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue === '' || afterValue === 'none').toBe(true);

    hot.sort(1);

    // ascending
    sortedColumn = this.$container.find('th span.columnSorting')[1];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue.indexOf(String.fromCharCode(9650))).toBeGreaterThan(-1);

    hot.sort(1);

    // descending
    sortedColumn = this.$container.find('th span.columnSorting')[1];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue.indexOf(String.fromCharCode(9660))).toBeGreaterThan(-1);
  });

  it('should change sorting indicator state on every `hot.sort()` method (calling for different columns)', function () {
    var hot = handsontable({
      data: [[1, 'Ted', 'Right'], [2, '', 'Honest'], [3, '', 'Well'], [4, 'Sid', 'Strong'], [5, 'Jane', 'Neat']],
      colHeaders: true,
      columnSorting: true,
      sortIndicator: true
    });

    hot.sort(1);

    // ascending
    var sortedColumn = this.$container.find('th span.columnSorting')[1];
    var afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue.indexOf(String.fromCharCode(9650))).toBeGreaterThan(-1);

    hot.sort(2);

    // ascending
    sortedColumn = this.$container.find('th span.columnSorting')[2];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue.indexOf(String.fromCharCode(9650))).toBeGreaterThan(-1);

    hot.sort(1);

    // ascending
    sortedColumn = this.$container.find('th span.columnSorting')[1];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue.indexOf(String.fromCharCode(9650))).toBeGreaterThan(-1);

    hot.sort(2, false);

    // descending
    sortedColumn = this.$container.find('th span.columnSorting')[2];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue.indexOf(String.fromCharCode(9660))).toBeGreaterThan(-1);

    hot.sort(2, false);

    // descending
    sortedColumn = this.$container.find('th span.columnSorting')[2];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue.indexOf(String.fromCharCode(9660))).toBeGreaterThan(-1);

    hot.sort(2, true);

    // ascending
    sortedColumn = this.$container.find('th span.columnSorting')[2];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue.indexOf(String.fromCharCode(9650))).toBeGreaterThan(-1);
  });

  it('should change sorting indicator state when initial column sorting was provided', function () {
    var hot = handsontable({
      data: [[1, 'Ted', 'Right'], [2, '', 'Honest'], [3, '', 'Well'], [4, 'Sid', 'Strong'], [5, 'Jane', 'Neat']],
      colHeaders: true,
      columnSorting: {
        column: 1,
        sortOrder: false
      },
      sortIndicator: true
    });

    // descending
    var sortedColumn = this.$container.find('th span.columnSorting')[1];
    var afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue.indexOf(String.fromCharCode(9660))).toBeGreaterThan(-1);

    hot.sort(1);

    // default
    sortedColumn = this.$container.find('th span.columnSorting')[1];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue === '' || afterValue === 'none').toBe(true);

    hot.sort(1);

    // ascending
    sortedColumn = this.$container.find('th span.columnSorting')[1];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue.indexOf(String.fromCharCode(9650))).toBeGreaterThan(-1);

    hot.sort(1);

    // descending
    sortedColumn = this.$container.find('th span.columnSorting')[1];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue.indexOf(String.fromCharCode(9660))).toBeGreaterThan(-1);

    hot.sort(1);

    // default
    sortedColumn = this.$container.find('th span.columnSorting')[1];
    afterValue = window.getComputedStyle(sortedColumn, ':after').getPropertyValue('content');
    expect(afterValue === '' || afterValue === 'none').toBe(true);
  });

  it('should properly sort the table, when it\'s scrolled to the far right', function () {
    var data = [['Jasmine Ferguson', 'Britney Carey', 'Kelly Decker', 'Lacey Mcleod', 'Leona Shaffer', 'Kelli Ochoa', 'Adele Roberson', 'Viola Snow', 'Barron Cherry', 'Calhoun Lane', 'Elvia Andrews', 'Katheryn Dale', 'Dorthy Hale', 'Munoz Randall', 'Fields Morse', 'Hubbard Nichols', 'Chang Yang', 'Osborn Anthony', 'Owens Warner', 'Gloria Hampton'], ['Lane Hill', 'Belinda Mathews', 'York Gray', 'Celina Stone', 'Victoria Mays', 'Angelina Lott', 'Joyce Mason', 'Shawn Rodriguez', 'Susanna Mayo', 'Wolf Fuller', 'Long Hester', 'Dudley Doyle', 'Wilder Sutton', 'Oneal Avery', 'James Mclaughlin', 'Lenora Guzman', 'Mcmahon Sullivan', 'Abby Weeks', 'Beverly Joseph', 'Rosalind Church'], ['Myrtle Landry', 'Hays Huff', 'Hernandez Benjamin', 'Mclaughlin Garza', 'Franklin Barton', 'Lara Buchanan', 'Ratliff Beck', 'Rosario Munoz', 'Isabelle Dalton', 'Smith Woodard', 'Marjorie Marshall', 'Spears Stein', 'Brianna Bowman', 'Marci Clay', 'Palmer Harrell', 'Ball Levy', 'Shelley Mendoza', 'Morrow Glass', 'Baker Knox', 'Adrian Holman'], ['Trisha Howell', 'Brooke Harrison', 'Anthony Watkins', 'Ellis Cobb', 'Sheppard Dillon', 'Mathis Bray', 'Foreman Burns', 'Lina Glenn', 'Giles Pollard', 'Weiss Ballard', 'Lynnette Smith', 'Flores Kline', 'Graciela Singleton', 'Santiago Mcclure', 'Claudette Battle', 'Nita Holloway', 'Eula Wolfe', 'Pruitt Stokes', 'Felicia Briggs', 'Melba Bradshaw']];

    var hot = handsontable({
      data: data,
      colHeaders: true,
      columnSorting: true
    });

    hot.view.wt.wtOverlays.leftOverlay.scrollTo(15);
    hot.render();
    hot.sort(15);

    expect(getDataAtCell(0, 15)).toEqual('Ball Levy');
    expect(getDataAtCell(1, 15)).toEqual('Hubbard Nichols');
    expect(getDataAtCell(2, 15)).toEqual('Lenora Guzman');
    expect(getDataAtCell(3, 15)).toEqual('Nita Holloway');

    hot.sort(15);

    expect(getDataAtCell(3, 15)).toEqual('Ball Levy');
    expect(getDataAtCell(2, 15)).toEqual('Hubbard Nichols');
    expect(getDataAtCell(1, 15)).toEqual('Lenora Guzman');
    expect(getDataAtCell(0, 15)).toEqual('Nita Holloway');

    hot.sort(15);

    expect(getDataAtCell(0, 15)).toEqual('Hubbard Nichols');
    expect(getDataAtCell(1, 15)).toEqual('Lenora Guzman');
    expect(getDataAtCell(2, 15)).toEqual('Ball Levy');
    expect(getDataAtCell(3, 15)).toEqual('Nita Holloway');
  });

  it('should allow specifiyng a custom sorting function', function () {
    var data = [['1 inch'], ['1 yard'], ['2 feet'], ['0.2 miles']];
    var hot = handsontable({
      data: data,
      colHeaders: true,
      columnSorting: true,
      columns: [{
        sortFunction: function sortFunction(sortOrder) {
          return function (a, b) {
            var unitsRatios = {
              inch: 1,
              yard: 36,
              feet: 12,
              miles: 63360
            };

            var newA = a[1],
                newB = b[1];

            Handsontable.helper.objectEach(unitsRatios, function (val, prop) {
              if (a[1].indexOf(prop) > -1) {
                newA = parseFloat(a[1].replace(prop, '')) * val;

                return false;
              }
            });

            Handsontable.helper.objectEach(unitsRatios, function (val, prop) {
              if (b[1].indexOf(prop) > -1) {
                newB = parseFloat(b[1].replace(prop, '')) * val;

                return false;
              }
            });

            if (newA < newB) {
              return sortOrder ? -1 : 1;
            }
            if (newA > newB) {
              return sortOrder ? 1 : -1;
            }
            return 0;
          };
        }
      }]
    });

    expect(getDataAtCell(0, 0)).toEqual('1 inch');
    expect(getDataAtCell(1, 0)).toEqual('1 yard');
    expect(getDataAtCell(2, 0)).toEqual('2 feet');
    expect(getDataAtCell(3, 0)).toEqual('0.2 miles');

    hot.sort(0);

    expect(getDataAtCell(0, 0)).toEqual('1 inch');
    expect(getDataAtCell(1, 0)).toEqual('2 feet');
    expect(getDataAtCell(2, 0)).toEqual('1 yard');
    expect(getDataAtCell(3, 0)).toEqual('0.2 miles');

    hot.sort(0);

    expect(getDataAtCell(0, 0)).toEqual('0.2 miles');
    expect(getDataAtCell(1, 0)).toEqual('1 yard');
    expect(getDataAtCell(2, 0)).toEqual('2 feet');
    expect(getDataAtCell(3, 0)).toEqual('1 inch');

    hot.sort(0);

    expect(getDataAtCell(0, 0)).toEqual('1 inch');
    expect(getDataAtCell(1, 0)).toEqual('1 yard');
    expect(getDataAtCell(2, 0)).toEqual('2 feet');
    expect(getDataAtCell(3, 0)).toEqual('0.2 miles');
  });

  it('should properly sort integers with nulls', function () {
    var hot = handsontable({
      data: [['12'], [null], ['10'], ['-5'], [null], ['1000']],
      colHeaders: true,
      columnSorting: true
    });

    this.sortByColumn(0);
    expect(getDataAtCol(0)).toEqual(['-5', '10', '12', '1000', null, null]);

    this.sortByColumn(0);
    expect(getDataAtCol(0)).toEqual(['1000', '12', '10', '-5', null, null]);
  });

  it('should properly sort floating points', function () {
    var hot = handsontable({
      data: [['0.0561'], ['-10.67'], ['-4.1'], ['-0.01'], ['-127'], ['1000']],
      colHeaders: true,
      columnSorting: true
    });

    this.sortByColumn(0);
    expect(getDataAtCol(0)).toEqual(['-127', '-10.67', '-4.1', '-0.01', '0.0561', '1000']);

    this.sortByColumn(0);
    expect(getDataAtCol(0)).toEqual(['1000', '0.0561', '-0.01', '-4.1', '-10.67', '-127']);
  });

  it('should properly sort floating points with nulls', function () {
    var hot = handsontable({
      data: [['0.0561'], ['-10.67'], [null], ['-4.1'], ['-0.01'], [null], ['-127'], ['1000'], [null]],
      colHeaders: true,
      columnSorting: true
    });

    this.sortByColumn(0);
    expect(getDataAtCol(0)).toEqual(['-127', '-10.67', '-4.1', '-0.01', '0.0561', '1000', null, null, null]);

    this.sortByColumn(0);
    expect(getDataAtCol(0)).toEqual(['1000', '0.0561', '-0.01', '-4.1', '-10.67', '-127', null, null, null]);
  });

  it('should properly sort floating points with non-numerical values', function () {
    var hot = handsontable({
      data: [['0.0561'], ['-10.67'], ['a'], ['-4.1'], ['-0.01'], ['b'], ['-127'], ['1000'], ['hello']],
      colHeaders: true,
      columnSorting: true
    });

    this.sortByColumn(0);
    expect(getDataAtCol(0)).toEqual(['-127', '-10.67', '-4.1', '-0.01', '0.0561', '1000', 'a', 'b', 'hello']);

    this.sortByColumn(0);
    expect(getDataAtCol(0)).toEqual(['hello', 'b', 'a', '1000', '0.0561', '-0.01', '-4.1', '-10.67', '-127']);
  });

  it('should modify row translating process when soring is applied (visual to physical and vice versa)', function () {
    var hot = handsontable({
      data: [[2], [4], [1], [3]],
      colHeaders: true,
      columnSorting: true
    });

    this.sortByColumn(0);

    expect(hot.toPhysicalRow(0)).toBe(2);
    expect(hot.toPhysicalRow(1)).toBe(0);
    expect(hot.toPhysicalRow(2)).toBe(3);
    expect(hot.toPhysicalRow(3)).toBe(1);
    expect(hot.toVisualRow(0)).toBe(1);
    expect(hot.toVisualRow(1)).toBe(3);
    expect(hot.toVisualRow(2)).toBe(0);
    expect(hot.toVisualRow(3)).toBe(2);
  });

  describe('should return sorted properly data when maxRows or / and minSpareRow options are set', function () {
    var testSorting = function testSorting(desc, config, result) {
      it(desc, function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(config.rows, config.columns),
          maxRows: config.maxRow,
          minSpareRows: config.minSpareRows,
          columnSorting: {
            column: config.sortByColumnIndex,
            sortOrder: config.sortOrder
          }
        });

        expect(getData().length).toEqual(result.dataLength);

        for (var i = 0; i < result.expectations.length; i += 1) {
          expect(getDataAtCell(result.expectations[i].rowIndex, result.expectations[i].columnIndex)).toEqual(result.expectations[i].value);
        }
      });
    };

    testSorting('maxRows < data.length', { rows: 9, columns: 9, maxRow: 6, sortByColumnIndex: 1, sortOrder: false }, { dataLength: 6, expectations: [{ rowIndex: 0, columnIndex: 2, value: 'C6' }] });

    testSorting('maxRows > data.length', { rows: 8, columns: 8, maxRow: 20, sortByColumnIndex: 1, sortOrder: false }, { dataLength: 8, expectations: [{ rowIndex: 0, columnIndex: 2, value: 'C8' }] });

    testSorting('minSpareRows is set; maxRows < data.length', { rows: 9, columns: 9, maxRow: 5, minSpareRows: 3, sortByColumnIndex: 1, sortOrder: false }, { dataLength: 5, expectations: [{ rowIndex: 0, columnIndex: 2, value: 'C5' }] });

    testSorting('minSpareRows is set; maxRows === data.length', { rows: 6, columns: 6, maxRow: 9, minSpareRows: 3, sortByColumnIndex: 1, sortOrder: false }, { dataLength: 6 + 3, expectations: [{ rowIndex: 0, columnIndex: 2, value: 'C6' }] });

    testSorting('minSpareRows is set; maxRows > data.length', { rows: 9, columns: 9, maxRow: 15, minSpareRows: 2, sortByColumnIndex: 1, sortOrder: false }, { dataLength: 9 + 2, expectations: [{ rowIndex: 0, columnIndex: 2, value: 'C9' }] });
  });
});

/***/ }),
/* 129 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Comments', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  describe('Enabling the plugin', function () {
    it('should enable the plugin in the initial config', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        comments: true
      });

      expect(hot.getPlugin('comments').isEnabled()).toBe(true);
    });

    it('should enable the plugin using updateSettings', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4)
      });

      expect(hot.getPlugin('comments').isEnabled()).toBe(false);

      updateSettings({
        comments: true
      });

      expect(hot.getPlugin('comments').isEnabled()).toBe(true);
    });
  });

  describe('Styling', function () {
    it('should display comment indicators in the appropriate cells', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        comments: true,
        cell: [{ row: 1, col: 1, comment: { value: 'test' } }, { row: 2, col: 2, comment: { value: 'test' } }]
      });

      expect(getCell(1, 1).className.indexOf('htCommentCell')).toBeGreaterThan(-1);
      expect(getCell(2, 2).className.indexOf('htCommentCell')).toBeGreaterThan(-1);
    });
  });

  describe('API', function () {
    it('should return the comment from a proper cell, when using the getCommentAtCell method', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        comments: true,
        cell: [{ row: 1, col: 1, comment: { value: 'test' } }, { row: 2, col: 2, comment: { value: 'another test' } }]
      });

      var plugin = hot.getPlugin('comments');

      expect(plugin.getCommentAtCell(1, 1)).toEqual('test');
      expect(plugin.getCommentAtCell(2, 2)).toEqual('another test');
    });

    it('should return the comment from a proper cell, when using the setRange and getComment methods', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        comments: true,
        cell: [{ row: 1, col: 1, comment: { value: 'test' } }, { row: 2, col: 2, comment: { value: 'another test' } }]
      });

      var plugin = hot.getPlugin('comments');

      plugin.setRange({ from: { row: 1, col: 1 } });
      expect(plugin.getComment()).toEqual('test');
      plugin.setRange({ from: { row: 2, col: 2 } });
      expect(plugin.getComment()).toEqual('another test');
    });

    it('should allow inserting comments using the `setCommentAtCell` method', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        comments: true
      });

      var plugin = hot.getPlugin('comments');

      expect(getCellMeta(1, 1).comment).toEqual(void 0);

      plugin.setCommentAtCell(1, 1, 'test comment');

      expect(getCellMeta(1, 1).comment.value).toEqual('test comment');
    });

    it('should trigger `afterSetCellMeta` callback when `setCommentAtCell` function is invoked', function () {
      var afterSetCellMetaCallback = jasmine.createSpy('afterSetCellMetaCallback');
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        comments: true,
        afterSetCellMeta: afterSetCellMetaCallback
      });

      var plugin = hot.getPlugin('comments');

      plugin.setCommentAtCell(1, 1, 'Added comment');
      expect(afterSetCellMetaCallback).toHaveBeenCalledWith(1, 1, 'comment', { value: 'Added comment' }, undefined, undefined);
    });

    it('should allow removing comments using the `removeCommentAtCell` method', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        comments: true,
        cell: [{ row: 1, col: 1, comment: { value: 'test' } }]
      });

      var plugin = hot.getPlugin('comments');

      expect(getCellMeta(1, 1).comment.value).toEqual('test');

      plugin.removeCommentAtCell(1, 1);

      expect(getCellMeta(1, 1).comment).toEqual(void 0);
    });

    it('should trigger `afterSetCellMeta` callback when `removeCommentAtCell` function is invoked', function () {
      var afterSetCellMetaCallback = jasmine.createSpy('afterSetCellMetaCallback');
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        comments: true,
        cell: [{ row: 1, col: 1, comment: { value: 'test' } }],
        afterSetCellMeta: afterSetCellMetaCallback
      });

      var plugin = hot.getPlugin('comments');

      plugin.removeCommentAtCell(1, 1);
      expect(afterSetCellMetaCallback).toHaveBeenCalledWith(1, 1, 'comment', undefined, undefined, undefined);
    });

    it('should allow opening the comment editor using the `showAtCell` method', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        comments: true
      });

      var plugin = hot.getPlugin('comments');
      var editor = plugin.editor.getInputElement();

      expect(editor.parentNode.style.display).toEqual('none');

      plugin.showAtCell(1, 1);

      expect(editor.parentNode.style.display).toEqual('block');
    });

    it('should allow closing the comment editor using the `hide` method', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        comments: true
      });

      var plugin = hot.getPlugin('comments');
      var editor = plugin.editor.getInputElement();
      plugin.showAtCell(1, 1);
      expect(editor.parentNode.style.display).toEqual('block');

      plugin.hide();

      expect(editor.parentNode.style.display).toEqual('none');
    });
  });

  it('`updateCommentMeta` & `setComment` functions should extend cellMetaObject properly', function () {
    var comment, readOnly;
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(4, 4),
      comments: true
    });
    var plugin = hot.getPlugin('comments');

    setCellMeta(0, 0, 'comment', { readOnly: true });
    plugin.updateCommentMeta(0, 0, { value: 'Test' });

    comment = getCellMeta(0, 0).comment;
    readOnly = comment && comment.readOnly;

    expect(readOnly).toEqual(true);

    plugin.setRange({ from: { row: 0, col: 0 }, to: { row: 0, col: 0 } });
    plugin.setComment('Test2');

    comment = getCellMeta(0, 0).comment;
    readOnly = comment && comment.readOnly;

    expect(readOnly).toEqual(true);
  });

  describe('Using the Context Menu', function () {
    it('should open the comment editor when clicking the "Add comment" entry', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        comments: true
      });

      selectCell(1, 1);
      contextMenu();

      var addCommentButton = $('.htItemWrapper').filter(function () {
        return $(this).text() === 'Add comment';
      })[0];

      $(addCommentButton).simulate('mousedown');

      var editor = hot.getPlugin('comments').editor.getInputElement();

      expect($(editor).parents('.htComments')[0].style.display).toEqual('block');
    });

    it('should remove the comment from a cell after clicking the "Delete comment" entry', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        comments: true,
        cell: [{ row: 1, col: 1, comment: { value: 'Test comment' } }]
      });

      expect(getCellMeta(1, 1).comment.value).toEqual('Test comment');

      selectCell(1, 1);
      contextMenu();

      var deleteCommentButton = $('.htItemWrapper').filter(function () {
        return $(this).text() === 'Delete comment';
      })[0];

      $(deleteCommentButton).simulate('mousedown');

      expect(getCellMeta(1, 1).comment).toEqual(void 0);
    });

    it('should remove comments from a selected group of cells after clicking the "Delete comment" entry', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        comments: true,
        cell: [{ row: 1, col: 1, comment: { value: 'Test comment' } }, { row: 2, col: 2, comment: { value: 'Test comment 2' } }]
      });

      expect(getCellMeta(1, 1).comment.value).toEqual('Test comment');
      expect(getCellMeta(2, 2).comment.value).toEqual('Test comment 2');

      selectCell(1, 1, 2, 2);
      contextMenu();

      var deleteCommentButton = $('.htItemWrapper').filter(function () {
        return $(this).text() === 'Delete comment';
      })[0];

      $(deleteCommentButton).simulate('mousedown');

      expect(getCellMeta(1, 1).comment).toEqual(void 0);
      expect(getCellMeta(2, 2).comment).toEqual(void 0);
    });

    it('should make the comment editor\'s textarea read-only after clicking the "Read only comment" entry', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        comments: true,
        cell: [{ row: 1, col: 1, comment: { value: 'Test comment' } }]
      });

      selectCell(1, 1);
      contextMenu();

      var editor = hot.getPlugin('comments').editor.getInputElement();

      expect($(editor)[0].readOnly).toBe(false);

      var readOnlyComment = $('.htItemWrapper').filter(function () {
        return $(this).text() === 'Read only comment';
      })[0];

      $(readOnlyComment).simulate('mousedown');
      $(document).simulate('mouseup');

      $(getCell(1, 1)).simulate('mouseover', {
        clientX: Handsontable.dom.offset(getCell(1, 1)).left + 5,
        clientY: Handsontable.dom.offset(getCell(1, 1)).top + 5
      });

      setTimeout(function () {
        expect($(editor)[0].readOnly).toBe(true);
        done();
      }, 550);
    });
  });

  describe('Hooks invoked after changing cell meta', function () {
    it('should trigger `afterSetCellMeta` callback after deleting comment by context menu', function () {
      var afterSetCellMetaCallback = jasmine.createSpy('afterSetCellMetaCallback');
      var rows = 10,
          columns = 10;

      handsontable({
        data: Handsontable.helper.createSpreadsheetData(rows, columns),
        rowHeaders: true,
        colHeaders: true,
        contextMenu: true,
        comments: true,
        columns: function columns() {
          return {
            comment: {
              value: 'test'
            }
          };
        },

        afterSetCellMeta: afterSetCellMetaCallback
      });

      expect(afterSetCellMetaCallback).not.toHaveBeenCalled();

      selectCell(1, 1);
      contextMenu();

      var deleteCommentButton = $('.htItemWrapper').filter(function () {
        return $(this).text() === 'Delete comment';
      })[0];

      $(deleteCommentButton).simulate('mousedown');

      expect(afterSetCellMetaCallback).toHaveBeenCalledWith(1, 1, 'comment', undefined, undefined, undefined);
    });

    // Don't work in PhantomJS
    // It will work probably when #3961 will be fixed

    xit('should trigger `afterSetCellMeta` callback after editing comment by context menu', function (done) {
      var afterSetCellMetaCallback = jasmine.createSpy('afterSetCellMetaCallback');
      var rows = 10,
          columns = 10;

      handsontable({
        data: Handsontable.helper.createSpreadsheetData(rows, columns),
        rowHeaders: true,
        colHeaders: true,
        contextMenu: true,
        comments: true,
        columns: function columns() {
          return {
            comment: {
              value: 'test'
            }
          };
        },

        afterSetCellMeta: afterSetCellMetaCallback
      });

      selectCell(0, 0);
      contextMenu();

      var editCommentButton = $('.htItemWrapper').filter(function () {
        return $(this).text() === 'Edit comment';
      })[0];

      $(editCommentButton).simulate('mousedown');

      setTimeout(function () {
        $('.htCommentTextArea').val('Edited comment');

        // changing focus

        $('body').simulate('mousedown');

        setTimeout(function () {
          expect(afterSetCellMetaCallback).toHaveBeenCalledWith(0, 0, 'comment', { value: 'Edited comment' }, undefined, undefined);
          done();
        }, 100);
      }, 100);
    });
  });
});

/***/ }),
/* 130 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('ContextMenu', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  describe('alignment', function () {
    it('should align text left', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      contextMenu();

      var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(9);
      item.simulate('mouseover');

      setTimeout(function () {
        var contextSubMenu = $('.htContextMenuSub_' + item.text());
        var button = contextSubMenu.find('.ht_master .htCore tbody td').not('.htSeparator').eq(0);
        button.simulate('mousedown'); // Text left

        expect(getCellMeta(0, 0).className).toEqual('htLeft');
        expect(getCell(0, 0).className).toContain('htLeft');
        done();
      }, 350);
    });

    it('should align text center', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      contextMenu();

      var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(9);
      item.simulate('mouseover');

      setTimeout(function () {
        var contextSubMenu = $('.htContextMenuSub_' + item.text());
        var button = contextSubMenu.find('.ht_master .htCore tbody td').not('.htSeparator').eq(1);

        button.simulate('mousedown'); // Text center
        expect(getCellMeta(0, 0).className).toEqual('htCenter');
        expect(getCell(0, 0).className).toContain('htCenter');
        done();
      }, 350);
    });

    it('should align text right', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      contextMenu();

      var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(9);
      item.simulate('mouseover');

      setTimeout(function () {
        var contextSubMenu = $('.htContextMenuSub_' + item.text());
        var button = contextSubMenu.find('.ht_master .htCore tbody td').not('.htSeparator').eq(2);

        button.simulate('mousedown'); // Text right
        expect(getCellMeta(0, 0).className).toEqual('htRight');
        expect(getCell(0, 0).className).toContain('htRight');
        done();
      }, 350);
    });

    it('should justify text', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      contextMenu();

      var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(9);
      item.simulate('mouseover');

      setTimeout(function () {
        var contextSubMenu = $('.htContextMenuSub_' + item.text());
        var button = contextSubMenu.find('.ht_master .htCore tbody td').not('.htSeparator').eq(3);

        button.simulate('mousedown'); // Text justify
        deselectCell();
        expect(getCellMeta(0, 0).className).toEqual('htJustify');
        expect(getCell(0, 0).className).toContain('htJustify');
        done();
      }, 350); // menu opens after 300ms
    });

    it('should vertical align text top', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      contextMenu();

      var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(9);
      item.simulate('mouseover');

      setTimeout(function () {
        var contextSubMenu = $('.htContextMenuSub_' + item.text());
        var button = contextSubMenu.find('.ht_master .htCore tbody td').not('.htSeparator').eq(4);

        button.simulate('mousedown'); // Text top
        deselectCell();
        expect(getCellMeta(0, 0).className).toEqual('htTop');
        expect(getCell(0, 0).className).toContain('htTop');
        done();
      }, 350); // menu opens after 300ms
    });

    it('should vertical align text middle', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      contextMenu();

      var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(9);
      item.simulate('mouseover');

      setTimeout(function () {
        var contextSubMenu = $('.htContextMenuSub_' + item.text());
        var button = contextSubMenu.find('.ht_master .htCore tbody td').not('.htSeparator').eq(5);

        button.simulate('mousedown'); // Text middle
        deselectCell();
        expect(getCellMeta(0, 0).className).toEqual('htMiddle');
        expect(getCell(0, 0).className).toContain('htMiddle');
        done();
      }, 350); // menu opens after 300ms
    });

    it('should vertical align text bottom', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      contextMenu();
      var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(9);
      item.simulate('mouseover');

      setTimeout(function () {
        var contextSubMenu = $('.htContextMenuSub_' + item.text());
        var button = contextSubMenu.find('.ht_master .htCore tbody td').not('.htSeparator').eq(6);
        button.simulate('mousedown'); // Text bottom
        deselectCell();
        expect(getCellMeta(0, 0).className).toEqual('htBottom');
        expect(getCell(0, 0).className).toContain('htBottom');
        done();
      }, 350); // menu opens after 300ms
    });

    it('should trigger `afterSetCellMeta` callback after changing alignment by context menu', function (done) {
      var afterSetCellMetaCallback = jasmine.createSpy('afterSetCellMetaCallback');
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        rowHeaders: true,
        colHeaders: true,
        contextMenu: true,
        afterSetCellMeta: afterSetCellMetaCallback
      });

      selectCell(2, 3);
      contextMenu();
      var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(9);
      item.simulate('mouseover');

      setTimeout(function () {
        var contextSubMenu = $('.htContextMenuSub_' + item.text());
        var button = contextSubMenu.find('.ht_master .htCore tbody td').not('.htSeparator').eq(2);
        button.simulate('mousedown'); // Text bottom
        deselectCell();
        expect(afterSetCellMetaCallback).toHaveBeenCalledWith(2, 3, 'className', 'htRight', undefined, undefined);
        done();
      }, 350); // menu opens after 300ms
    });
  });
});

/***/ }),
/* 131 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('ContextMenu', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should update context menu items by calling `updateSettings` method', function () {
    var hot = handsontable({
      contextMenu: ['row_above', 'row_below', '---------', 'remove_row'],
      height: 100
    });

    contextMenu();

    var items = $('.htContextMenu tbody td');
    var actions = items.not('.htSeparator');
    var separators = items.filter('.htSeparator');

    expect(actions.length).toEqual(3);
    expect(separators.length).toEqual(1);

    expect(actions.text()).toEqual(['Insert row above', 'Insert row below', 'Remove row'].join(''));

    hot.updateSettings({
      contextMenu: ['remove_row']
    });

    contextMenu();

    items = $('.htContextMenu tbody td');
    actions = items.not('.htSeparator');
    separators = items.filter('.htSeparator');

    expect(actions.length).toEqual(1);
    expect(separators.length).toEqual(0);

    expect(actions.text()).toEqual(['Remove row'].join(''));

    hot.updateSettings({
      contextMenu: {
        items: {
          remove_col: true,
          hsep1: '---------',
          custom: { name: 'My custom item' }
        }
      }
    });

    contextMenu();

    items = $('.htContextMenu tbody td');
    actions = items.not('.htSeparator');
    separators = items.filter('.htSeparator');

    expect(actions.length).toEqual(2);
    expect(separators.length).toEqual(1);

    expect(actions.text()).toEqual(['Remove column', 'My custom item'].join(''));
  });

  describe('menu opening', function () {
    it('should open menu after right click on table cell', function () {
      var hot = handsontable({
        contextMenu: true,
        height: 100
      });

      expect(hot.getPlugin('contextMenu')).toBeDefined();
      expect($('.htContextMenu').is(':visible')).toBe(false);

      contextMenu();

      expect($('.htContextMenu').is(':visible')).toBe(true);
    });

    it('should not open the menu after clicking an open editor', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      selectCell(2, 2);
      keyDownUp('enter');

      expect(hot.getPlugin('contextMenu')).toBeDefined();
      expect($('.htContextMenu').is(':visible')).toBe(false);

      contextMenu(hot.getActiveEditor().TEXTAREA);

      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should open menu after right click on header cell when only header cells are visible', function () {
      var hot = handsontable({
        data: [],
        colHeaders: ['Year', 'Kia'],
        columns: [{ data: 0 }, { data: 1 }],
        contextMenu: true,
        height: 100
      });

      expect(hot.getPlugin('contextMenu')).toBeDefined();
      expect($('.htContextMenu').is(':visible')).toBe(false);

      contextMenu(hot.rootElement.querySelector('.ht_clone_top thead th'));

      expect($('.htContextMenu').is(':visible')).toBe(true);
    });

    it('should open menu after right click on header corner', function () {
      var hot = handsontable({
        data: [],
        colHeaders: true,
        rowHeaders: true,
        contextMenu: true,
        height: 100
      });

      expect(hot.getPlugin('contextMenu')).toBeDefined();
      expect($('.htContextMenu').is(':visible')).toBe(false);

      contextMenu(hot.rootElement.querySelector('.ht_clone_top_left_corner thead th'));

      expect($('.htContextMenu').is(':visible')).toBe(true);
    });

    it('should open menu after right click active cell border', function () {
      var hot = handsontable({
        contextMenu: true,
        height: 100
      });

      expect(hot.getPlugin('contextMenu')).toBeDefined();
      expect($('.htContextMenu').is(':visible')).toBe(false);

      selectCell(0, 0);

      this.$container.find('.wtBorder.current:eq(0)').simulate('contextmenu');

      expect($('.htContextMenu').is(':visible')).toBe(true);
    });
  });

  describe('menu closing', function () {
    it('should close menu after click', function () {
      var hot = handsontable({
        contextMenu: true,
        height: 100
      });

      contextMenu();

      expect($('.htContextMenu').is(':visible')).toBe(true);

      mouseDown(this.$container);

      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should close menu after click under the menu', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(500, 10),
        contextMenu: true,
        height: 500
      });

      contextMenu();

      expect($('.htContextMenu').is(':visible')).toBe(true);

      var rect = $('.htContextMenu')[0].getBoundingClientRect();
      var x = parseInt(rect.left + rect.width / 2, 10);
      var y = parseInt(rect.top + rect.height, 10);
      mouseDown(document.elementFromPoint(x, y));

      expect($('.htContextMenu').is(':visible')).toBe(false);
    });
  });

  describe('menu disabled', function () {

    it('should not open menu after right click', function () {
      var hot = handsontable({
        contextMenu: true,
        height: 100
      });

      hot.getPlugin('contextMenu').disablePlugin();

      expect($('.htContextMenu').is(':visible')).toBe(false);

      contextMenu();

      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should not create context menu if it\'s disabled in constructor options', function () {
      var hot = handsontable({
        contextMenu: false,
        height: 100
      });

      expect(hot.getPlugin('contextMenu').isEnabled()).toBe(false);
    });

    it('should reenable menu', function () {
      var hot = handsontable({
        contextMenu: true,
        height: 100
      });

      hot.getPlugin('contextMenu').disablePlugin();

      expect($('.htContextMenu').is(':visible')).toBe(false);

      contextMenu();

      expect($('.htContextMenu').is(':visible')).toBe(false);

      hot.getPlugin('contextMenu').enablePlugin();

      contextMenu();

      expect($('.htContextMenu').is(':visible')).toBe(true);
    });

    it('should reenable menu with updateSettings when it was disabled in constructor', function () {
      var hot = handsontable({
        contextMenu: false,
        height: 100
      });

      expect(hot.getPlugin('contextMenu').isEnabled()).toBe(false);

      updateSettings({
        contextMenu: true
      });

      expect(hot.getPlugin('contextMenu').isEnabled()).toBe(true);

      expect($('.htContextMenu').is(':visible')).toBe(false);

      contextMenu();

      expect($('.htContextMenu').is(':visible')).toBe(true);
    });

    it('should disable menu with updateSettings when it was enabled in constructor', function () {
      var hot = handsontable({
        contextMenu: true,
        height: 100
      });

      expect(hot.getPlugin('contextMenu').isEnabled()).toBe(true);

      updateSettings({
        contextMenu: false
      });

      expect(hot.getPlugin('contextMenu').isEnabled()).toBe(false);
    });

    it('should work properly (remove row) after destroy and new init', function () {
      var test = function test() {
        handsontable({
          startRows: 5,
          contextMenu: ['remove_row'],
          height: 100
        });
        selectCell(0, 0);
        contextMenu();

        $('.htContextMenu .ht_master .htCore tbody').find('td').not('.htSeparator').eq(0).simulate('mousedown');
        expect(getData().length).toEqual(4);
      };
      test();

      destroy();

      test();
    });
  });

  describe('menu hidden items', function () {
    it('should remove separators from top, bottom and duplicated', function () {
      var hot = handsontable({
        contextMenu: ['---------', '---------', 'row_above', '---------', '---------', 'row_below', '---------', 'remove_row'],
        height: 100
      });

      contextMenu();

      var items = $('.htContextMenu tbody td');
      var actions = items.not('.htSeparator');
      var separators = items.filter('.htSeparator');

      expect(actions.length).toEqual(3);
      expect(separators.length).toEqual(2);
    });

    it('should hide option if hidden function return true', function () {

      var hot = handsontable({
        startCols: 5,
        colHeaders: true,
        contextMenu: [{
          key: '',
          name: 'Custom option',
          hidden: function hidden() {
            return !this.selection.selectedHeader.cols;
          }
        }]
      });

      contextMenu();
      var items = $('.htContextMenu tbody td');
      var actions = items.not('.htSeparator');

      expect(actions.length).toEqual(0);

      var header = $('.ht_clone_top thead th').eq(1);

      header.simulate('mousedown');
      contextMenu();

      items = $('.htContextMenu tbody td');
      actions = items.not('.htSeparator');
      expect(actions.length).toEqual(1);
    });
  });

  describe('menu destroy', function () {
    it('should close context menu when HOT is being destroyed', function () {
      var hot = handsontable({
        contextMenu: true,
        height: 100
      });

      contextMenu();

      expect($('.htContextMenu').is(':visible')).toBe(true);

      destroy();

      expect($('.htContextMenu').is(':visible')).toBe(false);
    });
  });

  describe('subMenu', function () {
    it('should not open subMenu immediately', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      contextMenu();

      var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(9);
      item.simulate('mouseover');
      var contextSubMenu = $('.htContextMenuSub_' + item.text()).find('tbody td');

      expect(contextSubMenu.length).toEqual(0);

      setTimeout(function () {
        var contextSubMenu = $('.htContextMenuSub_' + item.text()).find('tbody td');

        expect(contextSubMenu.length).toEqual(0);
        done();
      }, 100);
    });

    it('should open subMenu with delay', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      contextMenu();

      var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(9);

      item.simulate('mouseover');

      setTimeout(function () {
        var contextSubMenu = $('.htContextMenuSub_' + item.text());

        expect(contextSubMenu.length).toEqual(1);
        done();
      }, 350); // menu opens after 300ms
    });

    it('should NOT open subMenu if there is no subMenu for item', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      contextMenu();

      var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(8);

      item.simulate('mouseover');

      expect(item.hasClass('htSubmenu')).toBe(false);

      var contextSubMenu = $('.htContextMenuSub_' + item.text());

      expect(contextSubMenu.length).toEqual(0);
    });

    it('should open subMenu on the left of main menu if on the right there\'s no space left', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, Math.floor(window.innerWidth / 50)),
        contextMenu: true,
        width: window.innerWidth
      });

      selectCell(0, countCols() - 1);
      contextMenu();

      var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(9);
      var contextMenuRoot = $('.htContextMenu');

      item.simulate('mouseover');

      expect(item.text()).toBe('Alignment');
      expect(item.hasClass('htSubmenu')).toBe(true);

      var contextSubMenu = $('.htContextMenuSub_' + item.text());

      expect(contextSubMenu.offset().left).toBeLessThan(contextMenuRoot.offset().left - contextSubMenu.width() + 30); // 30 - scroll
    });

    it('should open subMenu on the right of main menu if there\'s free space', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, Math.floor(window.innerWidth / 50)),
        contextMenu: true,
        width: window.innerWidth
      });

      selectCell(0, countCols() - 9);
      contextMenu();

      var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(9);
      var contextMenuRoot = $('.htContextMenu');

      item.simulate('mouseover');

      setTimeout(function () {
        expect(item.text()).toBe('Alignment');
        expect(item.hasClass('htSubmenu')).toBe(true);

        var contextSubMenu = $('.htContextMenuSub_' + item.text());

        expect(contextSubMenu.offset().left).toBeGreaterThan(contextMenuRoot.offset().left + contextMenuRoot.width() - 30); // 30 - scroll
        done();
      }, 350); // menu opens after 300ms
    });

    it('should open subMenu on the left-bottom of main menu if there\'s free space', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(Math.floor(window.innerHeight / 23), Math.floor(window.innerWidth / 50)),
        contextMenu: true,
        height: window.innerHeight
      });

      window.scrollTo(0, document.body.clientHeight);
      selectCell(0, countCols() - 1);
      contextMenu();

      var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(9);
      var contextMenuRoot = $('.htContextMenu');

      item.simulate('mouseover');

      setTimeout(function () {
        expect(item.text()).toBe('Alignment');
        expect(item.hasClass('htSubmenu')).toBe(true);

        var contextSubMenu = $('.htContextMenuSub_' + item.text());

        expect(parseInt(contextSubMenu.offset().top, 10)).toBeAroundValue(parseInt(item.offset().top, 10) - 1);
        expect(parseInt(contextSubMenu.offset().left, 10)).toBeLessThan(contextMenuRoot.offset().left - contextSubMenu.width() + 30); // 30 - scroll
        done();
      }, 350); // menu opens after 300ms
    });

    it('should open subMenu on the right-bottom of main menu if there\'s free space', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(Math.floor(window.innerHeight / 23), Math.floor(window.innerWidth / 50)),
        contextMenu: true,
        height: window.innerHeight
      });

      window.scrollTo(0, document.body.clientHeight);
      selectCell(0, countCols() - 9);

      contextMenu();

      var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(9);
      var contextMenuRoot = $('.htContextMenu');

      item.simulate('mouseover');

      setTimeout(function () {
        expect(item.text()).toBe('Alignment');
        expect(item.hasClass('htSubmenu')).toBe(true);

        var contextSubMenu = $('.htContextMenuSub_' + item.text());

        expect(parseInt(contextSubMenu.offset().top, 10)).toBeAroundValue(parseInt(item.offset().top, 10) - 1);
        expect(parseInt(contextSubMenu.offset().left, 10)).toBeGreaterThan(contextMenuRoot.offset().left + contextMenuRoot.width() - 30); // 30 - scroll
        done();
      }, 350); // menu opens after 300ms
    });

    it('should open subMenu on the left-top of main menu if there\'s no free space on bottom', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(Math.floor(window.innerHeight / 23), Math.floor(window.innerWidth / 50)),
        contextMenu: true,
        height: window.innerHeight
      });

      selectCell(countRows() - 1, countCols() - 1);
      contextMenu();

      var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(9);
      var contextMenuRoot = $('.htContextMenu');

      item.simulate('mouseover');

      setTimeout(function () {
        expect(item.text()).toBe('Alignment');
        expect(item.hasClass('htSubmenu')).toBe(true);

        var contextSubMenu = $('.htContextMenuSub_' + item.text());

        expect(contextSubMenu.offset().top + contextSubMenu.height() - 28).toBeAroundValue(item.offset().top);
        expect(contextSubMenu.offset().left).toBeLessThan(contextMenuRoot.offset().left - contextSubMenu.width() + 30); // 30 - scroll
        done();
      }, 350); // menu opens after 300ms
    });

    it('should open subMenu on the right-top of main menu if there\'s no free space on bottom', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(Math.floor(window.innerHeight / 23), Math.floor(window.innerWidth / 50)),
        contextMenu: true,
        height: window.innerHeight
      });

      selectCell(countRows() - 1, countCols() - 9);
      contextMenu();

      var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(9);
      var contextMenuRoot = $('.htContextMenu');

      item.simulate('mouseover');

      setTimeout(function () {
        expect(item.text()).toBe('Alignment');
        expect(item.hasClass('htSubmenu')).toBe(true);

        var contextSubMenu = $('.htContextMenuSub_' + item.text());

        expect(contextSubMenu.offset().top + contextSubMenu.height() - 28).toBeAroundValue(item.offset().top);
        expect(contextSubMenu.offset().left).toBeGreaterThan(contextMenuRoot.offset().left + contextMenuRoot.width() - 30); // 30 - scroll
        done();
      }, 350); // menu opens after 300ms
    });
  });

  describe('default context menu actions', function () {
    it('should display the default set of actions', function () {
      var hot = handsontable({
        contextMenu: true,
        comments: true,
        height: 100
      });

      contextMenu();

      var items = $('.htContextMenu tbody td');
      var actions = items.not('.htSeparator');
      var separators = items.filter('.htSeparator');

      expect(actions.length).toEqual(13);
      expect(separators.length).toEqual(6);

      expect(actions.text()).toEqual(['Insert row above', 'Insert row below', 'Insert column on the left', 'Insert column on the right', 'Remove row', 'Remove column', 'Undo', 'Redo', 'Read only', 'Alignment', 'Add comment', 'Delete comment', 'Read only comment'].join(''));
    });

    it('should disable column manipulation when row header selected', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        colHeaders: true,
        rowHeaders: true,
        height: 100
      });

      $('.ht_clone_left .htCore').eq(0).find('tbody').find('th').eq(0).simulate('mousedown', { which: 3 });
      contextMenu();

      expect($('.htContextMenu tbody td.htDisabled').text()).toBe(['Insert column on the left', 'Insert column on the right', 'Remove column', 'Undo', 'Redo'].join(''));
    });

    it('should disable row manipulation when column header selected', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        colHeaders: true,
        rowHeaders: true,
        height: 100
      });

      $('.ht_clone_top .htCore').find('thead').find('th').eq(2).simulate('mousedown', { which: 3 });
      contextMenu();

      expect($('.htContextMenu tbody td.htDisabled').text()).toBe(['Insert row above', 'Insert row below', 'Remove row', 'Undo', 'Redo'].join(''));
    });

    it('should disable cells manipulation when corner header selected', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        colHeaders: true,
        rowHeaders: true,
        height: 100
      });

      $('.ht_clone_top_left_corner .htCore').find('thead').find('th').eq(0).simulate('mousedown', { which: 3 });
      contextMenu();

      expect($('.htContextMenu tbody td.htDisabled').text()).toBe(['Remove row', 'Remove column', 'Undo', 'Redo', 'Read only', 'Alignment'].join(''));
    });

    it('should insert row above selection', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 400
      });

      var afterCreateRowCallback = jasmine.createSpy('afterCreateRowCallback');
      hot.addHook('afterCreateRow', afterCreateRowCallback);

      expect(countRows()).toEqual(4);

      selectCell(1, 0, 3, 0);
      contextMenu();
      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(0).simulate('mousedown'); // Insert row above

      expect(afterCreateRowCallback).toHaveBeenCalledWith(1, 1, 'ContextMenu.rowAbove', undefined, undefined, undefined);
      expect(countRows()).toEqual(5);
      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should insert row above selection when initial data is empty', function () {
      var hot = handsontable({
        rowHeaders: true,
        colHeaders: true,
        data: [],
        dataSchema: [],
        contextMenu: true,
        height: 400
      });

      var afterCreateRowCallback = jasmine.createSpy('afterCreateRowCallback');
      hot.addHook('afterCreateRow', afterCreateRowCallback);

      expect(countRows()).toEqual(0);

      var cell = $('.ht_clone_top_left_corner .htCore').find('thead').find('th').eq(0);

      cell.simulate('mousedown', { which: 3 });
      contextMenu(cell[0]);
      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(0).simulate('mousedown'); // Insert row above

      expect(afterCreateRowCallback).toHaveBeenCalledWith(0, 1, 'ContextMenu.rowAbove', undefined, undefined, undefined);
      expect(countRows()).toEqual(1);
      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should NOT display insert row selection', function () {
      var hot = handsontable({
        contextMenu: true,
        allowInsertRow: false
      });

      contextMenu();

      var items = $('.htContextMenu tbody td');
      var actions = items.not('.htSeparator');
      var separators = items.filter('.htSeparator');

      expect(actions.length).toEqual(8);
      expect(separators.length).toEqual(4);

      expect(actions.text()).toEqual(['Insert column on the left', 'Insert column on the right', 'Remove row', 'Remove column', 'Undo', 'Redo', 'Read only', 'Alignment'].join(''));
    });

    it('should NOT display insert column selection', function () {
      var hot = handsontable({
        contextMenu: true,
        allowInsertColumn: false
      });

      contextMenu();

      var items = $('.htContextMenu tbody td');
      var actions = items.not('.htSeparator');

      expect(actions.length).toEqual(8);

      expect(actions.text()).toEqual(['Insert row above', 'Insert row below', 'Remove row', 'Remove column', 'Undo', 'Redo', 'Read only', 'Alignment'].join(''));
    });

    it('should insert row above selection (reverse selection)', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      var afterCreateRowCallback = jasmine.createSpy('afterCreateRowCallback');
      hot.addHook('afterCreateRow', afterCreateRowCallback);

      expect(countRows()).toEqual(4);

      selectCell(3, 0, 1, 0);
      contextMenu();
      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(0).simulate('mousedown'); // Insert row above

      expect(afterCreateRowCallback).toHaveBeenCalledWith(1, 1, 'ContextMenu.rowAbove', undefined, undefined, undefined);
      expect(countRows()).toEqual(5);
      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should insert row below selection', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      var afterCreateRowCallback = jasmine.createSpy('afterCreateRowCallback');
      hot.addHook('afterCreateRow', afterCreateRowCallback);

      expect(countRows()).toEqual(4);

      selectCell(1, 0, 3, 0);
      contextMenu();
      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(1).simulate('mousedown'); // Insert row above

      expect(afterCreateRowCallback).toHaveBeenCalledWith(4, 1, 'ContextMenu.rowBelow', undefined, undefined, undefined);
      expect(countRows()).toEqual(5);
      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should insert row below selection when initial data is empty', function () {
      var hot = handsontable({
        rowHeaders: true,
        colHeaders: true,
        data: [],
        dataSchema: [],
        contextMenu: true,
        height: 400
      });

      var afterCreateRowCallback = jasmine.createSpy('afterCreateRowCallback');
      hot.addHook('afterCreateRow', afterCreateRowCallback);

      expect(countRows()).toEqual(0);

      var cell = $('.ht_clone_top_left_corner .htCore').find('thead').find('th').eq(0);

      cell.simulate('mousedown', { which: 3 });
      contextMenu(cell[0]);
      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(1).simulate('mousedown'); // Insert row below

      expect(afterCreateRowCallback).toHaveBeenCalledWith(0, 1, 'ContextMenu.rowBelow', undefined, undefined, undefined);
      expect(countRows()).toEqual(1);
      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should insert row below selection (reverse selection)', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      var afterCreateRowCallback = jasmine.createSpy('afterCreateRowCallback');
      hot.addHook('afterCreateRow', afterCreateRowCallback);

      expect(countRows()).toEqual(4);

      selectCell(3, 0, 1, 0);
      contextMenu();
      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(1).simulate('mousedown'); // Insert row below

      expect(afterCreateRowCallback).toHaveBeenCalledWith(4, 1, 'ContextMenu.rowBelow', undefined, undefined, undefined);
      expect(countRows()).toEqual(5);
      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should insert column on the left of selection', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        width: 400,
        height: 400
      });

      var afterCreateColCallback = jasmine.createSpy('afterCreateColCallback');
      hot.addHook('afterCreateCol', afterCreateColCallback);

      expect(countCols()).toEqual(4);

      selectCell(0, 1, 0, 3);
      contextMenu();
      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(2).simulate('mousedown'); // Insert col left

      expect(afterCreateColCallback).toHaveBeenCalledWith(1, 1, 'ContextMenu.columnLeft', undefined, undefined, undefined);
      expect(countCols()).toEqual(5);
      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should insert column on the left of selection when initial data is empty', function () {
      var hot = handsontable({
        rowHeaders: true,
        colHeaders: true,
        data: [],
        dataSchema: [],
        contextMenu: true,
        height: 400
      });

      var afterCreateColCallback = jasmine.createSpy('afterCreateColCallback');
      hot.addHook('afterCreateCol', afterCreateColCallback);

      expect(countCols()).toEqual(0);

      var cell = $('.ht_clone_top_left_corner .htCore').find('thead').find('th').eq(0);

      cell.simulate('mousedown', { which: 3 });
      contextMenu(cell[0]);
      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(3).simulate('mousedown'); // Insert column on the left

      expect(afterCreateColCallback).toHaveBeenCalledWith(0, 1, 'ContextMenu.columnRight', undefined, undefined, undefined);
      expect(countCols()).toEqual(1);
      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should insert column on the left of selection (reverse selection)', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      var afterCreateColCallback = jasmine.createSpy('afterCreateColCallback');
      hot.addHook('afterCreateCol', afterCreateColCallback);

      expect(countCols()).toEqual(4);

      selectCell(0, 3, 0, 1);
      contextMenu();
      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(2).simulate('mousedown'); // Insert col left

      expect(afterCreateColCallback).toHaveBeenCalledWith(1, 1, 'ContextMenu.columnLeft', undefined, undefined, undefined);
      expect(countCols()).toEqual(5);
      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should insert column on the right of selection', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      var afterCreateColCallback = jasmine.createSpy('afterCreateColCallback');
      hot.addHook('afterCreateCol', afterCreateColCallback);

      expect(countCols()).toEqual(4);

      selectCell(0, 1, 0, 3);
      contextMenu();
      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(2).simulate('mousedown'); // Insert col right

      expect(afterCreateColCallback).toHaveBeenCalledWith(1, 1, 'ContextMenu.columnLeft', undefined, undefined, undefined);
      expect(countCols()).toEqual(5);
      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should insert column on the right of selection when initial data is empty', function () {
      var hot = handsontable({
        rowHeaders: true,
        colHeaders: true,
        data: [],
        dataSchema: [],
        contextMenu: true,
        height: 400
      });

      var afterCreateColCallback = jasmine.createSpy('afterCreateColCallback');
      hot.addHook('afterCreateCol', afterCreateColCallback);

      expect(countCols()).toEqual(0);

      var cell = $('.ht_clone_top_left_corner .htCore').find('thead').find('th').eq(0);

      cell.simulate('mousedown', { which: 3 });
      contextMenu(cell[0]);
      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(3).simulate('mousedown'); // Insert column on the right

      expect(afterCreateColCallback).toHaveBeenCalledWith(0, 1, 'ContextMenu.columnRight', undefined, undefined, undefined);
      expect(countCols()).toEqual(1);
      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should insert column on the right of selection (reverse selection)', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      var afterCreateColCallback = jasmine.createSpy('afterCreateColCallback');
      hot.addHook('afterCreateCol', afterCreateColCallback);

      expect(countCols()).toEqual(4);

      selectCell(0, 3, 0, 1);
      contextMenu();
      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(3).simulate('mousedown'); // Insert col right

      expect(afterCreateColCallback).toHaveBeenCalledWith(4, 1, 'ContextMenu.columnRight', undefined, undefined, undefined);
      expect(countCols()).toEqual(5);
      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should remove selected rows', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      var afterRemoveRowCallback = jasmine.createSpy('afterRemoveRowCallback');
      hot.addHook('afterRemoveRow', afterRemoveRowCallback);

      expect(countRows()).toEqual(4);

      selectCell(1, 0, 3, 0);
      contextMenu();
      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(4).simulate('mousedown'); // Remove row

      expect(afterRemoveRowCallback).toHaveBeenCalledWith(1, 3, [1, 2, 3], 'ContextMenu.removeRow', undefined, undefined);
      expect(countRows()).toEqual(1);
      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should allow to remove the latest row', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(1, 4),
        contextMenu: true,
        height: 100
      });

      var afterRemoveRowCallback = jasmine.createSpy('afterRemoveRowCallback');
      hot.addHook('afterRemoveRow', afterRemoveRowCallback);

      expect(countRows()).toBe(1);

      selectCell(0, 0, 0, 0);
      contextMenu();

      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(4).simulate('mousedown'); // Remove row

      expect(afterRemoveRowCallback).toHaveBeenCalledWith(0, 1, [0], 'ContextMenu.removeRow', undefined, undefined);
      expect(countRows()).toBe(0);
      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should remove selected rows (reverse selection)', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      var afterRemoveRowCallback = jasmine.createSpy('afterRemoveRowCallback');
      hot.addHook('afterRemoveRow', afterRemoveRowCallback);

      expect(countRows()).toBe(4);

      selectCell(3, 0, 1, 0);
      contextMenu();
      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(4).simulate('mousedown'); // Remove row

      expect(afterRemoveRowCallback).toHaveBeenCalledWith(1, 3, [1, 2, 3], 'ContextMenu.removeRow', undefined, undefined);
      expect(countRows()).toBe(1);
      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should remove selected columns', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      var afterRemoveColCallback = jasmine.createSpy('afterRemoveColCallback');
      hot.addHook('afterRemoveCol', afterRemoveColCallback);

      expect(countCols()).toBe(4);

      selectCell(0, 1, 0, 3);
      contextMenu();
      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(5).simulate('mousedown'); // Remove col

      expect(afterRemoveColCallback).toHaveBeenCalledWith(1, 3, [1, 2, 3], 'ContextMenu.removeColumn', undefined, undefined);
      expect(countCols()).toBe(1);
      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should allow to remove the latest column', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 1),
        contextMenu: true,
        height: 100
      });

      var afterRemoveColCallback = jasmine.createSpy('afterRemoveColCallback');
      hot.addHook('afterRemoveCol', afterRemoveColCallback);

      expect(countCols()).toBe(1);

      selectCell(0, 0, 0, 0);
      contextMenu();

      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(5).simulate('mousedown'); // Remove column

      expect(afterRemoveColCallback).toHaveBeenCalledWith(0, 1, [0], 'ContextMenu.removeColumn', undefined, undefined);
      expect(countCols()).toBe(0);
      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should remove selected columns (reverse selection)', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      var afterRemoveColCallback = jasmine.createSpy('afterRemoveColCallback');
      hot.addHook('afterRemoveCol', afterRemoveColCallback);

      expect(countCols()).toEqual(4);

      selectCell(0, 3, 0, 1);

      contextMenu();

      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(5).simulate('mousedown'); // Remove col

      expect(afterRemoveColCallback).toHaveBeenCalledWith(1, 3, [1, 2, 3], 'ContextMenu.removeColumn', undefined, undefined);
      expect(countCols()).toEqual(1);
    });

    it('should undo changes', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      selectCell(0, 0);

      expect(getDataAtCell(0, 0)).toEqual('A1');

      setDataAtCell(0, 0, 'XX');

      expect(getDataAtCell(0, 0)).toEqual('XX');

      contextMenu();

      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(6).simulate('mousedown'); // Undo

      expect(getDataAtCell(0, 0)).toEqual('A1');
    });

    it('should redo changes', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      selectCell(0, 0);

      expect(getDataAtCell(0, 0)).toEqual('A1');

      setDataAtCell(0, 0, 'XX');

      expect(getDataAtCell(0, 0)).toEqual('XX');

      hot.undo();

      expect(getDataAtCell(0, 0)).toEqual('A1');

      contextMenu();

      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(7).simulate('mousedown'); // Redo

      expect(getDataAtCell(0, 0)).toEqual('XX');
    });

    it('should display only the specified actions', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: ['remove_row', 'undo'],
        height: 100
      });

      contextMenu();

      expect($('.htContextMenu .ht_master .htCore').find('tbody td').length).toEqual(2);
    });

    it('should make a single selected cell read-only', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      selectCell(0, 0);

      expect(getDataAtCell(0, 0)).toEqual('A1');
      expect(hot.getCellMeta(0, 0).readOnly).toBe(false);

      selectCell(0, 0);
      contextMenu();
      var menu = $('.htContextMenu .ht_master .htCore tbody');
      menu.find('td').not('.htSeparator').eq(8).simulate('mousedown'); // Make read-only

      expect(hot.getCellMeta(0, 0).readOnly).toBe(true);
    });

    it('should make a single selected cell writable, when it\'s set to read-only', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      selectCell(0, 0);

      expect(getDataAtCell(0, 0)).toEqual('A1');

      hot.getCellMeta(0, 0).readOnly = true;

      selectCell(0, 0);
      contextMenu();
      var menu = $('.htContextMenu .ht_master .htCore tbody');
      menu.find('td').not('.htSeparator').eq(8).simulate('mousedown');
      //      $(hot.contextMenu.menu).find('tbody td').not('.htSeparator').eq(8).trigger('mousedown'); //Make writable

      expect(hot.getCellMeta(0, 0).readOnly).toBe(false);
    });

    it('should make a group of selected cells read-only, if all of them are writable', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      for (var i = 0; i < 2; i++) {
        for (var j = 0; j < 2; j++) {
          expect(hot.getCellMeta(i, j).readOnly).toEqual(false);
        }
      }

      selectCell(0, 0, 2, 2);

      contextMenu();
      var menu = $('.htContextMenu .ht_master .htCore tbody');
      menu.find('td').not('.htSeparator').eq(8).simulate('mousedown');
      //      $(hot.contextMenu.menu).find('tbody td').not('.htSeparator').eq(8).trigger('mousedown'); //Make read-only

      for (var _i = 0; _i < 2; _i++) {
        for (var _j = 0; _j < 2; _j++) {
          expect(hot.getCellMeta(_i, _j).readOnly).toEqual(true);
        }
      }
    });

    it('should not close menu after clicking on submenu root item', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: ['row_above', 'remove_row', '---------', 'alignment'],
        height: 400
      });

      selectCell(1, 0, 3, 0);
      contextMenu();

      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(2).simulate('mousedown'); // Alignment
      expect($('.htContextMenu').is(':visible')).toBe(true);
    });

    it('should make a group of selected cells read-only, if all of them are writable (reverse selection)', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      for (var i = 0; i < 2; i++) {
        for (var j = 0; j < 2; j++) {
          expect(hot.getCellMeta(i, j).readOnly).toEqual(false);
        }
      }

      selectCell(2, 2, 0, 0);

      contextMenu();

      var menu = $('.htContextMenu .ht_master .htCore tbody');
      menu.find('td').not('.htSeparator').eq(8).simulate('mousedown'); // Make read-only

      for (var _i2 = 0; _i2 < 2; _i2++) {
        for (var _j2 = 0; _j2 < 2; _j2++) {
          expect(hot.getCellMeta(_i2, _j2).readOnly).toEqual(true);
        }
      }
    });

    it('should make a group of selected cells writable if at least one of them is read-only', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      for (var i = 0; i < 2; i++) {
        for (var j = 0; j < 2; j++) {
          expect(hot.getCellMeta(i, j).readOnly).toEqual(false);
        }
      }

      hot.getCellMeta(1, 1).readOnly = true;

      selectCell(0, 0, 2, 2);

      contextMenu();
      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(8).simulate('mousedown'); // Make writable

      for (var _i3 = 0; _i3 < 2; _i3++) {
        for (var _j3 = 0; _j3 < 2; _j3++) {
          expect(hot.getCellMeta(_i3, _j3).readOnly).toEqual(false);
        }
      }
    });

    it('should make a group of selected cells writable if at least one of them is read-only (reverse selection)', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: true,
        height: 100
      });

      for (var i = 0; i < 2; i++) {
        for (var j = 0; j < 2; j++) {
          expect(hot.getCellMeta(i, j).readOnly).toEqual(false);
        }
      }

      hot.getCellMeta(1, 1).readOnly = true;

      selectCell(2, 2, 0, 0);

      contextMenu();
      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(8).simulate('mousedown'); // Make writable

      for (var _i4 = 0; _i4 < 2; _i4++) {
        for (var _j4 = 0; _j4 < 2; _j4++) {
          expect(hot.getCellMeta(_i4, _j4).readOnly).toEqual(false);
        }
      }
    });
  });

  describe('disabling actions', function () {
    it('should not close menu after clicking on disabled item', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(4, 4),
        contextMenu: ['undo', 'redo'],
        height: 400
      });

      selectCell(1, 0, 3, 0);
      contextMenu();

      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(0).simulate('mousedown'); // Undo
      expect($('.htContextMenu').is(':visible')).toBe(true);
    });

    it('should disable undo and redo action if undoRedo plugin is not enabled ', function () {
      var hot = handsontable({
        contextMenu: true,
        undoRedo: false,
        height: 100
      });

      contextMenu();
      var $menu = $('.htContextMenu .ht_master .htCore');

      expect($menu.find('tbody td:eq(9)').text()).toEqual('Undo');
      expect($menu.find('tbody td:eq(9)').hasClass('htDisabled')).toBe(true);
      expect($menu.find('tbody td:eq(10)').text()).toEqual('Redo');
      expect($menu.find('tbody td:eq(10)').hasClass('htDisabled')).toBe(true);
    });

    it('should disable undo when there is nothing to undo ', function () {
      var hot = handsontable({
        contextMenu: true,
        height: 100
      });

      contextMenu();
      var $menu = $('.htContextMenu .ht_master .htCore');

      expect(hot.undoRedo.isUndoAvailable()).toBe(false);
      expect($menu.find('tbody td:eq(9)').text()).toEqual('Undo');
      expect($menu.find('tbody td:eq(9)').hasClass('htDisabled')).toBe(true);

      closeContextMenu();

      setDataAtCell(0, 0, 'foo');

      contextMenu();
      $menu = $('.htContextMenu .ht_master .htCore');
      expect(hot.undoRedo.isUndoAvailable()).toBe(true);
      expect($menu.find('tbody td:eq(9)').hasClass('htDisabled')).toBe(false);
    });

    it('should disable redo when there is nothing to redo ', function () {
      var hot = handsontable({
        contextMenu: true,
        height: 100
      });

      contextMenu();
      var $menu = $('.htContextMenu .ht_master .htCore');

      expect(hot.undoRedo.isRedoAvailable()).toBe(false);
      expect($menu.find('tbody td:eq(10)').text()).toEqual('Redo');
      expect($menu.find('tbody td:eq(10)').hasClass('htDisabled')).toBe(true);

      closeContextMenu();

      setDataAtCell(0, 0, 'foo');
      hot.undo();

      contextMenu();
      $menu = $('.htContextMenu .ht_master .htCore');
      expect(hot.undoRedo.isRedoAvailable()).toBe(true);
      expect($menu.find('tbody td:eq(10)').hasClass('htDisabled')).toBe(false);
    });

    it('should disable Insert row in context menu when maxRows is reached', function () {
      var hot = handsontable({
        contextMenu: true,
        maxRows: 6,
        height: 100
      });

      contextMenu();
      var $menu = $('.htContextMenu .ht_master .htCore');

      expect($menu.find('tbody td:eq(0)').text()).toEqual('Insert row above');
      expect($menu.find('tbody td:eq(0)').hasClass('htDisabled')).toBe(false);
      expect($menu.find('tbody td:eq(1)').text()).toEqual('Insert row below');
      expect($menu.find('tbody td:eq(1)').hasClass('htDisabled')).toBe(false);

      closeContextMenu();

      alter('insert_row');

      contextMenu();
      $menu = $('.htContextMenu .ht_master .htCore');

      expect($menu.find('tbody td:eq(0)').hasClass('htDisabled')).toBe(true);
      expect($menu.find('tbody td:eq(1)').hasClass('htDisabled')).toBe(true);
    });

    it('should disable Insert col in context menu when maxCols is reached', function () {
      var hot = handsontable({
        contextMenu: true,
        maxCols: 6,
        height: 100
      });

      contextMenu();
      var $menu = $('.htContextMenu .ht_master .htCore');

      expect($menu.find('tbody td:eq(3)').text()).toEqual('Insert column on the left');
      expect($menu.find('tbody td:eq(3)').hasClass('htDisabled')).toBe(false);
      expect($menu.find('tbody td:eq(4)').text()).toEqual('Insert column on the right');
      expect($menu.find('tbody td:eq(4)').hasClass('htDisabled')).toBe(false);

      closeContextMenu();

      alter('insert_col');

      contextMenu();
      $menu = $('.htContextMenu .ht_master .htCore');
      expect($menu.find('tbody td:eq(3)').hasClass('htDisabled')).toBe(true);
      expect($menu.find('tbody td:eq(4)').hasClass('htDisabled')).toBe(true);
    });

    it('should NOT disable Insert col in context menu when only one column exists', function () {
      var hot = handsontable({
        data: [['single col']],
        contextMenu: true,
        maxCols: 10,
        height: 100
      });

      selectCell(0, 0);
      contextMenu();
      var $menu = $('.htContextMenu .ht_master .htCore');

      expect($menu.find('tbody td:eq(3)').text()).toEqual('Insert column on the left');
      expect($menu.find('tbody td:eq(3)').hasClass('htDisabled')).toBe(false);
      expect($menu.find('tbody td:eq(4)').text()).toEqual('Insert column on the right');
      expect($menu.find('tbody td:eq(4)').hasClass('htDisabled')).toBe(false);
    });

    it('should disable Remove col in context menu when rows are selected by headers', function () {
      var hot = handsontable({
        contextMenu: ['remove_col', 'remove_row'],
        height: 100,
        colHeaders: true,
        rowHeaders: true
      });
      var $rowsHeaders = this.$container.find('.ht_clone_left tr th');

      $rowsHeaders.eq(1).simulate('mousedown');
      $rowsHeaders.eq(2).simulate('mouseover');
      $rowsHeaders.eq(3).simulate('mouseover');
      $rowsHeaders.eq(3).simulate('mousemove');
      $rowsHeaders.eq(3).simulate('mouseup');

      contextMenu();
      var $menu = $('.htContextMenu .ht_master .htCore');

      expect($menu.find('tbody td:eq(0)').text()).toEqual('Remove column');
      expect($menu.find('tbody td:eq(0)').hasClass('htDisabled')).toBe(true);
    });

    it('should disable Remove row in context menu when columns are selected by headers', function () {
      var hot = handsontable({
        contextMenu: ['remove_col', 'remove_row'],
        height: 100,
        colHeaders: true,
        rowHeaders: true
      });

      this.$container.find('thead tr:eq(0) th:eq(1)').simulate('mousedown');
      this.$container.find('thead tr:eq(0) th:eq(2)').simulate('mouseover');
      this.$container.find('thead tr:eq(0) th:eq(3)').simulate('mouseover');
      this.$container.find('thead tr:eq(0) th:eq(3)').simulate('mousemove');
      this.$container.find('thead tr:eq(0) th:eq(3)').simulate('mouseup');

      contextMenu();
      var $menu = $('.htContextMenu .ht_master .htCore');

      expect($menu.find('tbody td:eq(1)').text()).toEqual('Remove row');
      expect($menu.find('tbody td:eq(1)').hasClass('htDisabled')).toBe(true);
    });
  });

  describe('custom options', function () {
    it('should have custom items list', function () {

      var callback1 = jasmine.createSpy('callback1');
      var callback2 = jasmine.createSpy('callback2');

      var hot = handsontable({
        contextMenu: {
          items: {
            cust1: {
              name: 'CustomItem1',
              callback: callback1
            },
            cust2: {
              name: 'CustomItem2',
              callback: callback2
            }
          }
        },
        height: 100
      });

      contextMenu();

      expect($('.htContextMenu .ht_master .htCore').find('tbody td').length).toEqual(2);
      expect($('.htContextMenu .ht_master .htCore').find('tbody td').text()).toEqual(['CustomItem1', 'CustomItem2'].join(''));

      $('.htContextMenu .ht_master .htCore').find('tbody td:eq(0)').simulate('mousedown');

      expect(callback1.calls.count()).toEqual(1);
      expect(callback2.calls.count()).toEqual(0);

      contextMenu();
      $('.htContextMenu .ht_master .htCore').find('tbody td:eq(1)').simulate('mousedown');

      expect(callback1.calls.count()).toEqual(1);
      expect(callback2.calls.count()).toEqual(1);
    });

    it('should have custom items list (defined as a function)', function () {
      var enabled = false;
      var hot = handsontable({
        contextMenu: {
          items: {
            cust1: {
              name: function name() {
                if (!enabled) {
                  return 'Enable my custom option';
                }
                return 'Disable my custom option';
              },
              callback: function callback() {}
            }
          }
        },
        height: 100
      });

      contextMenu();

      expect($('.htContextMenu .ht_master .htCore').find('tbody td').text()).toEqual('Enable my custom option');

      $('.htContextMenu .ht_master .htCore').find('tbody td:eq(0)').simulate('mousedown');

      enabled = true;
      contextMenu();

      expect($('.htContextMenu .ht_master .htCore').find('tbody td').text()).toEqual('Disable my custom option');

      $('.htContextMenu .ht_master .htCore').find('tbody td:eq(0)').simulate('mousedown');
    });

    it('should enable to define item options globally', function () {

      var callback = jasmine.createSpy('callback');

      var hot = handsontable({
        contextMenu: {
          callback: callback,
          items: {
            cust1: {
              name: 'CustomItem1'
            },
            cust2: {
              name: 'CustomItem2'
            }
          }
        },
        height: 100
      });

      contextMenu();

      $('.htContextMenu .ht_master .htCore').find('tbody td:eq(0)').simulate('mousedown');

      expect(callback.calls.count()).toEqual(1);

      contextMenu();
      $('.htContextMenu .ht_master .htCore').find('tbody td:eq(1)').simulate('mousedown');

      expect(callback.calls.count()).toEqual(2);
    });

    it('should override default items options', function () {
      var callback = jasmine.createSpy('callback');

      var hot = handsontable({
        contextMenu: {
          items: {
            remove_row: {
              callback: callback
            },
            remove_col: {
              name: 'Delete column'
            }
          }
        },
        height: 100
      });

      contextMenu();

      expect($('.htContextMenu .ht_master .htCore').find('tbody td').length).toEqual(2);
      expect($('.htContextMenu .ht_master .htCore').find('tbody td').text()).toEqual(['Remove row', 'Delete column'].join(''));

      $('.htContextMenu .ht_master .htCore').find('tbody td:eq(0)').simulate('mousedown');

      expect(callback.calls.count()).toEqual(1);

      expect(countCols()).toEqual(5);

      contextMenu();
      $('.htContextMenu .ht_master .htCore').find('tbody td:eq(1)').simulate('mousedown');

      expect(countCols()).toEqual(4);
    });

    it('should fire item callback after item has been clicked', function () {
      var customItem = {
        name: 'Custom item',
        callback: function callback() {}
      };

      spyOn(customItem, 'callback');

      var hot = handsontable({
        contextMenu: {
          items: {
            customItemKey: customItem
          }
        },
        height: 100
      });

      contextMenu();

      $('.htContextMenu .ht_master .htCore').find('tbody td:eq(0)').simulate('mousedown');

      expect(customItem.callback.calls.count()).toEqual(1);
      expect(customItem.callback.calls.argsFor(0)[0]).toEqual('customItemKey');
    });
  });

  describe('keyboard navigation', function () {
    describe('no item selected', function () {
      it('should select the first item in menu, when user hits ARROW_DOWN', function () {
        var hot = handsontable({
          contextMenu: true,
          height: 100
        });

        contextMenu();
        var menuHot = hot.getPlugin('contextMenu').menu.hotMenu;

        expect(menuHot.getSelected()).toBeUndefined();

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toEqual([0, 0, 0, 0]);
      });

      it('should scroll down, when user hits ARROW_DOWN for item in menu below the viewport', function () {
        var hot = handsontable({
          height: 100,
          contextMenu: {
            items: {
              item1: {
                name: 'Item1'
              },
              item2: {
                name: 'Item2'
              },
              item3: {
                name: 'Item3'
              },
              item4: {
                name: 'Item4'
              },
              item5: {
                name: 'Item5'
              },
              item6: {
                name: 'Item6'
              },
              item7: {
                name: 'Item7'
              },
              item8: {
                name: 'Item8'
              },
              item9: {
                name: 'Item9'
              },
              item10: {
                name: 'Item10'
              },
              item11: {
                name: 'Item11'
              },
              item12: {
                name: 'Item12'
              },
              item13: {
                name: 'Item13'
              },
              item14: {
                name: 'Item14'
              },
              item15: {
                name: 'Item15'
              },
              item16: {
                name: 'Item16'
              },
              item17: {
                name: 'Item17'
              },
              item18: {
                name: 'Item18'
              },
              item19: {
                name: 'Item19'
              },
              item20: {
                name: 'Item20'
              },
              item21: {
                name: 'Item21'
              },
              item22: {
                name: 'Item22'
              },
              item23: {
                name: 'Item23'
              },
              item24: {
                name: 'Item24'
              },
              item25: {
                name: 'Item25'
              },
              item26: {
                name: 'Item26'
              },
              item27: {
                name: 'Item27'
              },
              item28: {
                name: 'Item28'
              },
              item29: {
                name: 'Item29'
              },
              item30: {
                name: 'Item30'
              },
              item31: {
                name: 'Item31'
              },
              item32: {
                name: 'Item32'
              },
              item33: {
                name: 'Item33'
              },
              item34: {
                name: 'Item34'
              },
              item35: {
                name: 'Item35'
              },
              item36: {
                name: 'Item36'
              },
              item37: {
                name: 'Item37'
              },
              item38: {
                name: 'Item38'
              },
              item39: {
                name: 'Item39'
              },
              item40: {
                name: 'Item40'
              }
            }
          }
        }),
            scrollHeight;

        contextMenu();

        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');

        if (typeof window.scrollY !== 'undefined') {
          scrollHeight = window.scrollY;
        } else {
          scrollHeight = document.documentElement.scrollTop;
        }

        expect(scrollHeight).not.toBe(0);
      });

      it('should select the first NOT DISABLED item in menu, when user hits ARROW_DOWN', function () {
        var hot = handsontable({
          contextMenu: {
            items: {
              item1: {
                name: 'Item1',
                disabled: true
              },
              item2: {
                name: 'Item2',
                disabled: true
              },
              item3: {
                name: 'Item3'
              }
            }
          },
          height: 100
        });

        contextMenu();

        var menuHot = hot.getPlugin('contextMenu').menu.hotMenu;

        expect(menuHot.getSelected()).toBeUndefined();

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toEqual([2, 0, 2, 0]);
      });

      it('should NOT select any items in menu, when user hits ARROW_DOWN and there is no items enabled', function () {
        var hot = handsontable({
          contextMenu: {
            items: {
              item1: {
                name: 'Item1',
                disabled: true
              },
              item2: {
                name: 'Item2',
                disabled: true
              },
              item3: {
                name: 'Item3',
                disabled: true
              }
            }
          },
          height: 100
        });

        contextMenu();
        var menuHot = hot.getPlugin('contextMenu').menu.hotMenu;

        expect(menuHot.getSelected()).toBeUndefined();

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toBeUndefined();
      });

      it('should select the last item in menu, when user hits ARROW_UP', function () {
        var hot = handsontable({
          contextMenu: {
            items: {
              item1: 'Item1',
              item2: 'Item2',
              item3: 'Item3'
            }
          },
          height: 100
        });

        contextMenu();
        var menuHot = hot.getPlugin('contextMenu').menu.hotMenu;

        expect(menuHot.getSelected()).toBeUndefined();

        keyDownUp('arrow_up');

        expect(menuHot.getSelected()).toEqual([2, 0, 2, 0]);
      });

      it('should select the last NOT DISABLED item in menu, when user hits ARROW_UP', function () {
        var hot = handsontable({
          contextMenu: {
            items: {
              item1: {
                name: 'Item1'
              },
              item2: {
                name: 'Item2',
                disabled: true
              },
              item3: {
                name: 'Item3',
                disabled: true
              }
            }
          },
          height: 100
        });

        contextMenu();
        var menuHot = hot.getPlugin('contextMenu').menu.hotMenu;

        expect(menuHot.getSelected()).toBeUndefined();

        keyDownUp('arrow_up');

        expect(menuHot.getSelected()).toEqual([0, 0, 0, 0]);
      });

      it('should NOT select any items in menu, when user hits ARROW_UP and there is no items enabled', function () {
        var hot = handsontable({
          contextMenu: {
            items: {
              item1: {
                name: 'Item1',
                disabled: true
              },
              item2: {
                name: 'Item2',
                disabled: true
              },
              item3: {
                name: 'Item3',
                disabled: true
              }
            }
          },
          height: 100
        });

        contextMenu();
        var id = $('.htContextMenu')[0].id;
        var menuHot = hot.getPlugin('contextMenu').menu.hotMenu;

        expect(menuHot.getSelected()).toBeUndefined();

        keyDownUp('arrow_up');

        expect(menuHot.getSelected()).toBeUndefined();
      });
    });

    describe('item selected', function () {
      it('should select next item when user hits ARROW_DOWN', function () {
        var hot = handsontable({
          contextMenu: {
            items: {
              item1: {
                name: 'Item1'
              },
              item2: {
                name: 'Item2'
              },
              item3: {
                name: 'Item3'
              }
            }
          },
          height: 100
        });

        contextMenu();
        var menuHot = hot.getPlugin('contextMenu').menu.hotMenu;

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toEqual([0, 0, 0, 0]);

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toEqual([1, 0, 1, 0]);

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toEqual([2, 0, 2, 0]);
      });

      it('should select next item (skipping disabled items) when user hits ARROW_DOWN', function () {
        var hot = handsontable({
          contextMenu: {
            items: {
              item1: {
                name: 'Item1'
              },
              item2: {
                name: 'Item2',
                disabled: true
              },
              item3: {
                name: 'Item3'
              }
            }
          },
          height: 100
        });

        contextMenu();
        var menuHot = hot.getPlugin('contextMenu').menu.hotMenu;

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toEqual([0, 0, 0, 0]);

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toEqual([2, 0, 2, 0]);
      });

      it('should select next item (skipping separators) when user hits ARROW_DOWN', function () {
        var hot = handsontable({
          contextMenu: {
            items: {
              item1: {
                name: 'Item1'
              },
              sep1: Handsontable.plugins.ContextMenu.SEPARATOR,
              item2: {
                name: 'Item2'
              },
              item3: {
                name: 'Item3'
              }
            }
          },
          height: 100
        });

        contextMenu();
        var menuHot = hot.getPlugin('contextMenu').menu.hotMenu;

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toEqual([0, 0, 0, 0]);

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toEqual([2, 0, 2, 0]);

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toEqual([3, 0, 3, 0]);
      });

      it('should not change selection when last item is selected and user hits ARROW_DOWN', function () {
        var hot = handsontable({
          contextMenu: {
            items: {
              item1: {
                name: 'Item1'
              },
              item2: {
                name: 'Item2'
              },
              item3: {
                name: 'Item3'
              }
            }
          },
          height: 100
        });

        contextMenu();
        var menuHot = hot.getPlugin('contextMenu').menu.hotMenu;

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toEqual([0, 0, 0, 0]);

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toEqual([1, 0, 1, 0]);

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toEqual([2, 0, 2, 0]);

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toEqual([2, 0, 2, 0]);
      });

      it('should not change selection when last enabled item is selected and user hits ARROW_DOWN', function () {
        var hot = handsontable({
          contextMenu: {
            items: {
              item1: {
                name: 'Item1'
              },
              item2: {
                name: 'Item2'
              },
              item3: {
                name: 'Item3',
                disabled: true
              }
            }
          },
          height: 100
        });

        contextMenu();
        var menuHot = hot.getPlugin('contextMenu').menu.hotMenu;

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toEqual([0, 0, 0, 0]);

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toEqual([1, 0, 1, 0]);

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toEqual([1, 0, 1, 0]);
      });

      it('should select next item when user hits ARROW_UP', function () {
        var hot = handsontable({
          contextMenu: {
            items: {
              item1: {
                name: 'Item1'
              },
              item2: {
                name: 'Item2'
              },
              item3: {
                name: 'Item3'
              }
            }
          },
          height: 100
        });

        contextMenu();
        var menuHot = hot.getPlugin('contextMenu').menu.hotMenu;

        keyDownUp('arrow_up');

        expect(menuHot.getSelected()).toEqual([2, 0, 2, 0]);

        keyDownUp('arrow_up');

        expect(menuHot.getSelected()).toEqual([1, 0, 1, 0]);

        keyDownUp('arrow_up');

        expect(menuHot.getSelected()).toEqual([0, 0, 0, 0]);
      });

      it('should select next item (skipping disabled items) when user hits ARROW_UP', function () {
        var hot = handsontable({
          contextMenu: {
            items: {
              item1: {
                name: 'Item1'
              },
              item2: {
                name: 'Item2',
                disabled: true
              },
              item3: {
                name: 'Item3'
              }
            }
          },
          height: 100
        });

        contextMenu();
        var menuHot = hot.getPlugin('contextMenu').menu.hotMenu;

        keyDownUp('arrow_up');

        expect(menuHot.getSelected()).toEqual([2, 0, 2, 0]);

        keyDownUp('arrow_up');

        expect(menuHot.getSelected()).toEqual([0, 0, 0, 0]);
      });

      it('should select next item (skipping separators) when user hits ARROW_UP', function () {
        var hot = handsontable({
          contextMenu: {
            items: {
              item1: {
                name: 'Item1'
              },
              sep1: Handsontable.plugins.ContextMenu.SEPARATOR,
              item2: {
                name: 'Item2'
              },
              item3: {
                name: 'Item3'
              }
            }
          },
          height: 100
        });

        contextMenu();
        var menuHot = hot.getPlugin('contextMenu').menu.hotMenu;

        keyDownUp('arrow_up');

        expect(menuHot.getSelected()).toEqual([3, 0, 3, 0]);

        keyDownUp('arrow_up');

        expect(menuHot.getSelected()).toEqual([2, 0, 2, 0]);

        keyDownUp('arrow_up');

        expect(menuHot.getSelected()).toEqual([0, 0, 0, 0]);
      });

      it('should not change selection when first item is selected and user hits ARROW_UP', function () {
        var hot = handsontable({
          contextMenu: {
            items: {
              item1: {
                name: 'Item1'
              },
              item2: {
                name: 'Item2'
              },
              item3: {
                name: 'Item3'
              }
            }
          },
          height: 100
        });

        contextMenu();
        var menuHot = hot.getPlugin('contextMenu').menu.hotMenu;

        keyDownUp('arrow_up');

        expect(menuHot.getSelected()).toEqual([2, 0, 2, 0]);

        keyDownUp('arrow_up');

        expect(menuHot.getSelected()).toEqual([1, 0, 1, 0]);

        keyDownUp('arrow_up');

        expect(menuHot.getSelected()).toEqual([0, 0, 0, 0]);

        keyDownUp('arrow_up');

        expect(menuHot.getSelected()).toEqual([0, 0, 0, 0]);
      });

      it('should not change selection when first enabled item is selected and user hits ARROW_UP', function () {
        var hot = handsontable({
          contextMenu: {
            items: {
              item1: {
                name: 'Item1',
                disabled: true
              },
              item2: {
                name: 'Item2'
              },
              item3: {
                name: 'Item3'
              }
            }
          },
          height: 100
        });

        contextMenu();
        var menuHot = hot.getPlugin('contextMenu').menu.hotMenu;

        keyDownUp('arrow_up');

        expect(menuHot.getSelected()).toEqual([2, 0, 2, 0]);

        keyDownUp('arrow_up');

        expect(menuHot.getSelected()).toEqual([1, 0, 1, 0]);

        keyDownUp('arrow_up');

        expect(menuHot.getSelected()).toEqual([1, 0, 1, 0]);
      });

      it('should perform a selected item action, when user hits ENTER', function () {
        var itemAction = jasmine.createSpy('itemAction');
        var hot = handsontable({
          contextMenu: {
            items: {
              item1: {
                name: 'Item1',
                callback: itemAction
              },
              item2: 'Item2'
            }
          },
          height: 100
        });

        contextMenu();
        var menuHot = hot.getPlugin('contextMenu').menu.hotMenu;

        keyDownUp('arrow_down');

        expect(menuHot.getSelected()).toEqual([0, 0, 0, 0]);

        expect(itemAction).not.toHaveBeenCalled();

        keyDownUp('enter');

        expect(itemAction).toHaveBeenCalled();
        expect($(hot.getPlugin('contextMenu').menu).is(':visible')).toBe(false);
      });
    });

    it('should close menu when user hits ESC', function () {
      handsontable({
        contextMenu: true,
        height: 100
      });

      contextMenu();

      expect($('.htContextMenu').is(':visible')).toBe(true);

      keyDownUp('esc');

      expect($('.htContextMenu').is(':visible')).toBe(false);
    });

    it('should close sub-menu and parent menu in proper order when user hits ESC twice', function (done) {
      handsontable({
        contextMenu: true,
        height: 100
      });

      contextMenu();

      var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(9);
      var contextMenuRoot = $('.htContextMenu');

      item.simulate('mouseover');

      setTimeout(function () {
        expect($('.htContextMenuSub_Alignment').is(':visible')).toBe(true);

        keyDownUp('esc');

        expect($('.htContextMenuSub_Alignment').is(':visible')).toBe(false);

        keyDownUp('esc');

        expect($('.htContextMenu').is(':visible')).toBe(false);
        done();
      }, 350); // waits for submenu open delay
    });
  });

  describe('mouse navigation', function () {
    it('should not scroll window position after fireing mouseenter on menu item', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(1000, 5),
        contextMenu: true
      }),
          scrollHeight;

      hot.selectCell(100, 0);
      contextMenu();
      window.scrollTo(0, 0);
      $('.htContextMenu .ht_master .htCore').find('tr td:eq("0")').simulate('mouseenter');

      if (typeof window.scrollY !== 'undefined') {
        scrollHeight = window.scrollY;
      } else {
        scrollHeight = document.documentElement.scrollTop;
      }

      expect(scrollHeight).toBe(0);
    });

    it('should not scroll window position after fireing click on menu', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(1000, 5),
        contextMenu: {
          items: {
            item1: {
              name: 'Item1'
            },
            sep1: Handsontable.plugins.ContextMenu.SEPARATOR,
            item2: {
              name: 'Item2'
            },
            item3: {
              name: 'Item3'
            }
          }
        }
      }),
          scrollHeight;

      hot.selectCell(100, 0);
      contextMenu();
      window.scrollTo(0, 0);
      $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(0).simulate('mousedown');

      if (typeof window.scrollY !== 'undefined') {
        scrollHeight = window.scrollY;
      } else {
        scrollHeight = document.documentElement.scrollTop;
      }

      expect(scrollHeight).toBe(0);
    });
  });

  describe('working with multiple tables', function () {
    beforeEach(function () {
      this.$container2 = $('<div id="' + id + '-2"></div>').appendTo('body');
    });

    afterEach(function () {
      if (this.$container2) {
        this.$container2.handsontable('destroy');
        this.$container2.remove();
      }
    });

    it('should apply enabling/disabling contextMenu using updateSetting only to particular instance of HOT ', function () {
      var hot1 = handsontable({
        contextMenu: false,
        height: 100
      });
      var hot2 = this.$container2.handsontable({
        contextMenu: true,
        height: 100
      });

      hot2 = hot2.handsontable('getInstance');
      var contextMenuContainer = $('.htContextMenu');

      contextMenu();
      expect(hot1.getPlugin('contextMenu').isEnabled()).toBe(false);
      expect(contextMenuContainer.is(':visible')).toBe(false);

      contextMenu2();
      expect(hot2.getPlugin('contextMenu').isEnabled()).toBe(true);
      expect($('.htContextMenu').is(':visible')).toBe(true);

      mouseDown(hot2.rootElement); // close menu

      hot1.updateSettings({
        contextMenu: true
      });
      hot2.updateSettings({
        contextMenu: false
      });

      contextMenu2();
      expect(hot2.getPlugin('contextMenu').isEnabled()).toBe(false);

      contextMenu();
      expect($('.htContextMenu').is(':visible')).toBe(true);

      function contextMenu2() {
        var hot = spec().$container2.data('handsontable');
        var selected = hot.getSelected();

        if (!selected) {
          hot.selectCell(0, 0);
          selected = hot.getSelected();
        }

        var cell = hot.getCell(selected[0], selected[1]);
        var cellOffset = $(cell).offset();

        $(cell).simulate('contextmenu', {
          pageX: cellOffset.left,
          pageY: cellOffset.top
        });
      }
    });

    it('should perform a contextMenu action only for particular instance of HOT ', function () {
      var hot1 = handsontable({
        contextMenu: true,
        height: 100
      });

      var hot2 = this.$container2.handsontable({
        contextMenu: true,
        height: 100
      });

      hot2 = hot2.handsontable('getInstance');

      hot1.selectCell(0, 0);
      contextMenu();

      expect(hot1.countRows()).toEqual(5);
      expect(hot2.countRows()).toEqual(5);

      $('.htContextMenu .ht_master .htCore').find('tr td:eq("0")').simulate('mousedown'); // insert row above

      expect(hot1.countRows()).toEqual(6);
      expect(hot2.countRows()).toEqual(5);

      hot2.selectCell(0, 0);
      contextMenu2();

      expect(hot1.countRows()).toEqual(6);
      expect(hot2.countRows()).toEqual(5);

      $('.htContextMenu .ht_master .htCore').find('tr td:eq("0")').simulate('mousedown'); // insert row above

      expect(hot1.countRows()).toEqual(6);
      expect(hot2.countRows()).toEqual(6);

      function contextMenu2() {
        var hot = spec().$container2.data('handsontable');
        var selected = hot.getSelected();

        if (!selected) {
          hot.selectCell(0, 0);
          selected = hot.getSelected();
        }

        var cell = hot.getCell(selected[0], selected[1]);
        var cellOffset = $(cell).offset();

        $(cell).simulate('contextmenu', {
          pageX: cellOffset.left,
          pageY: cellOffset.top
        });
      }
    });
  });

  describe('context menu with native scroll', function () {
    beforeEach(function () {
      var wrapper = $('<div></div>').css({
        width: 400,
        height: 200,
        overflow: 'scroll'
      });

      this.$wrapper = this.$container.wrap(wrapper).parent();
    });

    afterEach(function () {
      if (this.$container) {
        destroy();
        this.$container.remove();
      }
      this.$wrapper.remove();
    });

    it('should display menu table is not scrolled', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(40, 30),
        colWidths: 50, // can also be a number or a function
        rowHeaders: true,
        colHeaders: true,
        contextMenu: true,
        height: 100
      });

      contextMenu();
      expect($('.htContextMenu').is(':visible')).toBe(true);
    });

    it('should display menu table is scrolled', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(40, 30),
        colWidths: 50, // can also be a number or a function
        rowHeaders: true,
        colHeaders: true,
        contextMenu: true,
        height: 100
      });

      var mainHolder = hot.view.wt.wtTable.holder;

      $(mainHolder).scrollTop(300);
      $(mainHolder).scroll();

      selectCell(15, 3);
      contextMenu();

      expect($('.htContextMenu').is(':visible')).toBe(true);
    });

    it('should not close the menu, when table is scrolled', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(40, 30),
        colWidths: 50, // can also be a number or a function
        rowHeaders: true,
        colHeaders: true,
        contextMenu: true,
        height: 100
      });

      var $mainHolder = $(hot.view.wt.wtTable.holder);

      selectCell(15, 3);
      var scrollTop = $mainHolder.scrollTop();
      contextMenu();

      expect($('.htContextMenu').is(':visible')).toBe(true);

      $mainHolder.scrollTop(scrollTop + 60).scroll();

      expect($('.htContextMenu').is(':visible')).toBe(true);

      contextMenu();

      expect($('.htContextMenu').is(':visible')).toBe(true);

      $mainHolder.scrollTop(scrollTop + 100).scroll();

      expect($('.htContextMenu').is(':visible')).toBe(true);
    });

    it('should not attempt to close menu, when table is scrolled and the menu is already closed', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(40, 30),
        colWidths: 50, // can also be a number or a function
        rowHeaders: true,
        colHeaders: true,
        contextMenu: true,
        height: 100
      });

      var mainHolder = $(hot.view.wt.wtTable.holder);

      selectCell(15, 3);
      var scrollTop = mainHolder.scrollTop();
      contextMenu();
      var $menu = $('.htContextMenu');

      spyOn(hot.getPlugin('contextMenu'), 'close');

      mainHolder.scrollTop(scrollTop + 100).scroll();

      expect(hot.getPlugin('contextMenu').close).not.toHaveBeenCalled();
    });

    it('should not scroll the window when hovering over context menu items (#1897 reopen)', function () {
      this.$wrapper.css('overflow', 'visible');

      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(403, 303),
        colWidths: 50, // can also be a number or a function
        contextMenu: true
      });

      var beginningScrollX = window.scrollX;

      selectCell(2, 4);
      contextMenu();

      var cmInstance = hot.getPlugin('contextMenu').menu.hotMenu;

      cmInstance.selectCell(3, 0);
      expect(window.scrollX).toEqual(beginningScrollX);

      cmInstance.selectCell(4, 0);
      expect(window.scrollX).toEqual(beginningScrollX);

      cmInstance.selectCell(6, 0);
      expect(window.scrollX).toEqual(beginningScrollX);
    });
  });

  describe('afterContextMenuDefaultOptions hook', function () {
    it('should call afterContextMenuDefaultOptions hook with context menu options as the first param', function () {
      var options;

      var afterContextMenuDefaultOptions = function afterContextMenuDefaultOptions(options_) {
        options = options_;
        options.items.cust1 = {
          name: 'My custom item',
          callback: function callback() {}
        };
      };

      Handsontable.hooks.add('afterContextMenuDefaultOptions', afterContextMenuDefaultOptions);

      var hot = handsontable({
        contextMenu: true,
        height: 100
      });

      contextMenu();

      var $menu = $('.htContextMenu .ht_master .htCore');

      expect(options).toBeDefined();
      expect(options.items).toBeDefined();
      expect($menu.find('tbody td').text()).toContain('My custom item');

      $menu.find('tbody td:eq(0)').simulate('mousedown');

      Handsontable.hooks.remove('afterContextMenuDefaultOptions', afterContextMenuDefaultOptions);
    });
  });

  describe('beforeContextMenuSetItems hook', function () {
    it('should add new menu item even when item is excluded from plugin settings', function () {
      Handsontable.hooks.add('beforeContextMenuSetItems', function (options) {
        if (this === hot || !hot) {
          options.push({
            key: 'test',
            name: 'Test'
          });
        }
      });

      var hot = handsontable({
        contextMenu: ['make_read_only'],
        height: 100
      });

      contextMenu();

      var items = $('.htContextMenu tbody td');
      var actions = items.not('.htSeparator');

      expect(actions.text()).toEqual(['Read only', 'Test'].join(''));
    });

    it('should be called only with items selected in plugin settings', function () {
      var keys = [];

      Handsontable.hooks.add('beforeContextMenuSetItems', function (items) {
        if (this === hot || !hot) {
          keys = items.map(function (v) {
            return v.key;
          });
        }
      });

      var hot = handsontable({
        contextMenu: ['make_read_only', 'col_left'],
        height: 100
      });

      contextMenu();

      expect(keys).toEqual(['make_read_only', 'col_left']);
    });
  });
});

/***/ }),
/* 132 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('ContextMenuReadOnly', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should trigger `afterSetCellMeta` callback after changing cell to read only by context menu', function () {
    var afterSetCellMetaCallback = jasmine.createSpy('afterSetCellMetaCallback');
    var rows = 5,
        columns = 5;

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(rows, columns),
      rowHeaders: true,
      colHeaders: true,
      contextMenu: true,
      afterSetCellMeta: afterSetCellMetaCallback
    });

    selectCell(2, 3);
    contextMenu();

    var changeToReadOnluButton = $('.htItemWrapper').filter(function () {
      return $(this).text() === 'Read only';
    })[0];

    $(changeToReadOnluButton).simulate('mousedown');
    expect(afterSetCellMetaCallback).toHaveBeenCalledWith(2, 3, 'readOnly', true, undefined, undefined);
  });
});

/***/ }),
/* 133 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('ContextMenuCopyPaste', function () {
  var id = 'testContainer';

  if (typeof navigator.mimeTypes['application/x-shockwave-flash'] === 'undefined') {
    navigator.mimeTypes['application/x-shockwave-flash'] = {}; // mock Adobe Flash plugin so that contextMenuCopyPaste.js does not throw an error in PhantomJS
  }

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');

    var wrapper = $('<div></div>').css({
      width: 400,
      height: 200,
      overflow: 'scroll'
    });

    this.$wrapper = this.$container.wrap(wrapper).parent();
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
    this.$wrapper.remove();

    $('head').find('script[src*=ZeroClipboard]').remove();
    delete window.ZeroClipboard;
  });

  it('should add Copy and Paste context menu options at the beginning by default', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetObjectData(10, 5),
      rowHeaders: true,
      colHeaders: true,
      minSpareRows: 1,
      contextMenu: true,
      contextMenuCopyPaste: {
        swfPath: '../../demo/swf/ZeroClipboard.swf'
      }
    });

    selectCell(1, 1);

    contextMenu();

    var $contextMenuEntries = $('.htContextMenu .ht_master .htCore tbody').find('td');
    var $copyButton = $contextMenuEntries.find('div').filter(function () {
      return (/Copy/i.test($(this).text())
      );
    }).parents('td');
    var $pasteButton = $contextMenuEntries.find('div').filter(function () {
      return (/Paste/i.test($(this).text())
      );
    }).parents('td');

    expect($contextMenuEntries.index($copyButton)).toEqual(0);
    expect($contextMenuEntries.index($pasteButton)).toEqual(1);
  });

  it('should add Copy and Paste context menu options at the provided index', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetObjectData(10, 5),
      rowHeaders: true,
      colHeaders: true,
      minSpareRows: 1,
      contextMenu: ['row_above', 'copy', 'paste', 'row_below'],
      contextMenuCopyPaste: {
        swfPath: '../../demo/swf/ZeroClipboard.swf'
      }
    });

    selectCell(1, 1);

    contextMenu();

    var $contextMenuEntries = $('.htContextMenu .ht_master .htCore tbody').find('td');
    var $copyButton = $contextMenuEntries.find('div').filter(function () {
      return (/Copy/i.test($(this).text())
      );
    }).parents('td');
    var $pasteButton = $contextMenuEntries.find('div').filter(function () {
      return (/Paste/i.test($(this).text())
      );
    }).parents('td');

    expect($contextMenuEntries.not('[class*=htSeparator]').index($copyButton)).toEqual(1);
    expect($contextMenuEntries.not('[class*=htSeparator]').index($pasteButton)).toEqual(2);
  });

  it('should disable `Copy` and `Paste` items when context menu was triggered from corner header', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetObjectData(10, 5),
      rowHeaders: true,
      colHeaders: true,
      minSpareRows: 1,
      contextMenu: true,
      contextMenuCopyPaste: {
        swfPath: '../../demo/swf/ZeroClipboard.swf'
      }
    });

    $('.ht_clone_top_left_corner .htCore').find('thead').find('th').eq(0).simulate('mousedown', { which: 3 });
    contextMenu();

    expect($('.htContextMenu tbody td.htDisabled').text()).toBe(['Copy', 'Paste', 'Insert column on the left', 'Insert column on the right', 'Remove row', 'Remove column', 'Undo', 'Redo', 'Read only', 'Alignment'].join(''));
  });

  // see https://github.com/handsontable/handsontable/issues/3140
  it('should not throwing error when ContextMenu plugin is disabled', function () {
    var spy = jasmine.createSpy();
    var prevError = window.onerror;

    window.onerror = function () {
      spy();
    };

    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetObjectData(10, 5),
      rowHeaders: true,
      colHeaders: true,
      minSpareRows: 1,
      contextMenu: true,
      contextMenuCopyPaste: {
        swfPath: '../../demo/swf/ZeroClipboard.swf'
      }
    });

    hot.getPlugin('contextMenu').disablePlugin();
    $(getCell(0, 0)).simulate('mouseenter');

    expect(spy).not.toHaveBeenCalled();
    window.onerror = prevError;
  });
});

/***/ }),
/* 134 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('CopyPaste', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should remove additional new line from copied text (only safari)', function () {
    var getData = jasmine.createSpy().and.returnValue('a\nb\n\n');
    var preventDefault = jasmine.createSpy();
    var hot = handsontable();

    $('.copyPaste')[0].onpaste({ clipboardData: { getData: getData },
      preventDefault: preventDefault
    });

    if (Handsontable.helper.isSafari()) {
      expect($('.copyPaste')[0].value).toEqual('a\nb\n');
      expect(getData).toHaveBeenCalledWith('Text');
      expect(preventDefault).toHaveBeenCalled();
    } else if (Handsontable.helper.isChrome()) {
      expect($('.copyPaste')[0].value).toBe('a\nb\n\n');
      expect(getData).toHaveBeenCalledWith('Text');
      expect(preventDefault).toHaveBeenCalled();
    }
  });

  it('should allow blocking cutting cells by stopping the immediate propagation', function (done) {
    var onCut = jasmine.createSpy();
    var hot = handsontable({
      data: [['2012', 10, 11, 12, 13, 15, 16], ['2013', 10, 11, 12, 13, 15, 16]],
      beforeKeyDown: function beforeKeyDown(event) {
        if (event.ctrlKey && event.keyCode === Handsontable.helper.KEY_CODES.X) {
          event.isImmediatePropagationEnabled = false;
        }
      }
    });

    hot.copyPaste.copyPasteInstance.cutCallbacks.push(onCut);

    selectCell(0, 0);
    keyDown('ctrl+x');

    setTimeout(function () {
      expect(onCut).not.toHaveBeenCalled();
      done();
    }, 100);
  });

  describe('enabling/disabing plugin', function () {
    it('should enable copyPaste by default', function () {

      var hot = handsontable();

      expect(hot.copyPaste).toBeDefined();
    });

    it('should create copyPaste div if enabled', function () {
      expect($('#CopyPasteDiv').length).toEqual(0);

      var hot = handsontable();

      selectCell(0, 0);
      keyDownUp(Handsontable.helper.KEY_CODES.CONTROL_LEFT); // copyPaste div isn't created until you click CTRL

      expect($('#CopyPasteDiv').length).toEqual(1);
    });

    it('should not create copyPaste div if disabled', function () {
      expect($('#CopyPasteDiv').length).toEqual(0);

      var hot = handsontable({
        copyPaste: false
      });

      selectCell(0, 0);
      keyDownUp(Handsontable.helper.KEY_CODES.CONTROL_LEFT);

      expect($('#CopyPasteDiv').length).toEqual(0);
    });

    it('should not create copyPaste property if plugin is disabled', function () {
      var hot = handsontable({
        copyPaste: false
      });

      expect(hot.copyPaste).toBeUndefined();
    });

    it('should enable/disable plugin using updateSettings', function () {
      var hot = handsontable();

      expect(hot.copyPaste).toBeDefined();

      updateSettings({
        copyPaste: false
      });

      expect(hot.copyPaste).toBe(null);
    });

    it('should remove copyPaste div if plugin has been disabled using updateSetting', function () {
      expect($('#CopyPasteDiv').length).toEqual(0);

      var hot = handsontable();

      selectCell(0, 0);
      keyDownUp(Handsontable.helper.KEY_CODES.CONTROL_LEFT);

      expect($('#CopyPasteDiv').length).toEqual(1);

      updateSettings({
        copyPaste: false
      });

      expect($('#CopyPasteDiv').length).toEqual(0);

      selectCell(0, 0);
      keyDownUp(Handsontable.helper.KEY_CODES.CONTROL_LEFT);

      expect($('#CopyPasteDiv').length).toEqual(0);
    });
  });

  describe('setting values copyable', function () {
    it('should set copyable text when selecting a single cell and hitting ctrl', function () {
      handsontable({
        data: Handsontable.helper.createSpreadsheetData(2, 2)
      });

      var copyPasteTextarea = $('textarea.copyPaste');

      expect(copyPasteTextarea.val().length).toEqual(0);

      selectCell(0, 0);
      keyDownUp(Handsontable.helper.KEY_CODES.CONTROL_LEFT);

      expect(copyPasteTextarea.val()).toEqual('A1');
    });

    it('should set copyable text when selecting a single cell and hitting left command', function () {
      handsontable({
        data: Handsontable.helper.createSpreadsheetData(2, 2)
      });

      var copyPasteTextarea = $('textarea.copyPaste');

      expect(copyPasteTextarea.val().length).toEqual(0);

      selectCell(0, 0);
      keyDownUp(Handsontable.helper.KEY_CODES.COMMAND_LEFT);

      expect(copyPasteTextarea.val()).toEqual('A1');
    });

    it('should set copyable text when selecting a single cell and hitting right command', function () {
      handsontable({
        data: Handsontable.helper.createSpreadsheetData(2, 2)
      });

      var copyPasteTextarea = $('textarea.copyPaste');

      expect(copyPasteTextarea.val().length).toEqual(0);

      selectCell(0, 0);
      keyDownUp(Handsontable.helper.KEY_CODES.COMMAND_RIGHT);

      expect(copyPasteTextarea.val()).toEqual('A1');
    });

    it('should set copyable text when selecting multiple cells and hitting ctrl', function () {
      handsontable({
        data: Handsontable.helper.createSpreadsheetData(2, 2)
      });

      var copyPasteTextarea = $('textarea.copyPaste');

      expect(copyPasteTextarea.val().length).toEqual(0);

      selectCell(0, 0, 1, 0);
      keyDownUp(Handsontable.helper.KEY_CODES.CONTROL_LEFT);

      expect(copyPasteTextarea.val()).toEqual('A1\nA2');
    });

    it('should set copyable text when selecting all cells with CTRL+A', function (done) {
      handsontable({
        data: Handsontable.helper.createSpreadsheetData(2, 2)
      });

      var copyPasteTextarea = $('textarea.copyPaste');

      expect(copyPasteTextarea.val().length).toEqual(0);

      selectCell(0, 0);

      $(document.activeElement).simulate('keydown', { keyCode: Handsontable.helper.KEY_CODES.A, ctrlKey: true });

      setTimeout(function () {
        expect(getSelected()).toEqual([0, 0, 1, 1]);
        expect(copyPasteTextarea.val()).toEqual('A1\tB1\nA2\tB2');
        done();
      }, 10);
    });

    it('should not throw error when no cell is selected (#1221)', function () {
      handsontable({
        data: Handsontable.helper.createSpreadsheetData(2, 2)
      });

      selectCell(0, 0);
      deselectCell();

      function keydownCtrl() {
        $(document).simulate('keydown', {
          keyCode: Handsontable.helper.KEY_CODES.COMMAND_LEFT
        });
      }

      // expect no to throw any exception
      expect(keydownCtrl).not.toThrow();
    });

    it('should set copyable text when selecting a single cell with specified type and hitting ctrl (#1300)', function () {
      handsontable({
        data: [['A', 1], ['B', 2]],
        columns: [{
          type: 'text'
        }, {
          type: 'numeric'
        }]
      });

      var copyPasteTextarea = $('textarea.copyPaste');

      expect(copyPasteTextarea.val().length).toEqual(0);

      selectCell(0, 0, 1, 1);
      keyDownUp(Handsontable.helper.KEY_CODES.CONTROL_LEFT);

      expect(copyPasteTextarea.val()).toEqual('A\t1\nB\t2');
    });

    it('should set copyable text when selecting a single cell with editor type as false (#2574)', function () {
      handsontable({
        data: [['A', 1], ['B', 2]],
        columns: [{
          type: 'text'
        }, {
          editor: false
        }]
      });

      var copyPasteTextarea = $('textarea.copyPaste');

      expect(copyPasteTextarea.val().length).toEqual(0);

      selectCell(1, 1, 1, 1);
      keyDownUp(Handsontable.helper.KEY_CODES.CONTROL_LEFT);

      expect(copyPasteTextarea.val()).toEqual('2');
    });

    describe('working with multiple tables', function () {
      beforeEach(function () {
        this.$container2 = $('<div id="' + id + '2"></div>').appendTo('body');
      });

      afterEach(function () {
        if (this.$container2) {
          this.$container2.handsontable('destroy');
          this.$container2.remove();
        }
      });

      it('should disable copyPaste only in particular table', function () {
        var hot1 = handsontable();
        var hot2 = this.$container2.handsontable({
          copyPaste: false
        });

        expect(hot1.copyPaste).toBeDefined();
        expect(hot2.copyPaste).toBeUndefined();
      });

      it('should create only one CopyPasteDiv regardless of the number of tables', function () {
        var hot1 = handsontable();
        var hot2 = this.$container2.handsontable();

        expect($('#CopyPasteDiv').length).toEqual(1);
      });

      it('should leave CopyPasteDiv as long as at least one table has copyPaste enabled', function () {
        var hot1 = handsontable();
        var hot2 = this.$container2.handsontable().handsontable('getInstance');

        expect($('#CopyPasteDiv').length).toEqual(1);

        hot1.updateSettings({
          copyPaste: false
        });

        expect($('#CopyPasteDiv').length).toEqual(1);

        hot2.updateSettings({
          copyPaste: false
        });

        expect($('#CopyPasteDiv').length).toEqual(0);
      });
    });
  });

  describe('hooks', function () {
    it('should call beforeCut and afterCut during cutting out operation', function () {
      var beforeCutSpy = jasmine.createSpy('beforeCut');
      var afterCutSpy = jasmine.createSpy('afterCut');
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(2, 2),
        beforeCut: beforeCutSpy,
        afterCut: afterCutSpy
      });

      selectCell(0, 0);

      keyDown('ctrl');
      keyDown('ctrl+x');

      expect(beforeCutSpy.calls.count()).toEqual(1);
      expect(beforeCutSpy).toHaveBeenCalledWith([['A1']], [{ startRow: 0, startCol: 0, endRow: 0, endCol: 0 }], void 0, void 0, void 0, void 0);

      expect(afterCutSpy.calls.count()).toEqual(1);
      expect(afterCutSpy).toHaveBeenCalledWith([['A1']], [{ startRow: 0, startCol: 0, endRow: 0, endCol: 0 }], void 0, void 0, void 0, void 0);
    });

    it('should call beforeCopy and afterCopy during copying operation', function () {
      var beforeCopySpy = jasmine.createSpy('beforeCopy');
      var afterCopySpy = jasmine.createSpy('afterCopy');

      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(2, 2),
        beforeCopy: beforeCopySpy,
        afterCopy: afterCopySpy
      });

      selectCell(0, 0);

      keyDown('ctrl');
      keyDown('ctrl+c');

      expect(beforeCopySpy.calls.count()).toEqual(1);
      expect(beforeCopySpy).toHaveBeenCalledWith([['A1']], [{ startRow: 0, startCol: 0, endRow: 0, endCol: 0 }], void 0, void 0, void 0, void 0);

      expect(afterCopySpy.calls.count()).toEqual(1);
      expect(afterCopySpy).toHaveBeenCalledWith([['A1']], [{ startRow: 0, startCol: 0, endRow: 0, endCol: 0 }], void 0, void 0, void 0, void 0);
    });

    it('should call beforePaste and afterPaste during copying operation', function (done) {
      var beforePasteSpy = jasmine.createSpy('beforePaste');
      var afterPasteSpy = jasmine.createSpy('afterPaste');

      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(2, 2),
        beforePaste: beforePasteSpy,
        afterPaste: afterPasteSpy
      });

      selectCell(0, 0);
      keyDown('ctrl');
      hot.copyPaste.triggerPaste(null, 'Kia');

      setTimeout(function () {
        expect(beforePasteSpy.calls.count()).toEqual(1);
        expect(beforePasteSpy).toHaveBeenCalledWith([['Kia']], [{ startRow: 0, startCol: 0, endRow: 0, endCol: 0 }], void 0, void 0, void 0, void 0);

        expect(afterPasteSpy.calls.count()).toEqual(1);
        expect(afterPasteSpy).toHaveBeenCalledWith([['Kia']], [{ startRow: 0, startCol: 0, endRow: 0, endCol: 0 }], void 0, void 0, void 0, void 0);
        done();
      }, 60);
    });

    it('should be possible to block cutting out', function () {
      var afterCutSpy = jasmine.createSpy('afterCut');
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(2, 2),
        beforeCut: function beforeCut() {
          return false;
        },

        afterCut: afterCutSpy
      });

      selectCell(0, 0);

      keyDown('ctrl');
      keyDown('ctrl+x');

      expect(afterCutSpy.calls.count()).toEqual(0);
    });

    it('should be possible to block copying', function () {
      var afterCopySpy = jasmine.createSpy('afterCopy');
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(2, 2),
        beforeCopy: function beforeCopy() {
          return false;
        },

        afterCopy: afterCopySpy
      });

      selectCell(0, 0);

      keyDown('ctrl');
      keyDown('ctrl+c');

      expect(afterCopySpy.calls.count()).toEqual(0);
    });

    it('should be possible to block pasting', function (done) {
      var afterPasteSpy = jasmine.createSpy('afterPaste');

      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(2, 2),
        beforePaste: function beforePaste() {
          return false;
        },

        afterPaste: afterPasteSpy
      });

      selectCell(0, 0);
      keyDown('ctrl');
      hot.copyPaste.triggerPaste(null, 'Kia');

      setTimeout(function () {
        expect(afterPasteSpy.calls.count()).toEqual(0);
        done();
      }, 60);
    });
  });
});

/***/ }),
/* 135 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('CustomBorders', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
    var wrapper = $('<div></div>').css({
      width: 400,
      height: 200,
      overflow: 'scroll'
    });

    this.$wrapper = this.$container.wrap(wrapper).parent();
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
    this.$wrapper.remove();
  });

  it('should draw custom borders for single td', function () {
    handsontable({
      data: Handsontable.helper.createSpreadsheetData(7, 7),
      colHeaders: true,
      rowHeaders: true,
      customBorders: [{
        row: 2,
        col: 2,
        left: {
          width: 2,
          color: 'red'
        },
        right: {
          width: 1,
          color: 'green'
        }
      }]
    });
    // [top,left, bottom, right]

    var borders = $('.wtBorder.border_row2col2');
    expect(borders.length).toEqual(20); // 4 times 5 elements (top,right, bottom, left, corner)
    expect(borders[0].className).toContain('hidden'); // hidden top
    expect(borders[1].style.backgroundColor).toEqual('red'); // left red
    expect(borders[1].style.width).toEqual('2px'); // left 2px width
    expect(borders[2].className).toContain('hidden'); // hidden bottom
    expect(borders[3].style.backgroundColor).toEqual('green'); // green right
    expect(borders[3].style.width).toEqual('1px'); // right 1px width
  });

  it('should draw custom borders for range', function () {
    handsontable({
      data: Handsontable.helper.createSpreadsheetData(7, 7),
      colHeaders: true,
      rowHeaders: true,
      customBorders: [{
        range: {
          from: {
            row: 1,
            col: 1
          },
          to: {
            row: 3,
            col: 4
          }
        },
        top: {
          width: 2,
          color: 'black'
        },
        left: {
          width: 2,
          color: 'red'
        },
        bottom: {
          width: 2,
          color: 'red'
        },
        right: {
          width: 3,
          color: 'black'
        }
      }]
    });

    for (var row = 1; row <= 3; row++) {
      for (var column = 1; column <= 4; column++) {
        if (row == 1) {
          var topRow = $('.wtBorder.border_row' + row + 'col' + column);
          expect(topRow.length).toEqual(20); // borders for all tables (main and hiders)
          expect(topRow[0].style.backgroundColor).toEqual('black');
          expect(topRow[0].style.height).toEqual('2px');
        }
        if (column == 1) {
          var leftColumn = $('.wtBorder.border_row' + row + 'col' + column);
          expect(leftColumn.length).toEqual(20); // borders for all tables (main and hiders)
          expect(leftColumn[1].style.backgroundColor).toEqual('red');
          expect(leftColumn[1].style.width).toEqual('2px');
        }
        if (row == 3) {
          var bottomRow = $('.wtBorder.border_row' + row + 'col' + column);
          expect(bottomRow.length).toEqual(20); // borders for all tables (main and hiders)
          expect(bottomRow[2].style.backgroundColor).toEqual('red');
          expect(bottomRow[2].style.height).toEqual('2px');
        }
        if (column == 4) {
          var rightColumn = $('.wtBorder.border_row' + row + 'col' + column);
          expect(rightColumn.length).toEqual(20); // borders for all tables (main and hiders)
          expect(rightColumn[3].style.backgroundColor).toEqual('black');
          expect(rightColumn[3].style.width).toEqual('3px');
        }
      }
    }
  });

  it('should draw top border from context menu options', function (done) {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(4, 4),
      contextMenu: true,
      customBorders: true
    });

    var defaultBorder = {
      color: '#000',
      width: 1
    },
        empty = {
      hide: true
    };

    contextMenu();
    var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(10);
    item.simulate('mouseover');

    setTimeout(function () {
      var contextSubMenu = $('.htContextMenuSub_' + item.text());
      var button = contextSubMenu.find('.ht_master .htCore tbody td').not('.htSeparator').eq(0);

      button.simulate('mousedown');

      // expect(getCellMeta(0,0).borders.hasOwnProperty('top')).toBe(true);
      expect(getCellMeta(0, 0).borders.top).toEqual(defaultBorder);
      expect(getCellMeta(0, 0).borders.left).toEqual(empty);
      expect(getCellMeta(0, 0).borders.bottom).toEqual(empty);
      expect(getCellMeta(0, 0).borders.right).toEqual(empty);
      done();
    }, 350);
  });

  it('should draw left border from context menu options', function (done) {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(4, 4),
      contextMenu: true,
      customBorders: true
    });

    var defaultBorder = {
      color: '#000',
      width: 1
    },
        empty = {
      hide: true
    };

    contextMenu();
    var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(10);
    item.simulate('mouseover');

    setTimeout(function () {
      var contextSubMenu = $('.htContextMenuSub_' + item.text());
      var button = contextSubMenu.find('.ht_master .htCore tbody td').not('.htSeparator').eq(3);

      button.simulate('mousedown');

      /* eslint-disable no-prototype-builtins */
      expect(getCellMeta(0, 0).borders.hasOwnProperty('left')).toBe(true);
      expect(getCellMeta(0, 0).borders.top).toEqual(empty);
      expect(getCellMeta(0, 0).borders.left).toEqual(defaultBorder);
      expect(getCellMeta(0, 0).borders.bottom).toEqual(empty);
      expect(getCellMeta(0, 0).borders.right).toEqual(empty);
      done();
    }, 350);
  });

  it('should draw right border from context menu options', function (done) {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(4, 4),
      contextMenu: true,
      customBorders: true
    });

    var defaultBorder = {
      color: '#000',
      width: 1
    },
        empty = {
      hide: true
    };

    contextMenu();
    var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(10);
    item.simulate('mouseover');

    setTimeout(function () {
      var contextSubMenu = $('.htContextMenuSub_' + item.text());
      var button = contextSubMenu.find('.ht_master .htCore tbody td').not('.htSeparator').eq(1);

      button.simulate('mousedown');

      /* eslint-disable no-prototype-builtins */
      expect(getCellMeta(0, 0).borders.hasOwnProperty('right')).toBe(true);
      expect(getCellMeta(0, 0).borders.top).toEqual(empty);
      expect(getCellMeta(0, 0).borders.left).toEqual(empty);
      expect(getCellMeta(0, 0).borders.bottom).toEqual(empty);
      expect(getCellMeta(0, 0).borders.right).toEqual(defaultBorder);
      done();
    }, 350);
  });

  it('should draw bottom border from context menu options', function (done) {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(4, 4),
      contextMenu: true,
      customBorders: true
    });

    var defaultBorder = {
      color: '#000',
      width: 1
    },
        empty = {
      hide: true
    };

    contextMenu();
    var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(10);
    item.simulate('mouseover');

    setTimeout(function () {
      var contextSubMenu = $('.htContextMenuSub_' + item.text());
      var button = contextSubMenu.find('.ht_master .htCore tbody td').not('.htSeparator').eq(2);

      button.simulate('mousedown');

      /* eslint-disable no-prototype-builtins */
      expect(getCellMeta(0, 0).borders.hasOwnProperty('right')).toBe(true);
      expect(getCellMeta(0, 0).borders.top).toEqual(empty);
      expect(getCellMeta(0, 0).borders.left).toEqual(empty);
      expect(getCellMeta(0, 0).borders.bottom).toEqual(defaultBorder);
      expect(getCellMeta(0, 0).borders.right).toEqual(empty);
      done();
    }, 350);
  });

  it('should remove all bottoms border from context menu options', function (done) {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(4, 4),
      contextMenu: true,
      customBorders: [{
        row: 0,
        col: 0,
        left: {
          width: 2,
          color: 'red'
        },
        right: {
          width: 1,
          color: 'green'
        }
      }]
    });

    contextMenu();
    var item = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator').eq(10);
    item.simulate('mouseover');

    setTimeout(function () {
      var contextSubMenu = $('.htContextMenuSub_' + item.text());
      var button = contextSubMenu.find('.ht_master .htCore tbody td').not('.htSeparator').eq(4);

      button.simulate('mousedown');

      expect(getCellMeta(0, 0).borders).toBeUndefined();
      done();
    }, 350);
  });

  it('should disable `Borders` context menu item when menu was triggered from corner header', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetObjectData(10, 5),
      rowHeaders: true,
      colHeaders: true,
      contextMenu: true,
      customBorders: true
    });

    $('.ht_clone_top_left_corner .htCore').find('thead').find('th').eq(0).simulate('mousedown', { which: 3 });
    contextMenu();

    expect($('.htContextMenu tbody td.htDisabled').text()).toBe(['Insert column on the left', 'Insert column on the right', 'Remove row', 'Remove column', 'Undo', 'Redo', 'Read only', 'Alignment', 'Borders'].join(''));
  });
});

/***/ }),
/* 136 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('DragToScroll', function () {
  function createBoundaries() {
    return {
      top: 100,
      left: 100,
      width: 900,
      height: 900,
      bottom: 1000,
      right: 1000
    };
  }
  var dragToScroll = new Handsontable.plugins.DragToScroll();

  dragToScroll.setBoundaries(createBoundaries());

  it('exact top, exact left should be in boundaries', function () {
    dragToScroll.setCallback(function (scrollX, scrollY) {
      expect(scrollX).toEqual(0);
      expect(scrollY).toEqual(0);
    });

    dragToScroll.check(100, 100);
  });

  it('exact bottom, exact right should be in boundaries', function () {
    dragToScroll.setCallback(function (scrollX, scrollY) {
      expect(scrollX).toEqual(0);
      expect(scrollY).toEqual(0);
    });

    dragToScroll.check(1000, 1000);
  });

  it('less than top, less than left should be out in "top" direction', function () {
    dragToScroll.setCallback(function (scrollX, scrollY) {
      expect(scrollX).toEqual(-1);
      expect(scrollY).toEqual(-1);
    });

    dragToScroll.check(99, 99);
  });

  it('exact top, less than left should be out in "left" direction', function () {
    dragToScroll.setCallback(function (scrollX, scrollY) {
      expect(scrollX).toEqual(-1);
      expect(scrollY).toEqual(0);
    });

    dragToScroll.check(99, 100);
  });

  it('less than top, more than right should be out in "top" direction', function () {
    dragToScroll.setCallback(function (scrollX, scrollY) {
      expect(scrollX).toEqual(1);
      expect(scrollY).toEqual(-1);
    });

    dragToScroll.check(1001, 99);
  });

  it('more than bottom, more than right should be out in "bottom" direction', function () {
    dragToScroll.setCallback(function (scrollX, scrollY) {
      expect(scrollX).toEqual(1);
      expect(scrollY).toEqual(1);
    });

    dragToScroll.check(1001, 1001);
  });

  it('exact bottom, more than right should be out in "right" direction', function () {
    dragToScroll.setCallback(function (scrollX, scrollY) {
      expect(scrollX).toEqual(1);
      expect(scrollY).toEqual(0);
    });

    dragToScroll.check(1001, 1000);
  });

  it('more than bottom, less than left should be out in "bottom" direction', function () {
    dragToScroll.setCallback(function (scrollX, scrollY) {
      expect(scrollX).toEqual(-1);
      expect(scrollY).toEqual(1);
    });

    dragToScroll.check(99, 1001);
  });
});

/***/ }),
/* 137 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('manualColumnFreeze', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  describe('freezeColumn', function () {
    it('should increase fixedColumnsLeft setting', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        manualColumnFreeze: true
      });
      var plugin = hot.getPlugin('manualColumnFreeze');
      plugin.freezeColumn(4);

      expect(hot.getSettings().fixedColumnsLeft).toEqual(1);
    });

    it('should freeze (make fixed) the column provided as an argument', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        manualColumnFreeze: true
      });

      var plugin = hot.getPlugin('manualColumnFreeze');
      var movePlugin = hot.getPlugin('manualColumnMove');

      plugin.freezeColumn(5);

      expect(movePlugin.columnsMapper.getValueByIndex(0)).toEqual(5);
    });
  });

  describe('unfreezeColumn', function () {
    it('should decrease fixedColumnsLeft setting', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        manualColumnFreeze: true,
        fixedColumnsLeft: 1
      });
      var plugin = hot.getPlugin('manualColumnFreeze');

      plugin.unfreezeColumn(0);
      expect(hot.getSettings().fixedColumnsLeft).toEqual(0);
    });

    it('should unfreeze (make non-fixed) the column provided as an argument', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        manualColumnFreeze: true,
        fixedColumnsLeft: 3
      });

      var plugin = hot.getPlugin('manualColumnFreeze');
      var movePlugin = hot.getPlugin('manualColumnMove');

      plugin.unfreezeColumn(0);

      expect(hot.getSettings().fixedColumnsLeft).toEqual(2);
      expect(movePlugin.columnsMapper.getValueByIndex(0)).toEqual(1);
      expect(movePlugin.columnsMapper.getValueByIndex(1)).toEqual(2);
      expect(movePlugin.columnsMapper.getValueByIndex(2)).toEqual(0);
    });
  });

  describe('functionality', function () {

    it('should add a \'freeze this column\' context menu entry for non-fixed columns', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        manualColumnFreeze: true,
        contextMenu: true
      });

      selectCell(1, 1);
      contextMenu();

      var freezeEntry = $(hot.getPlugin('contextMenu').menu.container).find('div').filter(function () {
        return $(this).text() === 'Freeze this column';
      });

      expect(freezeEntry.size()).toEqual(1);
    });

    it('should add a \'unfreeze this column\' context menu entry for fixed columns', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        manualColumnFreeze: true,
        contextMenu: true,
        fixedColumnsLeft: 2
      });

      selectCell(1, 1);
      contextMenu();

      var freezeEntry = $(hot.getPlugin('contextMenu').menu.container).find('div').filter(function () {
        return $(this).text() === 'Unfreeze this column';
      });

      expect(freezeEntry.size()).toEqual(1);
    });

    it('should fix the desired column after clicking the \'freeze this column\' context menu entry', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        manualColumnFreeze: true,
        fixedColumnsLeft: 1,
        contextMenu: true
      });

      selectCell(1, 3);

      var dataAtCell = hot.getDataAtCell(1, 3);

      contextMenu();

      var freezeEntry = $(hot.getPlugin('contextMenu').menu.container).find('div').filter(function () {
        if ($(this).text() === 'Freeze this column') {
          return true;
        }
        return false;
      });

      expect(freezeEntry.size()).toEqual(1);
      freezeEntry.eq(0).simulate('mousedown');

      expect(hot.getSettings().fixedColumnsLeft).toEqual(2);
      expect(hot.getDataAtCell(1, 1)).toEqual(dataAtCell);
    });

    it('should unfix the desired column (and revert it to it\'s original position) after clicking the \'unfreeze this column\' context menu entry', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        manualColumnFreeze: true,
        fixedColumnsLeft: 3,
        manualColumnMove: [0, 2, 5, 3, 4, 1, 6, 7, 8, 9],
        contextMenu: true,
        rowHeaders: true
      });

      var dataAtCell = hot.getDataAtCell(1, 0);
      expect(dataAtCell).toEqual('A2');
      dataAtCell = hot.getDataAtCell(1, 1);
      expect(dataAtCell).toEqual('C2');
      dataAtCell = hot.getDataAtCell(1, 2);
      expect(dataAtCell).toEqual('F2');

      selectCell(1, 1);
      contextMenu();

      var freezeEntry = $(hot.getPlugin('contextMenu').menu.container).find('div').filter(function () {
        return $(this).text() === 'Unfreeze this column';
      });
      freezeEntry.eq(0).simulate('mousedown');

      expect(hot.getSettings().fixedColumnsLeft).toEqual(2);
      dataAtCell = hot.getDataAtCell(1, 0);
      expect(dataAtCell).toEqual('A2');
      dataAtCell = hot.getDataAtCell(1, 1);
      expect(dataAtCell).toEqual('F2');
      dataAtCell = hot.getDataAtCell(1, 2);
      expect(dataAtCell).toEqual('C2');

      selectCell(1, 1);
      contextMenu();

      freezeEntry = $(hot.getPlugin('contextMenu').menu.container).find('div').filter(function () {
        if ($(this).text() === 'Unfreeze this column') {
          return true;
        }
        return false;
      });
      freezeEntry.eq(0).simulate('mousedown');

      expect(hot.getSettings().fixedColumnsLeft).toEqual(1);
      dataAtCell = hot.getDataAtCell(1, 0);
      expect(dataAtCell).toEqual('A2');
      dataAtCell = hot.getDataAtCell(1, 1);
      expect(dataAtCell).toEqual('C2');
      dataAtCell = hot.getDataAtCell(1, 2);
      expect(dataAtCell).toEqual('D2');

      dataAtCell = hot.getDataAtCell(1, 5);
      expect(dataAtCell).toEqual('F2');

      // Use the modified columns position.
      hot.updateSettings({
        fixedColumnsLeft: 0,
        manualColumnMove: [0, 2, 5, 3, 4, 1, 6, 7, 8, 9]
      });

      hot.getSettings().fixedColumnsLeft = 0;

      selectCell(1, 2);
      contextMenu();
      freezeEntry = $(hot.getPlugin('contextMenu').menu.container).find('div').filter(function () {
        return $(this).text() === 'Freeze this column';
      });

      freezeEntry.eq(0).simulate('mousedown');

      expect(hot.getSettings().fixedColumnsLeft).toEqual(1);
      dataAtCell = hot.getDataAtCell(1, 0);
      expect(dataAtCell).toEqual('F2');

      selectCell(1, 0);
      contextMenu();
      freezeEntry = $(hot.getPlugin('contextMenu').menu.container).find('div').filter(function () {
        return $(this).text() === 'Unfreeze this column';
      });

      freezeEntry.eq(0).simulate('mousedown');

      expect(hot.getSettings().fixedColumnsLeft).toEqual(0);
      dataAtCell = hot.getDataAtCell(1, 2);
      expect(dataAtCell).toEqual('F2');
    });
  });
});

/***/ }),
/* 138 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('manualColumnMove', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  describe('init', function () {
    it('should change column order at init', function () {
      handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        manualColumnMove: [1, 2, 0]
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('B1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('C1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('A1');
    });
  });

  describe('persistentState', function () {
    it('should load data from cache after initialization of new Handsontable instance', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        manualColumnMove: true,
        persistentState: true
      });

      var dataAt0x2Cell = getDataAtCell(0, 2);
      var manualColumnMovePlugin = hot.getPlugin('manualColumnMove');

      manualColumnMovePlugin.moveColumn(2, 0);
      manualColumnMovePlugin.persistentStateSave();

      hot.destroy();
      this.$container.remove();
      this.$container = $('<div id="' + id + '"></div>').appendTo('body');

      handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        manualColumnMove: true,
        persistentState: true
      });

      expect(getDataAtCell(0, 0)).toEqual(dataAt0x2Cell);
      done();
    });

    it('should work with updateSettings properly', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        manualColumnMove: true,
        persistentState: true
      });

      var dataAt0x2Cell = getDataAtCell(0, 2);
      var manualColumnMovePlugin = hot.getPlugin('manualColumnMove');

      manualColumnMovePlugin.moveColumn(2, 0);
      manualColumnMovePlugin.persistentStateSave();

      updateSettings({});
      expect(getDataAtCell(0, 0)).toEqual(dataAt0x2Cell);
    });
  });

  describe('updateSettings', function () {
    it('should be enabled after specifying it in updateSettings config', function () {
      handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        colHeaders: true
      });

      updateSettings({
        manualColumnMove: true
      });

      this.$container.find('thead tr:eq(0) th:eq(0)').simulate('mousedown');
      this.$container.find('thead tr:eq(0) th:eq(0)').simulate('mouseup');

      expect(this.$container.hasClass('after-selection--columns')).toBeGreaterThan(0);
    });

    it('should change the default column order with updateSettings', function () {
      handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        manualColumnMove: true
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('A1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('B1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('C1');

      updateSettings({
        manualColumnMove: [2, 1, 0]
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('C1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('B1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('A1');
    });

    it('should change column order with updateSettings', function () {
      handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        manualColumnMove: [1, 2, 0]
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('B1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('C1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('A1');

      updateSettings({
        manualColumnMove: [2, 1, 0]
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('C1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('B1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('A1');
    });

    it('should update columnsMapper when updateSettings change numbers of columns', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        manualColumnMove: true
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('A1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('B1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('C1');

      hot.getPlugin('manualColumnMove').moveColumn(2, 0);

      updateSettings({
        columns: [{ data: 2 }, { data: 0 }, { data: 1 }]
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('B1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('C1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('A1');
    });

    it('should reset column order with updateSettings when undefined is passed', function () {
      handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        manualColumnMove: [1, 2, 0]
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('B1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('C1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('A1');

      updateSettings({
        manualColumnMove: void 0
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('A1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('B1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('C1');
    });
  });

  describe('loadData', function () {
    it('should increase numbers of columns if it is necessary', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        manualColumnMove: true
      });

      hot.loadData(Handsontable.helper.createSpreadsheetData(10, 10));

      expect(countRows()).toEqual(10);
      expect(hot.getPlugin('manualColumnMove').columnsMapper.__arrayMap.length).toEqual(10);
    });

    it('should decrease numbers of columns if it is necessary', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        manualColumnMove: true
      });

      hot.loadData(Handsontable.helper.createSpreadsheetData(2, 2));

      expect(countRows()).toEqual(2);
      expect(hot.getPlugin('manualColumnMove').columnsMapper.__arrayMap.length).toEqual(2);
    });
  });

  describe('moving', function () {
    it('should move column by API', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        colHeaders: true,
        manualColumnMove: true
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('A1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('B1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('C1');

      hot.getPlugin('manualColumnMove').moveColumn(2, 0);
      hot.render();

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('C1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('A1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('B1');
    });

    it('should move many columns by API', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        colHeaders: true,
        manualColumnMove: true
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('A1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('B1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('C1');

      hot.getPlugin('manualColumnMove').moveColumns([7, 9, 8], 0);
      hot.render();

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('H1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('J1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('I1');
    });

    it('should trigger an beforeColumnMove event before column move', function () {
      var beforeMoveColumnCallback = jasmine.createSpy('beforeMoveColumnCallback');

      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        colHeaders: true,
        manualColumnMove: true,
        beforeColumnMove: beforeMoveColumnCallback
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('A1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('B1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('C1');

      hot.getPlugin('manualColumnMove').moveColumns([8, 9, 7], 0);
      hot.render();

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('I1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('J1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('H1');

      expect(beforeMoveColumnCallback).toHaveBeenCalledWith([8, 9, 7], 0, void 0, void 0, void 0, void 0);
    });

    it('should trigger an afterColumnMove event after column move', function () {
      var afterMoveColumnCallback = jasmine.createSpy('afterMoveColumnCallback');

      this.$container.height(150);

      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        colHeaders: true,
        manualColumnMove: true,
        afterColumnMove: afterMoveColumnCallback
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('A1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('B1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('C1');

      hot.getPlugin('manualColumnMove').moveColumns([8, 9, 7], 0);
      hot.render();

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('I1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('J1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('H1');

      expect(afterMoveColumnCallback).toHaveBeenCalledWith([8, 9, 7], 0, void 0, void 0, void 0, void 0);
    });

    it('should move the second column to the first column', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        colHeaders: true,
        manualColumnMove: true
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('A1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('B1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('C1');

      var $rowsHeaders = this.$container.find('.ht_clone_top tr th');

      $rowsHeaders.eq(1).simulate('mousedown');
      $rowsHeaders.eq(1).simulate('mouseup');
      $rowsHeaders.eq(1).simulate('mousedown');
      $rowsHeaders.eq(0).simulate('mouseover');
      $rowsHeaders.eq(0).simulate('mousemove');
      $rowsHeaders.eq(0).simulate('mouseup');

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('B1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('A1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('C1');
    });

    it('should move the second row to the third row', function () {
      handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        colHeaders: true,
        manualColumnMove: true
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('A1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('B1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('C1');

      var $rowsHeaders = this.$container.find('.ht_clone_top tr th');

      $rowsHeaders.eq(1).simulate('mousedown');
      $rowsHeaders.eq(1).simulate('mouseup');
      $rowsHeaders.eq(1).simulate('mousedown');
      $rowsHeaders.eq(3).simulate('mouseover');
      $rowsHeaders.eq(3).simulate('mousemove');
      $rowsHeaders.eq(3).simulate('mouseup');

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('A1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(1)').text()).toEqual('C1');
      expect(this.$container.find('tbody tr:eq(0) td:eq(2)').text()).toEqual('B1');
    });

    it('should properly scrolling viewport if mouse is over part-visible cell', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 20),
        colHeaders: true,
        rowHeaders: true,
        manualColumnMove: true,
        width: 600,
        height: 600,
        colWidths: 47
      });

      hot.selectCell(0, 19);

      setTimeout(function () {
        expect(hot.view.wt.wtTable.getFirstVisibleColumn()).toBeGreaterThan(8);

        var $rowsHeaders = spec().$container.find('.ht_clone_top tr th');

        $rowsHeaders.eq(2).simulate('mousedown');
        $rowsHeaders.eq(2).simulate('mouseup');
        $rowsHeaders.eq(2).simulate('mousedown');
        $rowsHeaders.eq(1).simulate('mouseover');
        $rowsHeaders.eq(1).simulate('mousemove');
        $rowsHeaders.eq(1).simulate('mouseup');
      }, 50);

      setTimeout(function () {
        expect(hot.view.wt.wtTable.getFirstVisibleColumn()).toBeLessThan(9);
        done();
      }, 150);
    });

    it('moving column should keep cell meta created using cells function', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        colHeaders: true,
        manualColumnMove: true,
        cells: function cells(row, col) {
          if (row == 1 && col == 0) {
            this.readOnly = true;
          }
        }
      });

      var htCore = getHtCore();

      expect(htCore.find('tbody tr:eq(1) td:eq(0)')[0].className.indexOf('htDimmed')).toBeGreaterThan(-1);

      hot.getPlugin('manualColumnMove').moveColumn(0, 3);
      hot.render();

      expect(htCore.find('tbody tr:eq(1) td:eq(2)')[0].className.indexOf('htDimmed')).toBeGreaterThan(-1);
    });

    it('moving column should keep cell meta created using cell array', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        colHeaders: true,
        manualColumnMove: true,
        cell: [{ row: 1, col: 0, readOnly: true }]
      });

      var htCore = getHtCore();

      expect(htCore.find('tbody tr:eq(1) td:eq(0)')[0].className.indexOf('htDimmed')).toBeGreaterThan(-1);

      hot.getPlugin('manualColumnMove').moveColumn(3, 0);
      hot.render();

      expect(htCore.find('tbody tr:eq(1) td:eq(1)')[0].className.indexOf('htDimmed')).toBeGreaterThan(-1);
    });
  });

  describe('copy-paste', function () {
    it('should create new columns is are needed', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        colHeaders: true,
        manualColumnMove: true
      });
      var changesSet = [[3, 4, 'A1'], [3, 5, 'B1'], [3, 6, 'C1'], [3, 7, 'D1']];

      // unfortunately couse of security rules, we can't simulate native mechanism (e.g. CTRL+C -> CTRL+V)
      hot.setDataAtCell(changesSet, void 0, void 0, 'CopyPaste.paste');

      expect(hot.countCols()).toEqual(8);
    });
  });

  describe('undoRedo', function () {
    xit('should back changes', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        colHeaders: true,
        manualColumnMove: true
      });
      hot.getPlugin('manualColumnMove').moveColumn(1, 4);
      hot.render();

      expect(hot.getDataAtCell(1, 3)).toBe('B2');

      hot.undo();

      expect(hot.getDataAtCell(1, 3)).toBe('D2');
    });

    xit('should revert changes', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        colHeaders: true,
        manualColumnMove: true
      });
      hot.getPlugin('manualColumnMove').moveColumn(1, 4);
      hot.render();

      expect(hot.getDataAtCell(1, 3)).toBe('A2');

      hot.undo();

      expect(hot.getDataAtCell(1, 1)).toBe('A2');

      hot.redo();

      expect(hot.getDataAtCell(1, 3)).toBe('A2');
    });
  });
});

/***/ }),
/* 139 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('manualColumnMove', function () {
  var id = 'testContainer';
  var arrayOfArrays = Handsontable.helper.createSpreadsheetData(30, 30);

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  describe('UI', function () {
    it('should append UI elements to wtHider after click on row header', function () {
      var hot = handsontable({
        data: arrayOfArrays.slice(),
        colHeaders: true,
        manualColumnMove: true
      });

      var $headerTH = this.$container.find('thead tr:eq(0) th:eq(0)');
      $headerTH.simulate('mousedown');
      $headerTH.simulate('mouseup');
      $headerTH.simulate('mousedown');

      expect(this.$container.find('.ht__manualColumnMove--guideline').length).toBe(1);
      expect(this.$container.find('.ht__manualColumnMove--backlight').length).toBe(1);
    });

    it('should part of UI elements be visible on dragging action', function () {
      var hot = handsontable({
        data: arrayOfArrays.slice(),
        colHeaders: true,
        manualColumnMove: true
      });

      var $headerTH = this.$container.find('thead tr:eq(0) th:eq(0)');
      $headerTH.simulate('mousedown');
      $headerTH.simulate('mouseup');
      $headerTH.simulate('mousedown');

      expect(this.$container.find('.ht__manualColumnMove--guideline:visible').length).toBe(0);
      expect(this.$container.find('.ht__manualColumnMove--backlight:visible').length).toBe(1);
    });

    it('should all of UI elements be visible on dragging action', function () {
      var hot = handsontable({
        data: arrayOfArrays.slice(),
        colHeaders: true,
        manualColumnMove: true
      });

      var $headers = [this.$container.find('thead tr:eq(0) th:eq(0)'), this.$container.find('thead tr:eq(0) th:eq(1)'), this.$container.find('thead tr:eq(0) th:eq(2)')];

      $headers[0].simulate('mousedown');
      $headers[0].simulate('mouseup');
      $headers[0].simulate('mousedown');
      $headers[1].simulate('mouseover');
      $headers[2].simulate('mouseover');

      expect(this.$container.find('.ht__manualColumnMove--guideline:visible').length).toBe(1);
      expect(this.$container.find('.ht__manualColumnMove--backlight:visible').length).toBe(1);
    });

    it('should set properly width for the backlight element when stretchH is enabled', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(30, 5),
        width: 600,
        colHeaders: true,
        stretchH: 'all',
        manualColumnMove: true
      });

      var $headerTH = this.$container.find('thead tr:eq(0) th:eq(1)');
      $headerTH.simulate('mousedown');
      $headerTH.simulate('mouseup');
      $headerTH.simulate('mousedown');

      expect(this.$container.find('.ht__manualColumnMove--backlight')[0].offsetWidth).toBe($headerTH[0].offsetWidth);
    });

    it('should set properly width for the backlight element when stretchH is enabled and column order was changed', function () {
      var hot = handsontable({
        data: [{ id: 1, flag: 'EUR', currencyCode: 'EUR', currency: 'Euro', level: 0.9033, units: 'EUR / USD', asOf: '08/19/2015', onedChng: 0.0026 }],
        width: 600,
        colHeaders: true,
        stretchH: 'all',
        manualColumnMove: [2, 4, 6, 3, 1, 0],
        columns: [{ data: 'id', type: 'numeric', width: 40 }, { data: 'currencyCode', type: 'text' }, { data: 'currency', type: 'text' }, { data: 'level', type: 'numeric', format: '0.0000' }, { data: 'units', type: 'text' }, { data: 'asOf', type: 'date', dateFormat: 'MM/DD/YYYY' }, { data: 'onedChng', type: 'numeric', format: '0.00%' }]
      });

      var $headerTH = this.$container.find('thead tr:eq(0) th:eq(6)');
      $headerTH.simulate('mousedown');
      $headerTH.simulate('mouseup');
      $headerTH.simulate('mousedown');
      $headerTH.simulate('mouseup');
      $headerTH.simulate('mousedown');

      expect(this.$container.find('.ht__manualColumnMove--backlight')[0].offsetWidth).toBe($headerTH[0].offsetWidth);
    });

    it('should not run moving ui if mousedown was fired on sorting element', function () {
      var hot = handsontable({
        data: arrayOfArrays.slice(),
        colHeaders: true,
        manualColumnMove: true,
        columnSorting: true
      });

      var $headerTH = this.$container.find('thead tr:eq(0) th:eq(6)');
      var $summaryElement = $headerTH.find('.columnSorting');

      $headerTH.simulate('mousedown');
      $headerTH.simulate('mouseup');
      $headerTH.simulate('mousedown');
      $headerTH.simulate('mouseup');

      var $backlight = this.$container.find('.ht__manualColumnMove--backlight')[0];
      $summaryElement.simulate('mousedown');

      var displayProp = $backlight.currentStyle ? $backlight.currentStyle.display : getComputedStyle($backlight, null).display;
      expect(displayProp).toEqual('none');
    });
  });
});

/***/ }),
/* 140 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('manualColumnResize', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should change column widths at init', function () {
    handsontable({
      manualColumnResize: [100, 150, 180]
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').outerWidth()).toBe(100);
    expect(this.$container.find('tbody tr:eq(0) td:eq(1)').outerWidth()).toBe(150);
    expect(this.$container.find('tbody tr:eq(0) td:eq(2)').outerWidth()).toBe(180);
  });

  it('should be enabled after specifying it in updateSettings config', function () {
    var hot = handsontable({
      data: [{ id: 1, name: 'Ted', lastName: 'Right' }, { id: 2, name: 'Frank', lastName: 'Honest' }, { id: 3, name: 'Joan', lastName: 'Well' }, { id: 4, name: 'Sid', lastName: 'Strong' }, { id: 5, name: 'Jane', lastName: 'Neat' }],
      colHeaders: true
    });

    updateSettings({ manualColumnResize: true });

    this.$container.find('thead tr:eq(0) th:eq(0)').simulate('mouseover');

    expect($('.manualColumnResizer').size()).toBeGreaterThan(0);
  });

  it('should change the default column widths with updateSettings', function () {
    handsontable({
      manualColumnResize: true
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').outerWidth()).toBe(50);
    expect(this.$container.find('tbody tr:eq(0) td:eq(1)').outerWidth()).toBe(50);
    expect(this.$container.find('tbody tr:eq(0) td:eq(2)').outerWidth()).toBe(50);

    updateSettings({
      manualColumnResize: [60, 50, 80]
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').outerWidth()).toBe(60);
    expect(this.$container.find('tbody tr:eq(0) td:eq(1)').outerWidth()).toBe(50);
    expect(this.$container.find('tbody tr:eq(0) td:eq(2)').outerWidth()).toBe(80);
  });

  it('should change column widths with updateSettings', function () {
    handsontable({
      manualColumnResize: [100, 150, 180]
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').outerWidth()).toBe(100);
    expect(this.$container.find('tbody tr:eq(0) td:eq(1)').outerWidth()).toBe(150);
    expect(this.$container.find('tbody tr:eq(0) td:eq(2)').outerWidth()).toBe(180);

    updateSettings({
      manualColumnResize: [60, 50, 80]
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').outerWidth()).toBe(60);
    expect(this.$container.find('tbody tr:eq(0) td:eq(1)').outerWidth()).toBe(50);
    expect(this.$container.find('tbody tr:eq(0) td:eq(2)').outerWidth()).toBe(80);
  });

  it('should reset column widths when undefined is passed', function () {
    handsontable({
      manualColumnResize: [100, 150, 180]
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').outerWidth()).toBe(100);
    expect(this.$container.find('tbody tr:eq(0) td:eq(1)').outerWidth()).toBe(150);
    expect(this.$container.find('tbody tr:eq(0) td:eq(2)').outerWidth()).toBe(180);

    updateSettings({
      manualColumnResize: void 0
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').outerWidth()).toBe(50);
    expect(this.$container.find('tbody tr:eq(0) td:eq(1)').outerWidth()).toBe(50);
    expect(this.$container.find('tbody tr:eq(0) td:eq(2)').outerWidth()).toBe(50);
  });

  it('should not reset column widths when `true` is passed', function () {
    handsontable({
      manualColumnResize: [100, 150, 180]
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').outerWidth()).toBe(100);
    expect(this.$container.find('tbody tr:eq(0) td:eq(1)').outerWidth()).toBe(150);
    expect(this.$container.find('tbody tr:eq(0) td:eq(2)').outerWidth()).toBe(180);

    updateSettings({
      manualColumnResize: true
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').outerWidth()).toBe(100);
    expect(this.$container.find('tbody tr:eq(0) td:eq(1)').outerWidth()).toBe(150);
    expect(this.$container.find('tbody tr:eq(0) td:eq(2)').outerWidth()).toBe(180);
  });

  it('should resize (narrowing) appropriate columns, even when stretchH `all` is enabled', function () {
    this.$container.css('width', '910px');
    handsontable({
      colHeaders: true,
      manualColumnResize: true,
      stretchH: 'all'
    });

    resizeColumn(1, 65);

    var $columnHeaders = this.$container.find('thead tr:eq(1) th');

    expect($columnHeaders.eq(0).width()).toBe(209);
    expect($columnHeaders.eq(1).width()).toBe(64);
    expect($columnHeaders.eq(2).width()).toBe(210);
    expect($columnHeaders.eq(3).width()).toBe(210);
    expect($columnHeaders.eq(4).width()).toBe(211);
  });

  it('should resize (extending) appropriate columns, even when stretchH `all` is enabled', function () {
    this.$container.css('width', '910px');
    handsontable({
      colHeaders: true,
      manualColumnResize: true,
      stretchH: 'all'
    });

    resizeColumn(1, 400);

    var $columnHeaders = this.$container.find('thead tr:eq(1) th');

    expect($columnHeaders.eq(0).width()).toBe(125);
    expect($columnHeaders.eq(1).width()).toBe(399);
    expect($columnHeaders.eq(2).width()).toBe(126);
    expect($columnHeaders.eq(3).width()).toBe(126);
    expect($columnHeaders.eq(4).width()).toBe(128);
  });

  it('should resize (narrowing) selected columns', function (done) {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(10, 20),
      colHeaders: true,
      manualColumnResize: true
    });

    var $columnHeaders = this.$container.find('thead tr:eq(0) th');
    var $colHeader = this.$container.find('thead tr:eq(0) th:eq(1)');
    $colHeader.simulate('mouseover');

    var $resizer = this.$container.find('.manualColumnResizer');
    var resizerPosition = $resizer.position();

    this.$container.find('tr:eq(0) th:eq(1)').simulate('mousedown');
    this.$container.find('tr:eq(0) th:eq(2)').simulate('mouseover');
    this.$container.find('tr:eq(0) th:eq(3)').simulate('mouseover');
    this.$container.find('tr:eq(0) th:eq(3)').simulate('mousemove');
    this.$container.find('tr:eq(0) th:eq(3)').simulate('mouseup');

    $resizer.simulate('mousedown', { clientX: resizerPosition.left });
    $resizer.simulate('mousemove', { clientX: this.$container.find('tr:eq(0) th:eq(1)').position().left + 29 });
    $resizer.simulate('mouseup');

    setTimeout(function () {
      expect($columnHeaders.eq(1).width()).toBe(33);
      expect($columnHeaders.eq(2).width()).toBe(34);
      expect($columnHeaders.eq(3).width()).toBe(34);
      done();
    }, 1000);
  });

  it('should resize (expanding) selected columns', function (done) {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(10, 20),
      colHeaders: true,
      manualColumnResize: true
    });

    var $columnHeaders = this.$container.find('thead tr:eq(0) th');
    var $colHeader = this.$container.find('thead tr:eq(0) th:eq(1)');
    $colHeader.simulate('mouseover');

    var $resizer = this.$container.find('.manualColumnResizer');
    var resizerPosition = $resizer.position();

    this.$container.find('tr:eq(0) th:eq(1)').simulate('mousedown');
    this.$container.find('tr:eq(0) th:eq(2)').simulate('mouseover');
    this.$container.find('tr:eq(0) th:eq(3)').simulate('mouseover');
    this.$container.find('tr:eq(0) th:eq(3)').simulate('mousemove');
    this.$container.find('tr:eq(0) th:eq(3)').simulate('mouseup');

    $resizer.simulate('mousedown', { clientX: resizerPosition.left });
    $resizer.simulate('mousemove', { clientX: this.$container.find('tr:eq(0) th:eq(1)').position().left + 150 });
    $resizer.simulate('mouseup');

    setTimeout(function () {
      expect($columnHeaders.eq(1).width()).toBe(154);
      expect($columnHeaders.eq(2).width()).toBe(155);
      expect($columnHeaders.eq(3).width()).toBe(155);
      done();
    }, 1000);
  });

  it('should resize appropriate columns to calculated stretch width after double click on column handler when stretchH is set as `all`', function (done) {
    this.$container.css('width', '910px');
    handsontable({
      colHeaders: true,
      manualColumnResize: true,
      stretchH: 'all'
    });

    resizeColumn(1, 65);

    var $columnHeaders = this.$container.find('thead tr:eq(1) th');

    expect($columnHeaders.eq(0).width()).toBe(209);
    expect($columnHeaders.eq(1).width()).toBe(64);
    expect($columnHeaders.eq(2).width()).toBe(210);
    expect($columnHeaders.eq(3).width()).toBe(210);
    expect($columnHeaders.eq(4).width()).toBe(211);

    var $th = $columnHeaders.eq(1);

    $th.simulate('mouseover');

    var $resizer = this.$container.find('.manualColumnResizer');
    var resizerPosition = $resizer.position();

    $resizer.simulate('mousedown', { clientX: resizerPosition.left });
    $resizer.simulate('mouseup');

    $resizer.simulate('mousedown', { clientX: resizerPosition.left });
    $resizer.simulate('mouseup');

    setTimeout(function () {
      expect($columnHeaders.eq(0).width()).toBe(180);
      expect($columnHeaders.eq(1).width()).toBe(181);
      expect($columnHeaders.eq(2).width()).toBe(181);
      expect($columnHeaders.eq(3).width()).toBe(181);
      expect($columnHeaders.eq(4).width()).toBe(181);
      done();
    }, 1000);
  });

  it('should resize appropriate columns to calculated autoColumnSize width after double click on column handler when stretchH is set as `last`', function (done) {
    this.$container.css('width', '910px');
    handsontable({
      colHeaders: true,
      manualColumnResize: true,
      stretchH: 'last'
    });

    resizeColumn(0, 65);

    var $columnHeaders = this.$container.find('thead tr:eq(0) th');

    expect($columnHeaders.eq(0).width()).toBe(63);
    expect($columnHeaders.eq(1).width()).toBe(48);
    expect($columnHeaders.eq(2).width()).toBe(49);
    expect($columnHeaders.eq(3).width()).toBe(49);
    expect($columnHeaders.eq(4).width()).toBe(694);

    var $th = $columnHeaders.eq(0);

    $th.simulate('mouseover');

    var $resizer = this.$container.find('.manualColumnResizer');
    var resizerPosition = $resizer.position();

    $resizer.simulate('mousedown', { clientX: resizerPosition.left });
    $resizer.simulate('mouseup');

    $resizer.simulate('mousedown', { clientX: resizerPosition.left });
    $resizer.simulate('mouseup');

    setTimeout(function () {
      expect($columnHeaders.eq(0).width()).toBeAroundValue(19);
      expect($columnHeaders.eq(1).width()).toBe(48);
      expect($columnHeaders.eq(2).width()).toBe(49);
      expect($columnHeaders.eq(3).width()).toBe(49);
      expect($columnHeaders.eq(4).width()).toBeAroundValue(738);
      done();
    }, 1000);
  });

  it('should resize appropriate columns, even if the column order was changed with manualColumnMove plugin', function () {
    handsontable({
      colHeaders: ['First', 'Second', 'Third'],
      manualColumnMove: [2, 1, 0, 3],
      manualColumnResize: true
    });

    var $columnHeaders = this.$container.find('thead tr:eq(0) th');
    var initialColumnWidths = [];

    $columnHeaders.each(function () {
      initialColumnWidths.push($(this).width());
    });

    resizeColumn.call(this, 0, 100);

    var $resizedTh = $columnHeaders.eq(0);

    expect($resizedTh.text()).toEqual('Third');
    expect($resizedTh.outerWidth()).toEqual(100);

    // Sizes of remaining columns should stay the same
    for (var i = 1; i < $columnHeaders.length; i++) {
      expect($columnHeaders.eq(i).width()).toEqual(initialColumnWidths[i]);
    }
  });

  it('should trigger an afterColumnResize event after column size changes', function () {
    var afterColumnResizeCallback = jasmine.createSpy('afterColumnResizeCallback');

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(3, 3),
      colHeaders: true,
      manualColumnResize: true,
      afterColumnResize: afterColumnResizeCallback
    });

    expect(colWidth(this.$container, 0)).toEqual(50);

    resizeColumn(0, 100);

    expect(afterColumnResizeCallback).toHaveBeenCalledWith(0, 100, void 0, void 0, void 0, void 0);
    expect(colWidth(this.$container, 0)).toEqual(100);
  });

  it('should not trigger an afterColumnResize event if column size does not change (mouseMove event width delta = 0)', function () {
    var afterColumnResizeCallback = jasmine.createSpy('afterColumnResizeCallback');

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(3, 3),
      colHeaders: true,
      manualColumnResize: true,
      afterColumnResize: afterColumnResizeCallback
    });

    expect(colWidth(this.$container, 0)).toEqual(50);

    resizeColumn(0, 50);

    expect(afterColumnResizeCallback).not.toHaveBeenCalled();
    expect(colWidth(this.$container, 0)).toEqual(50);
  });

  it('should not trigger an afterColumnResize event if column size does not change (no mouseMove event)', function () {
    var afterColumnResizeCallback = jasmine.createSpy('afterColumnResizeCallback');

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(3, 3),
      colHeaders: true,
      manualColumnResize: true,
      afterColumnResize: afterColumnResizeCallback
    });

    expect(colWidth(this.$container, 0)).toEqual(50);

    var $th = this.$container.find('thead tr:eq(0) th:eq(0)');
    $th.simulate('mouseover');

    var $resizer = this.$container.find('.manualColumnResizer');
    var resizerPosition = $resizer.position();

    $resizer.simulate('mousedown', { clientX: resizerPosition.left });
    $resizer.simulate('mouseup');

    expect(afterColumnResizeCallback).not.toHaveBeenCalled();
    expect(colWidth(this.$container, 0)).toEqual(50);
  });

  it('should trigger an afterColumnResize after column size changes, after double click', function (done) {
    var afterColumnResizeCallback = jasmine.createSpy('afterColumnResizeCallback');

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(3, 3),
      colHeaders: true,
      manualColumnResize: true,
      afterColumnResize: afterColumnResizeCallback
    });

    expect(colWidth(this.$container, 0)).toEqual(50);

    var $th = this.$container.find('thead tr:eq(0) th:eq(0)');

    $th.simulate('mouseover');

    var $resizer = this.$container.find('.manualColumnResizer');
    var resizerPosition = $resizer.position();

    $resizer.simulate('mousedown', { clientX: resizerPosition.left });
    $resizer.simulate('mouseup');

    $resizer.simulate('mousedown', { clientX: resizerPosition.left });
    $resizer.simulate('mouseup');

    setTimeout(function () {
      expect(afterColumnResizeCallback.calls.count()).toEqual(1);
      expect(afterColumnResizeCallback.calls.argsFor(0)[0]).toEqual(0);
      // All modern browsers returns width = 25px, but IE8 seems to compute width differently and returns 24px
      expect(afterColumnResizeCallback.calls.argsFor(0)[1]).toBeInArray([30, 31, 32, 24, 25]);
      expect(colWidth(spec().$container, 0)).toBeInArray([30, 31, 32, 24, 25]);
      done();
    }, 1000);
  });

  it('should autosize column after double click (when initial width is not defined)', function (done) {
    handsontable({
      data: Handsontable.helper.createSpreadsheetData(3, 3),
      colHeaders: true,
      manualColumnResize: true,
      columns: [{ width: 100 }, { width: 200 }, {}]
    });

    expect(colWidth(this.$container, 0)).toEqual(100);
    expect(colWidth(this.$container, 1)).toEqual(200);
    expect(colWidth(this.$container, 2)).toEqual(50);

    resizeColumn(2, 300);

    var $resizer = this.$container.find('.manualColumnResizer');
    var resizerPosition = $resizer.position();

    $resizer.simulate('mousedown', { clientX: resizerPosition.left });
    $resizer.simulate('mouseup');

    $resizer.simulate('mousedown', { clientX: resizerPosition.left });
    $resizer.simulate('mouseup');

    setTimeout(function () {
      expect(colWidth(spec().$container, 2)).toBeAroundValue(29, 3);
      done();
    }, 1000);
  });

  it('should autosize selected columns after double click on handler', function (done) {
    handsontable({
      data: Handsontable.helper.createSpreadsheetData(9, 9),
      colHeaders: true,
      manualColumnResize: true
    });

    resizeColumn(2, 300);

    this.$container.find('thead tr:eq(0) th:eq(1)').simulate('mousedown');
    this.$container.find('thead tr:eq(0) th:eq(2)').simulate('mouseover');
    this.$container.find('thead tr:eq(0) th:eq(3)').simulate('mouseover');
    this.$container.find('thead tr:eq(0) th:eq(3)').simulate('mousemove');
    this.$container.find('thead tr:eq(0) th:eq(3)').simulate('mouseup');

    var $resizer = spec().$container.find('.manualColumnResizer');
    var resizerPosition = $resizer.position();

    setTimeout(function () {
      $resizer.simulate('mousedown', { clientX: resizerPosition.left });
      $resizer.simulate('mouseup');
      $resizer.simulate('mousedown', { clientX: resizerPosition.left });
      $resizer.simulate('mouseup');
    }, 600);

    setTimeout(function () {
      expect(colWidth(spec().$container, 1)).toBeAroundValue(32, 2);
      expect(colWidth(spec().$container, 2)).toBeAroundValue(32, 2);
      expect(colWidth(spec().$container, 3)).toBeAroundValue(32, 2);
      done();
    }, 1200);
  });

  it('should adjust resize handles position after table size changed', function () {
    var maxed = false;

    handsontable({
      colHeaders: true,
      manualColumnResize: true,
      stretchH: 'all',
      width: function width() {
        return maxed ? 614 : 200;
      }
    });

    this.$container.find('thead th:eq(0)').simulate('mouseover');

    var handle = this.$container.find('.manualColumnResizer');
    var handleBox = handle[0].getBoundingClientRect();
    var th0 = this.$container.find('thead th:eq(0)');
    var thBox = th0[0].getBoundingClientRect();

    expect(handleBox.left + handleBox.width).toEqual(thBox.left + thBox.width - 1);

    maxed = true;

    render();
    this.$container.find('thead th:eq(0)').simulate('mouseover');

    handleBox = handle[0].getBoundingClientRect();
    thBox = th0[0].getBoundingClientRect();
    expect(handleBox.left + handleBox.width).toEqual(thBox.left + thBox.width - 1);
  });

  it('should display the resize handle in the correct place after the table has been scrolled', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(10, 20),
      colHeaders: true,
      manualColumnResize: true,
      height: 100,
      width: 200
    });

    var mainHolder = hot.view.wt.wtTable.holder;

    var $colHeader = this.$container.find('.ht_clone_top thead tr:eq(0) th:eq(2)');
    $colHeader.simulate('mouseover');
    var $handle = this.$container.find('.manualColumnResizer');
    $handle[0].style.background = 'red';

    expect($colHeader.offset().left + $colHeader.width() - 5).toBeCloseTo($handle.offset().left, 0);
    expect($colHeader.offset().top).toBeCloseTo($handle.offset().top, 0);

    $(mainHolder).scrollLeft(200);
    hot.render();

    $colHeader = this.$container.find('.ht_clone_top thead tr:eq(0) th:eq(3)');
    $colHeader.simulate('mouseover');
    expect($colHeader.offset().left + $colHeader.width() - 5).toBeCloseTo($handle.offset().left, 0);
    expect($colHeader.offset().top).toBeCloseTo($handle.offset().top, 0);
  });

  describe('handle and guide', function () {
    it('should display the resize handle in the proper position and with a proper size', function () {
      var hot = handsontable({
        data: [{ id: 1, name: 'Ted', lastName: 'Right' }, { id: 2, name: 'Frank', lastName: 'Honest' }, { id: 3, name: 'Joan', lastName: 'Well' }, { id: 4, name: 'Sid', lastName: 'Strong' }, { id: 5, name: 'Jane', lastName: 'Neat' }],
        colHeaders: true,
        manualColumnResize: true
      });

      var $headerTH = this.$container.find('thead tr:eq(0) th:eq(1)');
      $headerTH.simulate('mouseover');

      var $handle = $('.manualColumnResizer');

      expect($handle.offset().left).toEqual($headerTH.offset().left + $headerTH.outerWidth() - $handle.outerWidth() - 1);
      expect($handle.height()).toEqual($headerTH.outerHeight());
    });
  });
});

/***/ }),
/* 141 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('manualRowMove', function () {
  var id = 'testContainer';
  var arrayOfObjects = [{ id: 1, name: 'Ted', lastName: 'Right' }, { id: 2, name: 'Frank', lastName: 'Honest' }, { id: 3, name: 'Joan', lastName: 'Well' }, { id: 4, name: 'Sid', lastName: 'Strong' }, { id: 5, name: 'Jane', lastName: 'Neat' }, { id: 6, name: 'Chuck', lastName: 'Jackson' }, { id: 7, name: 'Meg', lastName: 'Jansen' }, { id: 8, name: 'Rob', lastName: 'Norris' }, { id: 9, name: 'Sean', lastName: 'O\'Hara' }, { id: 10, name: 'Eve', lastName: 'Branson' }];

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  describe('init', function () {
    it('should change row order at init', function () {
      handsontable({
        data: arrayOfObjects,
        manualRowMove: [1, 2, 0]
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('2');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('3');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('1');
    });
  });

  describe('updateSettings', function () {
    it('should be enabled after specifying it in updateSettings config', function () {
      handsontable({
        data: arrayOfObjects,
        rowHeaders: true
      });

      updateSettings({
        manualRowMove: true
      });

      this.$container.find('tbody tr:eq(0) th:eq(0)').simulate('mousedown');
      this.$container.find('tbody tr:eq(0) th:eq(0)').simulate('mouseup');

      expect(this.$container.hasClass('after-selection--rows')).toBeGreaterThan(0);
    });

    it('should change the default row order with updateSettings', function () {
      handsontable({
        data: arrayOfObjects,
        manualRowMove: true
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('2');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('3');

      updateSettings({
        manualRowMove: [2, 1, 0]
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('3');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('2');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('1');
    });

    it('should change row order with updateSettings', function () {
      handsontable({
        data: arrayOfObjects,
        manualRowMove: [1, 2, 0]
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('2');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('3');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('1');

      updateSettings({
        manualRowMove: [2, 1, 0]
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('3');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('2');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('1');
    });

    it('should reset row order with updateSettings when undefined is passed', function () {
      handsontable({
        data: arrayOfObjects,
        manualRowMove: [1, 2, 0]
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('2');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('3');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('1');

      updateSettings({
        manualRowMove: void 0
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('2');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('3');
    });

    it('should not change row order with updateSettings when `true` is passed', function () {
      handsontable({
        data: arrayOfObjects,
        manualRowMove: [1, 2, 0]
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('2');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('3');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('1');

      updateSettings({
        manualRowMove: true
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('2');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('3');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('1');
    });
  });

  describe('loadData', function () {
    it('should increase numbers of rows if it is necessary', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        manualRowMove: true
      });

      hot.loadData(Handsontable.helper.createSpreadsheetData(10, 10));

      expect(countRows()).toEqual(10);
      expect(hot.getPlugin('manualRowMove').rowsMapper.__arrayMap.length).toEqual(10);
    });
    it('should decrease numbers of rows if it is necessary', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        manualRowMove: true
      });

      hot.loadData(Handsontable.helper.createSpreadsheetData(2, 2));

      expect(countRows()).toEqual(2);
      expect(hot.getPlugin('manualRowMove').rowsMapper.__arrayMap.length).toEqual(2);
    });
  });

  describe('moving', function () {
    it('should move row by API', function () {
      var hot = handsontable({
        data: arrayOfObjects,
        rowHeaders: true,
        manualRowMove: true
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('2');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('3');

      hot.getPlugin('manualRowMove').moveRow(2, 0);
      hot.render();

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('3');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('1');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('2');
    });

    it('should move many rows by API', function () {
      var hot = handsontable({
        data: arrayOfObjects,
        rowHeaders: true,
        manualRowMove: true
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('2');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('3');

      hot.getPlugin('manualRowMove').moveRows([7, 9, 8], 0);
      hot.render();

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('8');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('10');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('9');
    });

    it('should trigger an beforeRowMove event before row move', function () {
      var beforeMoveRowCallback = jasmine.createSpy('beforeMoveRowCallback');

      var hot = handsontable({
        data: arrayOfObjects,
        rowHeaders: true,
        manualRowMove: true,
        beforeRowMove: beforeMoveRowCallback
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('2');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('3');

      hot.getPlugin('manualRowMove').moveRows([8, 9, 7], 0);
      hot.render();

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('9');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('10');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('8');

      expect(beforeMoveRowCallback).toHaveBeenCalledWith([8, 9, 7], 0, void 0, void 0, void 0, void 0);
    });

    it('should trigger an afterRowMove event after row move', function () {
      var afterMoveRowCallback = jasmine.createSpy('afterMoveRowCallback');

      this.$container.height(150);

      var hot = handsontable({
        data: arrayOfObjects,
        rowHeaders: true,
        manualRowMove: true,
        afterRowMove: afterMoveRowCallback
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('2');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('3');

      hot.getPlugin('manualRowMove').moveRows([8, 9, 7], 0);
      hot.render();

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('9');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('10');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('8');

      expect(afterMoveRowCallback).toHaveBeenCalledWith([8, 9, 7], 0, void 0, void 0, void 0, void 0);
    });

    it('should move the second row to the first row', function () {
      var hot = handsontable({
        data: arrayOfObjects,
        rowHeaders: true,
        manualRowMove: true
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('2');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('3');

      var $rowsHeaders = this.$container.find('.ht_clone_left tr th');

      $rowsHeaders.eq(1).simulate('mousedown');
      $rowsHeaders.eq(1).simulate('mouseup');
      $rowsHeaders.eq(1).simulate('mousedown');
      $rowsHeaders.eq(0).simulate('mouseover');
      $rowsHeaders.eq(0).simulate('mousemove');
      $rowsHeaders.eq(0).simulate('mouseup');

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('2');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('1');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('3');
    });

    it('should move the second row to the third row', function () {
      handsontable({
        data: arrayOfObjects,
        rowHeaders: true,
        manualRowMove: true
      });

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('2');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('3');

      var $rowsHeaders = this.$container.find('.ht_clone_left tr th');

      $rowsHeaders.eq(1).simulate('mousedown');
      $rowsHeaders.eq(1).simulate('mouseup');
      $rowsHeaders.eq(1).simulate('mousedown');
      $rowsHeaders.eq(3).simulate('mouseover');
      $rowsHeaders.eq(3).simulate('mousemove');
      $rowsHeaders.eq(3).simulate('mouseup');

      expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('1');
      expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('3');
      expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('2');
    });

    it('should not move row if it\'s not needed', function () {
      var cache = [];

      handsontable({
        data: arrayOfObjects,
        rowHeaders: true,
        manualRowMove: true,
        afterRowMove: function afterRowMove(rows, target) {
          cache.push(rows);
        }
      });

      var $rowsHeaders = this.$container.find('.ht_clone_left tr th');

      $rowsHeaders.eq(1).simulate('mousedown');
      $rowsHeaders.eq(1).simulate('mouseup');
      $rowsHeaders.eq(1).simulate('mousedown');
      $rowsHeaders.eq(3).simulate('mouseup');

      expect(cache.length).toEqual(0);
    });

    it('should properly scrolling viewport if mouse is over part-visible cell', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(20, 20),
        colHeaders: true,
        rowHeaders: true,
        manualRowMove: true,
        width: 600,
        height: 600,
        rowHeights: 47
      });

      var ev = {};

      hot.selectCell(19, 0);

      setTimeout(function () {
        expect(hot.view.wt.wtTable.getFirstVisibleRow()).toBeGreaterThan(8);

        var $rowsHeaders = spec().$container.find('.ht_clone_left tr th');

        $rowsHeaders.eq(10).simulate('mousedown');
        $rowsHeaders.eq(10).simulate('mouseup');
        $rowsHeaders.eq(10).simulate('mousedown');
        $rowsHeaders.eq(8).simulate('mouseover');
        $rowsHeaders.eq(8).simulate('mousemove');
        $rowsHeaders.eq(8).simulate('mouseup');
      }, 50);

      setTimeout(function () {
        expect(hot.view.wt.wtTable.getFirstVisibleRow()).toBeLessThan(8);
        done();
      }, 150);
    });

    it('moving row should keep cell meta created using cells function', function () {
      var hot = handsontable({
        data: arrayOfObjects,
        rowHeaders: true,
        manualRowMove: true,
        cells: function cells(row, col) {
          if (row == 1 && col == 0) {
            this.readOnly = true;
          }
        }
      });

      var htCore = getHtCore();

      expect(htCore.find('tbody tr:eq(1) td:eq(0)')[0].className.indexOf('htDimmed')).toBeGreaterThan(-1);

      hot.getPlugin('manualRowMove').moveRow(1, 3);
      hot.render();

      expect(htCore.find('tbody tr:eq(2) td:eq(0)')[0].className.indexOf('htDimmed')).toBeGreaterThan(-1);
    });

    it('moving row should keep cell meta created using cell array', function () {
      var hot = handsontable({
        data: arrayOfObjects,
        rowHeaders: true,
        manualRowMove: true,
        cell: [{ row: 1, col: 0, readOnly: true }]
      });

      var htCore = getHtCore();

      expect(htCore.find('tbody tr:eq(1) td:eq(0)')[0].className.indexOf('htDimmed')).toBeGreaterThan(-1);

      hot.getPlugin('manualRowMove').moveRow(3, 1);
      hot.render();

      expect(htCore.find('tbody tr:eq(2) td:eq(0)')[0].className.indexOf('htDimmed')).toBeGreaterThan(-1);
    });
  });

  describe('undoRedo', function () {
    it('should back changes', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        rowHeaders: true,
        manualRowMove: true
      });
      hot.getPlugin('manualRowMove').moveRow(1, 4);
      hot.render();

      expect(hot.getDataAtCell(3, 0)).toBe('A2');

      hot.undo();

      expect(hot.getDataAtCell(1, 0)).toBe('A2');
    });

    it('should revert changes', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        rowHeaders: true,
        manualRowMove: true
      });
      hot.getPlugin('manualRowMove').moveRow(1, 4);
      hot.render();

      expect(hot.getDataAtCell(3, 0)).toBe('A2');

      hot.undo();

      expect(hot.getDataAtCell(1, 0)).toBe('A2');

      hot.redo();

      expect(hot.getDataAtCell(3, 0)).toBe('A2');
    });
  });
});

/***/ }),
/* 142 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('manualRowMove', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  describe('UI', function () {
    it('should append UI elements to wtHider after click on row header', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(30, 30),
        rowHeaders: true,
        manualRowMove: true
      });

      var $headerTH = this.$container.find('tbody tr:eq(0) th:eq(0)');
      $headerTH.simulate('mousedown');
      $headerTH.simulate('mouseup');
      $headerTH.simulate('mousedown');

      expect(this.$container.find('.ht__manualRowMove--guideline').length).toBe(1);
      expect(this.$container.find('.ht__manualRowMove--backlight').length).toBe(1);
    });

    it('should part of UI elements be visible on dragging action', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(30, 30),
        rowHeaders: true,
        manualRowMove: true
      });

      var $headerTH = this.$container.find('tbody tr:eq(0) th:eq(0)');
      $headerTH.simulate('mousedown');
      $headerTH.simulate('mouseup');
      $headerTH.simulate('mousedown');

      expect(this.$container.find('.ht__manualRowMove--guideline:visible').length).toBe(0);
      expect(this.$container.find('.ht__manualRowMove--backlight:visible').length).toBe(1);
    });

    it('should all of UI elements be visible on dragging action', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(30, 30),
        rowHeaders: true,
        manualRowMove: true
      });

      var $headers = [this.$container.find('tbody tr:eq(0) th:eq(0)'), this.$container.find('tbody tr:eq(1) th:eq(0)'), this.$container.find('tbody tr:eq(2) th:eq(0)')];

      $headers[0].simulate('mousedown');
      $headers[0].simulate('mouseup');
      $headers[0].simulate('mousedown');
      $headers[1].simulate('mouseover');
      $headers[2].simulate('mouseover');

      expect(this.$container.find('.ht__manualRowMove--guideline:visible').length).toBe(1);
      expect(this.$container.find('.ht__manualRowMove--backlight:visible').length).toBe(1);
    });
  });
});

/***/ }),
/* 143 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('manualRowResize', function () {
  var id = 'test';
  var defaultRowHeight = 22;

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should change row heights at init', function () {
    handsontable({
      rowHeaders: true,
      manualRowResize: [50, 40, 100]
    });

    expect(rowHeight(this.$container, 0)).toEqual(51);
    expect(rowHeight(this.$container, 1)).toEqual(40);
    expect(rowHeight(this.$container, 2)).toEqual(100);
  });

  it('should be enabled after specifying it in updateSettings config', function () {
    var hot = handsontable({
      data: [{ id: 1, name: 'Ted', lastName: 'Right' }, { id: 2, name: 'Frank', lastName: 'Honest' }, { id: 3, name: 'Joan', lastName: 'Well' }, { id: 4, name: 'Sid', lastName: 'Strong' }, { id: 5, name: 'Jane', lastName: 'Neat' }],
      rowHeaders: true
    });

    updateSettings({ manualRowResize: true });

    this.$container.find('tbody tr:eq(0) th:eq(0)').simulate('mouseover');

    expect($('.manualRowResizer').size()).toBeGreaterThan(0);
  });

  it('should change the default row height with updateSettings', function () {
    handsontable({
      manualRowResize: true
    });

    expect(rowHeight(this.$container, 0)).toEqual(defaultRowHeight + 2); // + Double border
    expect(rowHeight(this.$container, 1)).toEqual(defaultRowHeight + 1); // + Single border
    expect(rowHeight(this.$container, 2)).toEqual(defaultRowHeight + 1); // + Single border

    updateSettings({
      manualRowResize: [60, 50, 80]
    });

    expect(rowHeight(this.$container, 0)).toEqual(61);
    expect(rowHeight(this.$container, 1)).toEqual(50);
    expect(rowHeight(this.$container, 2)).toEqual(80);
  });

  it('should change the row height with updateSettings', function () {
    handsontable({
      manualRowResize: [60, 50, 80]
    });

    expect(rowHeight(this.$container, 0)).toEqual(61);
    expect(rowHeight(this.$container, 1)).toEqual(50);
    expect(rowHeight(this.$container, 2)).toEqual(80);

    updateSettings({
      manualRowResize: [30, 80, 100]
    });

    expect(rowHeight(this.$container, 0)).toEqual(31);
    expect(rowHeight(this.$container, 1)).toEqual(80);
    expect(rowHeight(this.$container, 2)).toEqual(100);
  });

  it('should not change the row height when `true` is passing', function () {
    handsontable({
      manualRowResize: [60, 50, 80]
    });

    expect(rowHeight(this.$container, 0)).toEqual(61);
    expect(rowHeight(this.$container, 1)).toEqual(50);
    expect(rowHeight(this.$container, 2)).toEqual(80);

    updateSettings({
      manualRowResize: true
    });

    expect(rowHeight(this.$container, 0)).toEqual(61);
    expect(rowHeight(this.$container, 1)).toEqual(50);
    expect(rowHeight(this.$container, 2)).toEqual(80);
  });

  it('should change the row height to defaults when undefined is passed', function () {
    handsontable({
      manualRowResize: [60, 50, 80]
    });

    expect(rowHeight(this.$container, 0)).toEqual(61);
    expect(rowHeight(this.$container, 1)).toEqual(50);
    expect(rowHeight(this.$container, 2)).toEqual(80);

    updateSettings({
      manualRowResize: void 0
    });

    expect(rowHeight(this.$container, 0)).toEqual(defaultRowHeight + 2); // + Double border
    expect(rowHeight(this.$container, 1)).toEqual(defaultRowHeight + 1); // + Single border
    expect(rowHeight(this.$container, 2)).toEqual(defaultRowHeight + 1); // + Single border
  });

  it('should reset row height', function () {
    handsontable({
      manualRowResize: true
    });

    expect(rowHeight(this.$container, 0)).toEqual(defaultRowHeight + 2);
    expect(rowHeight(this.$container, 1)).toEqual(defaultRowHeight + 1);
    expect(rowHeight(this.$container, 2)).toEqual(defaultRowHeight + 1);

    updateSettings({
      manualRowResize: true
    });

    expect(rowHeight(this.$container, 0)).toEqual(defaultRowHeight + 2);
    expect(rowHeight(this.$container, 1)).toEqual(defaultRowHeight + 1);
    expect(rowHeight(this.$container, 2)).toEqual(defaultRowHeight + 1);
  });

  it('should trigger afterRowResize event after row height changes', function () {
    var afterRowResizeCallback = jasmine.createSpy('afterRowResizeCallback');

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 5),
      rowHeaders: true,
      manualRowResize: true,
      afterRowResize: afterRowResizeCallback
    });

    expect(rowHeight(this.$container, 0)).toEqual(defaultRowHeight + 2);

    resizeRow(0, 100);
    expect(afterRowResizeCallback).toHaveBeenCalledWith(0, 100, void 0, void 0, void 0, void 0);
    expect(rowHeight(this.$container, 0)).toEqual(101);
  });

  it('should not trigger afterRowResize event if row height does not change (delta = 0)', function () {
    var afterRowResizeCallback = jasmine.createSpy('afterRowResizeCallback');

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 5),
      rowHeaders: true,
      manualRowResize: true,
      afterRowResize: afterRowResizeCallback
    });

    expect(rowHeight(this.$container, 0)).toEqual(defaultRowHeight + 2);

    resizeRow(0, defaultRowHeight);
    expect(afterRowResizeCallback).not.toHaveBeenCalled();
    expect(rowHeight(this.$container, 0)).toEqual(defaultRowHeight + 2);
  });

  it('should not trigger afterRowResize event after if row height does not change (no mousemove event)', function () {
    var afterRowResizeCallback = jasmine.createSpy('afterRowResizeCallback');

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 5),
      rowHeaders: true,
      manualRowResize: true,
      afterRowResize: afterRowResizeCallback
    });

    expect(rowHeight(this.$container, 0)).toEqual(defaultRowHeight + 2);

    var $th = this.$container.find('tbody tr:eq(0) th:eq(0)');
    $th.simulate('mouseover');

    var $resizer = this.$container.find('.manualRowResizer');
    var resizerPosition = $resizer.position();

    $resizer.simulate('mousedown', {
      clientY: resizerPosition.top
    });

    $resizer.simulate('mouseup');

    expect(afterRowResizeCallback).not.toHaveBeenCalled();
    expect(rowHeight(this.$container, 0)).toEqual(defaultRowHeight + 2);
  });

  it('should trigger an afterRowResize after row size changes, after double click', function (done) {
    var afterRowResizeCallback = jasmine.createSpy('afterRowResizeCallback');

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 5),
      rowHeaders: true,
      manualRowResize: true,
      autoRowSize: true,
      afterRowResize: afterRowResizeCallback
    });

    expect(rowHeight(this.$container, 0)).toEqual(defaultRowHeight + 2);

    var $th = this.$container.find('tbody tr:eq(2) th:eq(0)');
    $th.simulate('mouseover');

    var $resizer = this.$container.find('.manualRowResizer');
    var resizerPosition = $resizer.position();

    $resizer.simulate('mousedown', {
      clientY: resizerPosition.top
    });
    $resizer.simulate('mouseup');

    $resizer.simulate('mousedown', {
      clientY: resizerPosition.top
    });
    $resizer.simulate('mouseup');

    setTimeout(function () {
      expect(afterRowResizeCallback.calls.count()).toEqual(1);
      expect(afterRowResizeCallback.calls.argsFor(0)[0]).toEqual(2);
      expect(afterRowResizeCallback.calls.argsFor(0)[1]).toEqual(defaultRowHeight + 1);
      expect(rowHeight(spec().$container, 2)).toEqual(defaultRowHeight + 1);
      done();
    }, 1000);
  });
  it('should not trigger afterRowResize event after if row height does not change (no dblclick event)', function () {
    var afterRowResizeCallback = jasmine.createSpy('afterRowResizeCallback');

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 5),
      rowHeaders: true,
      manualRowResize: true,
      afterRowResize: afterRowResizeCallback
    });

    expect(rowHeight(this.$container, 0)).toEqual(defaultRowHeight + 2);

    var $th = this.$container.find('tbody tr:eq(2) th:eq(0)');
    $th.simulate('mouseover');

    var $resizer = this.$container.find('.manualRowResizer');
    var resizerPosition = $resizer.position();

    $resizer.simulate('mousedown', {
      clientY: resizerPosition.top
    });
    $resizer.simulate('mouseup');

    expect(afterRowResizeCallback).not.toHaveBeenCalled();
    expect(rowHeight(this.$container, 0)).toEqual(defaultRowHeight + 2);
  });
  it('should display the resize handle in the correct place after the table has been scrolled', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(20, 20),
      rowHeaders: true,
      manualRowResize: true,
      height: 100,
      width: 200
    });

    var mainHolder = hot.view.wt.wtTable.holder;

    var $rowHeader = this.$container.find('.ht_clone_left tbody tr:eq(2) th:eq(0)');
    $rowHeader.simulate('mouseover');
    var $handle = this.$container.find('.manualRowResizer');
    $handle[0].style.background = 'red';

    expect($rowHeader.offset().left).toBeCloseTo($handle.offset().left, 0);
    expect($rowHeader.offset().top + $rowHeader.height() - 5).toBeCloseTo($handle.offset().top, 0);

    $(mainHolder).scrollTop(200);
    $(mainHolder).scroll();

    $rowHeader = this.$container.find('.ht_clone_left tbody tr:eq(2) th:eq(0)');
    $rowHeader.simulate('mouseover');
    expect($rowHeader.offset().left).toBeCloseTo($handle.offset().left, 0);
    expect($rowHeader.offset().top + $rowHeader.height() - 5).toBeCloseTo($handle.offset().top, 0);
  });

  it('should autosize selected rows after double click on handler', function (done) {
    handsontable({
      data: Handsontable.helper.createSpreadsheetData(9, 9),
      rowHeaders: true,
      manualRowResize: true
    });

    resizeRow(2, 300);

    var $resizer = this.$container.find('.manualRowResizer');
    var resizerPosition = $resizer.position();

    this.$container.find('.ht_clone_left tbody tr:eq(1) th:eq(0)').simulate('mousedown');
    this.$container.find('.ht_clone_left tbody tr:eq(2) th:eq(0)').simulate('mouseover');
    this.$container.find('.ht_clone_left tbody tr:eq(3) th:eq(0)').simulate('mouseover');
    this.$container.find('.ht_clone_left tbody tr:eq(3) th:eq(0)').simulate('mousemove');
    this.$container.find('.ht_clone_left tbody tr:eq(3) th:eq(0)').simulate('mouseup');

    setTimeout(function () {
      $resizer.simulate('mousedown', { clientY: resizerPosition.top });
      $resizer.simulate('mouseup');
      $resizer.simulate('mousedown', { clientY: resizerPosition.top });
      $resizer.simulate('mouseup');
    }, 600);

    setTimeout(function () {
      expect(rowHeight(spec().$container, 1)).toBeAroundValue(24);
      expect(rowHeight(spec().$container, 2)).toBeAroundValue(24);
      expect(rowHeight(spec().$container, 3)).toBeAroundValue(24);
      done();
    }, 1600);
  });

  it('should resize (expanding and narrowing) selected rows', function (done) {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(10, 20),
      rowHeaders: true,
      manualRowResize: true
    });

    resizeRow(2, 60);

    var $rowsHeaders = this.$container.find('.ht_clone_left tr th');
    this.$container.find('.ht_clone_left tbody tr:eq(1) th:eq(0)').simulate('mouseover');

    $rowsHeaders.eq(1).simulate('mousedown');
    $rowsHeaders.eq(2).simulate('mouseover');
    $rowsHeaders.eq(3).simulate('mouseover');
    $rowsHeaders.eq(3).simulate('mousemove');
    $rowsHeaders.eq(3).simulate('mouseup');

    var $resizer = this.$container.find('.manualRowResizer');
    var resizerPosition = $resizer.position();

    setTimeout(function () {
      $resizer.simulate('mousedown', { clientY: resizerPosition.top });
      $resizer.simulate('mousemove', { clientY: resizerPosition.top - $rowsHeaders.eq(3).height() + 80 });
      $resizer.simulate('mouseup');

      expect($rowsHeaders.eq(1).height()).toEqual(80);
      expect($rowsHeaders.eq(2).height()).toEqual(80);
      expect($rowsHeaders.eq(3).height()).toEqual(80);
    }, 600);

    setTimeout(function () {
      $resizer.simulate('mousedown', { clientY: resizerPosition.top });
      $resizer.simulate('mousemove', { clientY: resizerPosition.top - $rowsHeaders.eq(3).height() + 35 });
      $resizer.simulate('mouseup');

      expect($rowsHeaders.eq(1).height()).toEqual(35);
      expect($rowsHeaders.eq(2).height()).toEqual(35);
      expect($rowsHeaders.eq(3).height()).toEqual(35);
      done();
    }, 1800);
  });

  describe('handle and guide', function () {
    it('should display the resize handle in the proper position and with a proper size', function () {
      var hot = handsontable({
        data: [{ id: 1, name: 'Ted', lastName: 'Right' }, { id: 2, name: 'Frank', lastName: 'Honest' }, { id: 3, name: 'Joan', lastName: 'Well' }, { id: 4, name: 'Sid', lastName: 'Strong' }, { id: 5, name: 'Jane', lastName: 'Neat' }],
        rowHeaders: true,
        manualRowResize: true
      });

      var $headerTH = this.$container.find('tbody tr:eq(1) th:eq(0)');
      $headerTH.simulate('mouseover');

      var $handle = $('.manualRowResizer');

      expect($handle.offset().top).toBeCloseTo($headerTH.offset().top + $headerTH.outerHeight() - $handle.outerHeight() - 1, 0);
      expect($handle.width()).toBeCloseTo($headerTH.outerWidth(), 0);
    });
  });
});

/***/ }),
/* 144 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('MergeCells', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  describe('mergeCells option', function () {
    it('should merge cell in startup', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(10, 5),
        mergeCells: [{ row: 0, col: 0, rowspan: 2, colspan: 2 }]
      });
      var TD = hot.rootElement.querySelector('td');

      expect(TD.getAttribute('rowspan')).toBe('2');
      expect(TD.getAttribute('colspan')).toBe('2');
    });
  });

  describe('mergeCells updateSettings', function () {
    it('should allow to overwrite the initial settings using the updateSettings method', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(10, 10),
        mergeCells: [{ row: 0, col: 0, rowspan: 2, colspan: 2 }]
      });
      var TD = hot.rootElement.querySelector('td');
      expect(TD.getAttribute('rowspan')).toBe('2');
      expect(TD.getAttribute('colspan')).toBe('2');

      updateSettings({
        mergeCells: [{ row: 2, col: 2, rowspan: 2, colspan: 2 }]
      });

      TD = hot.rootElement.querySelector('td');
      expect(TD.getAttribute('rowspan')).toBe(null);
      expect(TD.getAttribute('colspan')).toBe(null);

      TD = getCell(2, 2);

      expect(TD.getAttribute('rowspan')).toBe('2');
      expect(TD.getAttribute('colspan')).toBe('2');
    });

    it('should allow resetting the merged cells by changing it to \'true\'', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(10, 10),
        mergeCells: [{ row: 0, col: 0, rowspan: 2, colspan: 2 }]
      });
      var TD = hot.rootElement.querySelector('td');
      expect(TD.getAttribute('rowspan')).toBe('2');
      expect(TD.getAttribute('colspan')).toBe('2');

      updateSettings({
        mergeCells: true
      });

      TD = hot.rootElement.querySelector('td');
      expect(TD.getAttribute('rowspan')).toBe(null);
      expect(TD.getAttribute('colspan')).toBe(null);
    });

    it('should allow resetting and turning off the mergeCells plugin by changing mergeCells to \'false\'', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(10, 10),
        mergeCells: [{ row: 0, col: 0, rowspan: 2, colspan: 2 }]
      });
      var TD = hot.rootElement.querySelector('td');
      expect(TD.getAttribute('rowspan')).toBe('2');
      expect(TD.getAttribute('colspan')).toBe('2');

      updateSettings({
        mergeCells: false
      });

      TD = hot.rootElement.querySelector('td');
      expect(TD.getAttribute('rowspan')).toBe(null);
      expect(TD.getAttribute('colspan')).toBe(null);
    });
  });

  describe('mergeCells copy', function () {
    it('should not copy text of cells that are merged into another cell', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(10, 5),
        mergeCells: [{ row: 0, col: 0, rowspan: 2, colspan: 2 }]
      });
      expect(hot.getCopyableText(0, 0, 2, 2)).toBe('A1\t\tC1\n\t\tC2\nA3\tB3\tC3');
    });
  });

  describe('merged cells selection', function () {

    it('should select the whole range of cells which form a merged cell', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(4, 4),
        mergeCells: [{
          row: 0,
          col: 0,
          colspan: 4,
          rowspan: 1
        }]
      });

      var $table = this.$container.find('table.htCore');
      var $td = $table.find('tr:eq(0) td:eq(0)');

      expect($td.attr('rowspan')).toEqual('1');
      expect($td.attr('colspan')).toEqual('4');

      expect(hot.getSelected()).toBeUndefined();

      hot.selectCell(0, 0);

      expect(hot.getSelected()).toEqual([0, 0, 0, 3]);

      deselectCell();

      hot.selectCell(0, 1);

      expect(hot.getSelected()).toEqual([0, 0, 0, 3]);
    });

    it('should always make a rectangular selection, when selecting merged and not merged cells', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(4, 4),
        mergeCells: [{
          row: 1,
          col: 1,
          colspan: 3,
          rowspan: 2
        }]
      });

      var $table = this.$container.find('table.htCore');
      var $td = $table.find('tr:eq(1) td:eq(1)');

      expect($td.attr('rowspan')).toEqual('2');
      expect($td.attr('colspan')).toEqual('3');

      expect(hot.getSelected()).toBeUndefined();

      hot.selectCell(0, 0);

      expect(hot.getSelected()).toEqual([0, 0, 0, 0]);

      deselectCell();

      hot.selectCell(0, 0, 1, 1);

      expect(hot.getSelected()).not.toEqual([0, 0, 1, 1]);
      expect(hot.getSelected()).toEqual([0, 0, 2, 3]);

      deselectCell();

      hot.selectCell(0, 1, 1, 1);

      expect(hot.getSelected()).toEqual([0, 1, 2, 3]);
    });

    it('should not switch the selection start point when selecting from non-merged cells to merged cells', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(10, 10),
        mergeCells: [{ row: 1, col: 1, rowspan: 3, colspan: 3 }, { row: 3, col: 4, rowspan: 2, colspan: 2 }]
      });

      $(hot.getCell(6, 6)).simulate('mousedown');

      expect(hot.getSelectedRange().from.col).toEqual(6);
      expect(hot.getSelectedRange().from.row).toEqual(6);

      $(hot.getCell(1, 1)).simulate('mouseenter');

      expect(hot.getSelectedRange().from.col).toEqual(6);
      expect(hot.getSelectedRange().from.row).toEqual(6);

      $(hot.getCell(3, 3)).simulate('mouseenter');

      expect(hot.getSelectedRange().from.col).toEqual(6);
      expect(hot.getSelectedRange().from.row).toEqual(6);

      $(hot.getCell(4, 4)).simulate('mouseenter');

      expect(hot.getSelectedRange().from.col).toEqual(6);
      expect(hot.getSelectedRange().from.row).toEqual(6);
    });

    it('should select cells in the correct direction when changing selections around a merged range', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(10, 10),
        mergeCells: [{ row: 4, col: 4, rowspan: 2, colspan: 2 }]
      });

      hot.selectCell(5, 5, 5, 2);
      expect(hot.getSelectedRange().getDirection()).toEqual('SE-NW');

      hot.selectCell(4, 4, 2, 5);
      expect(hot.getSelectedRange().getDirection()).toEqual('SW-NE');

      hot.selectCell(4, 4, 5, 7);
      expect(hot.getSelectedRange().getDirection()).toEqual('NW-SE');

      hot.selectCell(4, 5, 7, 5);
      expect(hot.getSelectedRange().getDirection()).toEqual('NE-SW');
    });

    it('should not add an area class to the selected cell if a single merged cell is selected', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(6, 6),
        mergeCells: [{
          row: 1,
          col: 1,
          colspan: 3,
          rowspan: 2
        }]
      });

      selectCell(1, 1);
      expect(getCell(1, 1).className.indexOf('area')).toEqual(-1);

      selectCell(1, 1, 4, 4);
      expect(getCell(1, 1).className.indexOf('area')).not.toEqual(-1);

      selectCell(1, 1);
      expect(getCell(1, 1).className.indexOf('area')).toEqual(-1);

      selectCell(0, 0);
      expect(getCell(1, 1).className.indexOf('area')).toEqual(-1);
    });
  });

  describe('merged cells scroll', function () {
    it('getCell should return merged cell parent', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(10, 5),
        mergeCells: [{ row: 0, col: 0, rowspan: 2, colspan: 2 }],
        height: 100,
        width: 400
      });

      var mergedCellParent = hot.getCell(0, 0);
      var mergedCellHidden = hot.getCell(1, 1);

      expect(mergedCellHidden).toBe(mergedCellParent);
    });

    it('should scroll viewport to beginning of a merged cell when it\'s clicked', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(10, 5),
        mergeCells: [{ row: 5, col: 0, rowspan: 2, colspan: 2 }],
        height: 100,
        width: 400
      });

      var mainHolder = hot.view.wt.wtTable.holder;

      mainHolder.scrollTop = 130;
      hot.render();

      expect(mainHolder.scrollTop).toBe(130);

      var TD = hot.getCell(5, 0);
      mouseDown(TD);
      mouseUp(TD);
      var mergedCellScrollTop = mainHolder.scrollTop;
      expect(mergedCellScrollTop).toBeLessThan(130);
      expect(mergedCellScrollTop).toBeGreaterThan(0);

      mainHolder.scrollTop = 0;
      hot.render();

      mainHolder.scrollTop = 130;
      hot.render();

      TD = hot.getCell(5, 2);
      mouseDown(TD);
      mouseUp(TD);
      var regularCellScrollTop = mainHolder.scrollTop;
      expect(mergedCellScrollTop).toBe(regularCellScrollTop);
    });

    it('should render whole merged cell even when most rows are not in the viewport - scrolled to top', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(40, 5),
        mergeCells: [{ row: 1, col: 0, rowspan: 21, colspan: 2 }, { row: 21, col: 2, rowspan: 18, colspan: 2 }],
        height: 100,
        width: 400
      });

      expect(hot.countRenderedRows()).toBe(39);
    });

    it('should render whole merged cell even when most rows are not in the viewport - scrolled to bottom', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(40, 5),
        mergeCells: [{ row: 1, col: 0, rowspan: 21, colspan: 2 }, { row: 21, col: 2, rowspan: 18, colspan: 2 }],
        height: 100,
        width: 400
      });

      var mainHolder = hot.view.wt.wtTable.holder;

      $(mainHolder).scrollTop(99999);
      hot.render();

      expect(hot.countRenderedRows()).toBe(39);
    });

    it('should render whole merged cell even when most columns are not in the viewport - scrolled to the left', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(5, 40),
        mergeCells: [{ row: 0, col: 1, rowspan: 2, colspan: 21 }, { row: 2, col: 21, rowspan: 2, colspan: 18 }],
        height: 100,
        width: 400
      });

      expect(hot.countRenderedCols()).toBe(39);
    });

    it('should render whole merged cell even when most columns are not in the viewport - scrolled to the right', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(5, 40),
        mergeCells: [{ row: 0, col: 1, rowspan: 2, colspan: 21 }, { row: 2, col: 21, rowspan: 2, colspan: 18 }],
        height: 100,
        width: 400
      });

      this.$container.scrollLeft(99999);
      hot.render();

      expect(hot.countRenderedCols()).toBe(39);
    });
  });

  describe('merge cells shift', function () {
    it('should shift the merged cells right, when inserting a column on the left side of them', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(20, 20),
        mergeCells: [{ row: 1, col: 1, rowspan: 2, colspan: 2 }, { row: 2, col: 5, rowspan: 2, colspan: 2 }],
        height: 400,
        width: 400
      });

      hot.alter('insert_col', 3, 2);

      expect(hot.mergeCells.mergedCellInfoCollection[0].col).toEqual(1);
      expect(hot.mergeCells.mergedCellInfoCollection[1].col).toEqual(6);
    });

    it('should shift the merged cells left, when removing a column on the left side of them', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(20, 20),
        mergeCells: [{ row: 1, col: 1, rowspan: 2, colspan: 2 }, { row: 2, col: 5, rowspan: 2, colspan: 2 }],
        height: 400,
        width: 400
      });

      hot.alter('remove_col', 3, 2);

      expect(hot.mergeCells.mergedCellInfoCollection[0].col).toEqual(1);
      expect(hot.mergeCells.mergedCellInfoCollection[1].col).toEqual(4);
    });

    it('should shift the merged cells down, when inserting a row above them', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(20, 20),
        mergeCells: [{ row: 1, col: 1, rowspan: 2, colspan: 2 }, { row: 5, col: 5, rowspan: 2, colspan: 2 }],
        height: 400,
        width: 400
      });

      hot.alter('insert_row', 3, 2);

      expect(hot.mergeCells.mergedCellInfoCollection[0].row).toEqual(1);
      expect(hot.mergeCells.mergedCellInfoCollection[1].row).toEqual(6);
    });

    it('should shift the merged cells down, when inserting a row above them', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(20, 20),
        mergeCells: [{ row: 1, col: 1, rowspan: 2, colspan: 2 }, { row: 5, col: 5, rowspan: 2, colspan: 2 }],
        height: 400,
        width: 400
      });

      hot.alter('remove_row', 3, 2);

      expect(hot.mergeCells.mergedCellInfoCollection[0].row).toEqual(1);
      expect(hot.mergeCells.mergedCellInfoCollection[1].row).toEqual(4);
    });
  });

  xdescribe('canMergeRange', function () {
    it('should return false if start and end cell is the same', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(10, 5)
      });
      var mergeCells = new Handsontable.plugins.MergeCells(hot);
      var coordsFrom = new WalkontableCellCoords(0, 1);
      var cellRange = new WalkontableCellRange(coordsFrom, coordsFrom, new WalkontableCellCoords(0, 1));
      var result = mergeCells.canMergeRange(cellRange);

      expect(result).toBe(false);
    });

    it('should return true for 2 consecutive cells in the same column', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(10, 5)
      });
      var mergeCells = new Handsontable.plugins.MergeCells(hot);
      var coordsFrom = new WalkontableCellCoords(0, 1);
      var cellRange = new WalkontableCellRange(coordsFrom, coordsFrom, new WalkontableCellCoords(1, 1));
      var result = mergeCells.canMergeRange(cellRange);

      expect(result).toBe(true);
    });

    it('should return true for 2 consecutive cells in the same row', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(10, 5)
      });
      var mergeCells = new Handsontable.MergeCells(hot);
      var coordsFrom = new WalkontableCellCoords(0, 1);
      var cellRange = new WalkontableCellRange(coordsFrom, coordsFrom, new WalkontableCellCoords(0, 2));
      var result = mergeCells.canMergeRange(cellRange);

      expect(result).toBe(true);
    });

    it('should return true for 4 neighboring cells', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(10, 5)
      });
      var mergeCells = new Handsontable.MergeCells(hot);
      var coordsFrom = new WalkontableCellCoords(0, 1);
      var cellRange = new WalkontableCellRange(coordsFrom, coordsFrom, new WalkontableCellCoords(1, 2));
      var result = mergeCells.canMergeRange(cellRange);

      expect(result).toBe(true);
    });
  });

  xdescribe('modifyTransform', function () {
    it('should not transform arrow right when entering a merged cell', function () {
      var mergeCellsSettings = [{ row: 1, col: 1, rowspan: 3, colspan: 3 }];
      var coords = new WalkontableCellCoords(1, 0);
      var currentSelection = new WalkontableCellRange(coords, coords, coords);
      var mergeCells = new Handsontable.MergeCells(mergeCellsSettings);
      var inDelta = new WalkontableCellCoords(0, 1);
      mergeCells.modifyTransform('modifyTransformStart', currentSelection, inDelta);

      expect(inDelta).toEqual(new WalkontableCellCoords(0, 1));
    });

    it('should transform arrow right when leaving a merged cell', function () {
      var mergeCellsSettings = [{ row: 1, col: 1, rowspan: 3, colspan: 3 }];
      var coords = new WalkontableCellCoords(1, 1);
      var currentSelection = new WalkontableCellRange(coords, coords, coords);
      var mergeCells = new Handsontable.MergeCells(mergeCellsSettings);
      var inDelta = new WalkontableCellCoords(0, 1);
      mergeCells.modifyTransform('modifyTransformStart', currentSelection, inDelta);

      expect(inDelta).toEqual(new WalkontableCellCoords(0, 3));
    });

    it('should transform arrow right when leaving a merged cell (return to desired row)', function () {
      var mergeCellsSettings = [{ row: 1, col: 1, rowspan: 3, colspan: 3 }];
      var mergeCells = new Handsontable.MergeCells(mergeCellsSettings);

      var coords = new WalkontableCellCoords(2, 0);
      var currentSelection = new WalkontableCellRange(coords, coords, coords);
      var inDelta = new WalkontableCellCoords(0, 1);
      mergeCells.modifyTransform('modifyTransformStart', currentSelection, inDelta);

      expect(inDelta).toEqual(new WalkontableCellCoords(-1, 1));

      coords = new WalkontableCellCoords(1, 1);
      currentSelection = new WalkontableCellRange(coords, coords, coords);
      inDelta = new WalkontableCellCoords(0, 1);
      mergeCells.modifyTransform('modifyTransformStart', currentSelection, inDelta);

      expect(inDelta).toEqual(new WalkontableCellCoords(1, 3));
    });

    it('should transform arrow left when entering a merged cell', function () {
      var mergeCellsSettings = [{ row: 1, col: 1, rowspan: 3, colspan: 3 }];
      var coords = new WalkontableCellCoords(1, 4);
      var currentSelection = new WalkontableCellRange(coords, coords, coords);
      var mergeCells = new Handsontable.MergeCells(mergeCellsSettings);
      var inDelta = new WalkontableCellCoords(0, -1);
      mergeCells.modifyTransform('modifyTransformStart', currentSelection, inDelta);

      expect(inDelta).toEqual(new WalkontableCellCoords(0, -3));
    });

    it('should not transform arrow left when leaving a merged cell', function () {
      var mergeCellsSettings = [{ row: 1, col: 1, rowspan: 3, colspan: 3 }];
      var coords = new WalkontableCellCoords(1, 1);
      var currentSelection = new WalkontableCellRange(coords, coords, coords);
      var mergeCells = new Handsontable.MergeCells(mergeCellsSettings);
      var inDelta = new WalkontableCellCoords(0, -1);
      mergeCells.modifyTransform('modifyTransformStart', currentSelection, inDelta);

      expect(inDelta).toEqual(new WalkontableCellCoords(0, -1));
    });

    it('should transform arrow left when leaving a merged cell (return to desired row)', function () {
      var mergeCellsSettings = [{ row: 1, col: 1, rowspan: 3, colspan: 3 }];
      var mergeCells = new Handsontable.MergeCells(mergeCellsSettings);

      var coords = new WalkontableCellCoords(2, 4);
      var currentSelection = new WalkontableCellRange(coords, coords, coords);
      var inDelta = new WalkontableCellCoords(0, -1);
      mergeCells.modifyTransform('modifyTransformStart', currentSelection, inDelta);

      expect(inDelta).toEqual(new WalkontableCellCoords(-1, -3));

      coords = new WalkontableCellCoords(1, 1);
      currentSelection = new WalkontableCellRange(coords, coords, coords);
      inDelta = new WalkontableCellCoords(0, -1);
      mergeCells.modifyTransform('modifyTransformStart', currentSelection, inDelta);

      expect(inDelta).toEqual(new WalkontableCellCoords(1, -1));
    });

    it('should not transform arrow down when entering a merged cell', function () {
      var mergeCellsSettings = [{ row: 1, col: 1, rowspan: 3, colspan: 3 }];
      var coords = new WalkontableCellCoords(0, 1);
      var currentSelection = new WalkontableCellRange(coords, coords, coords);
      var mergeCells = new Handsontable.MergeCells(mergeCellsSettings);
      var inDelta = new WalkontableCellCoords(0, -1);
      mergeCells.modifyTransform('modifyTransformStart', currentSelection, inDelta);

      expect(inDelta).toEqual(new WalkontableCellCoords(0, -1));
    });

    it('should transform arrow down when leaving a merged cell', function () {
      var mergeCellsSettings = [{ row: 1, col: 1, rowspan: 3, colspan: 3 }];
      var coords = new WalkontableCellCoords(1, 1);
      var currentSelection = new WalkontableCellRange(coords, coords, coords);
      var mergeCells = new Handsontable.MergeCells(mergeCellsSettings);
      var inDelta = new WalkontableCellCoords(1, 0);
      mergeCells.modifyTransform('modifyTransformStart', currentSelection, inDelta);

      expect(inDelta).toEqual(new WalkontableCellCoords(3, 0));
    });

    it('should transform arrow up when entering a merged cell', function () {
      var mergeCellsSettings = [{ row: 1, col: 1, rowspan: 3, colspan: 3 }];
      var coords = new WalkontableCellCoords(4, 1);
      var currentSelection = new WalkontableCellRange(coords, coords, coords);
      var mergeCells = new Handsontable.MergeCells(mergeCellsSettings);
      var inDelta = new WalkontableCellCoords(-1, 0);
      mergeCells.modifyTransform('modifyTransformStart', currentSelection, inDelta);

      expect(inDelta).toEqual(new WalkontableCellCoords(-3, 0));
    });

    it('should not transform arrow up when leaving a merged cell', function () {
      var mergeCellsSettings = [{ row: 1, col: 1, rowspan: 3, colspan: 3 }];
      var coords = new WalkontableCellCoords(1, 1);
      var currentSelection = new WalkontableCellRange(coords, coords, coords);
      var mergeCells = new Handsontable.MergeCells(mergeCellsSettings);
      var inDelta = new WalkontableCellCoords(-1, 0);
      mergeCells.modifyTransform('modifyTransformStart', currentSelection, inDelta);

      expect(inDelta).toEqual(new WalkontableCellCoords(-1, 0));
    });
  });

  describe('ContextMenu', function () {
    it('should disable `Merge cells` context menu item when context menu was triggered from corner header', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetObjectData(10, 5),
        rowHeaders: true,
        colHeaders: true,
        contextMenu: true,
        mergeCells: true
      });

      $('.ht_clone_top_left_corner .htCore').find('thead').find('th').eq(0).simulate('mousedown', { which: 3 });
      contextMenu();

      expect($('.htContextMenu tbody td.htDisabled').text()).toBe(['Insert column on the left', 'Insert column on the right', 'Remove row', 'Remove column', 'Undo', 'Redo', 'Read only', 'Alignment', 'Merge cells'].join(''));
    });
  });
});

/***/ }),
/* 145 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('HandsontableObserveChanges', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  function createHOT(data, observeChanges) {
    return handsontable({
      data: data,
      width: 200,
      height: 200,
      observeChanges: observeChanges
    });
  }

  describe('refreshing table after changes have been detected', function () {
    describe('array data', function () {
      it('should render newly added row', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);

        data.push(['A3', 'B3']);

        var htCore = getHtCore();

        setTimeout(function () {
          expect(htCore.find('tr').length).toEqual(3);
          expect(htCore.find('col').length).toEqual(2);
          done();
        }, 200);
      });

      it('should render newly added column', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);
        var htCore = getHtCore();

        data[0].push('C1');
        data[1].push('C2');

        setTimeout(function () {
          expect(htCore.find('tr').length).toEqual(2);
          expect(htCore.find('col').length).toEqual(3);
          done();
        }, 200);
      });

      it('should render removed row', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);
        var htCore = getHtCore();

        data.splice(0, 1); // removes one row at index 0

        setTimeout(function () {
          expect(htCore.find('tr').length).toEqual(1);
          expect(htCore.find('col').length).toEqual(2);
          done();
        }, 200);
      });

      it('should render removed column', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);
        var htCore = getHtCore();

        data[0].splice(0, 1); // removes one column at index 0 in first row
        data[1].splice(0, 1); // removes one column at index 0 in second row

        setTimeout(function () {
          expect(htCore.find('tr').length).toEqual(2);
          expect(htCore.find('col').length).toEqual(1);
          done();
        }, 200);
      });

      it('should render cell change from string to string', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);
        var htCore = getHtCore();

        data[0][0] = 'new string';

        setTimeout(function () {
          expect(htCore.find('td:eq(0)').html()).toEqual('new string');
          done();
        }, 200);
      });

      it('should render cell change in a new row', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);
        var htCore = getHtCore();

        data.push(['A3', 'B3']);

        setTimeout(function () {
          expect(htCore.find('tr:eq(2) td:eq(0)').html()).toEqual('A3');
          data[2][0] = 'new string';
        }, 200);

        setTimeout(function () {
          expect(htCore.find('tr:eq(2) td:eq(0)').html()).toEqual('new string');
          done();
        }, 1200);
      });

      it('should not render cell change when turned off (`observeChanges: false`)', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        createHOT(data, false);
        var htCore = getHtCore();

        data[0][0] = 'new string';

        setTimeout(function () {
          expect(htCore.find('td:eq(0)').html()).toEqual('A1');
          done();
        }, 100);
      });
    });
    describe('object data', function () {
      it('should render newly added row', function (done) {
        var data = Handsontable.helper.createSpreadsheetObjectData(2, 2);
        var hot = createHOT(data, true);
        var htCore = getHtCore();

        data.push({ prop0: 'A3', prop1: 'B3' });

        setTimeout(function () {
          expect(htCore.find('tr').length).toEqual(3);
          expect(htCore.find('col').length).toEqual(2);
          done();
        }, 200);
      });

      it('should render removed row', function (done) {
        var data = Handsontable.helper.createSpreadsheetObjectData(2, 2);
        var hot = createHOT(data, true);
        var htCore = getHtCore();

        data.splice(0, 1); // removes one row at index 0

        setTimeout(function () {
          expect(htCore.find('tr').length).toEqual(1);
          expect(htCore.find('col').length).toEqual(2);
          done();
        }, 200);
      });

      it('should render cell change from string to string', function (done) {
        var data = Handsontable.helper.createSpreadsheetObjectData(2, 2);
        var hot = createHOT(data, true);
        var htCore = getHtCore();

        data[0].prop0 = 'new string';

        setTimeout(function () {
          expect(htCore.find('td:eq(0)').html()).toEqual('new string');
          done();
        }, 200);
      });

      it('should render cell change in a new row', function (done) {
        var data = Handsontable.helper.createSpreadsheetObjectData(2, 2);
        var hot = createHOT(data, true);
        var htCore = getHtCore();

        data.push({ prop0: 'A3', prop1: 'B3' });

        setTimeout(function () {
          expect(htCore.find('tr:eq(2) td:eq(0)').html()).toEqual('A3');
          data[2].prop0 = 'new string';
        }, 200);

        setTimeout(function () {
          expect(htCore.find('tr:eq(2) td:eq(0)').html()).toEqual('new string');
          done();
        }, 1200);
      });

      it('should not break with undefined data properties', function () {
        var data = Handsontable.helper.createSpreadsheetObjectData(2, 2);
        data[0].prop0 = undefined;

        expect(function () {
          var hot = createHOT(data, true);
          var htCore = getHtCore();
        }).not.toThrow();
      });

      it('should not render cell change when turned off (`observeChanges: false`)', function (done) {
        var data = Handsontable.helper.createSpreadsheetObjectData(2, 2);
        createHOT(data, false);
        var htCore = getHtCore();

        data[0].prop0 = 'new string';

        setTimeout(function () {
          expect(htCore.find('td:eq(0)').html()).toEqual('A1');
          done();
        }, 200);
      });
    });
  });

  describe('enabling/disabling plugin', function () {
    it('should be possible to enable plugin using updateSettings', function (done) {
      var data = Handsontable.helper.createSpreadsheetData(2, 2);
      var hot = createHOT(data, false);
      var htCore = getHtCore();

      data[0][0] = 'new string';

      setTimeout(function () {
        expect(htCore.find('td:eq(0)').html()).toEqual('A1');

        updateSettings({
          observeChanges: true
        });
        data[1][0] = 'another new string';
      }, 200);

      setTimeout(function () {
        expect(htCore.find('tr:eq(1) td:eq(0)').html()).toEqual('another new string');
        done();
      }, 400);
    });

    it('should be possible to disable plugin using updateSettings', function (done) {
      var data = Handsontable.helper.createSpreadsheetData(2, 2);
      var hot = createHOT(data, true);
      var htCore = getHtCore();

      data[0][0] = 'new string';

      setTimeout(function () {
        expect(htCore.find('tbody tr:eq(0) td:eq(0)').html()).toEqual('new string');
        expect(htCore.find('tbody tr:eq(1) td:eq(0)').html()).toEqual('A2');

        updateSettings({
          observeChanges: false
        });

        data[1][0] = 'another new string';
      }, 200);

      setTimeout(function () {
        expect(htCore.find('tbody tr:eq(0) td:eq(0)').html()).toEqual('new string');
        expect(htCore.find('tbody tr:eq(1) td:eq(0)').html()).toEqual('A2');

        hot.render();

        expect(htCore.find('tbody tr:eq(0) td:eq(0)').html()).toEqual('new string');
        expect(htCore.find('tbody tr:eq(1) td:eq(0)').html()).toEqual('another new string');
        done();
      }, 300);
    });

    it('should be possible to pause observing changes without disabling the plugin', function (done) {
      var data = Handsontable.helper.createSpreadsheetData(2, 2);
      var hot = createHOT(data, true);
      var htCore = getHtCore();

      data[0][0] = 'new string';

      setTimeout(function () {
        expect(htCore.find('tbody tr:eq(0) td:eq(0)').html()).toEqual('new string');
        expect(htCore.find('tbody tr:eq(1) td:eq(0)').html()).toEqual('A2');

        hot.pauseObservingChanges();

        data[1][0] = 'another new string';
      }, 200);

      setTimeout(function () {
        expect(htCore.find('tbody tr:eq(0) td:eq(0)').html()).toEqual('new string');
        expect(htCore.find('tbody tr:eq(1) td:eq(0)').html()).toEqual('A2');

        hot.render();

        expect(htCore.find('tbody tr:eq(0) td:eq(0)').html()).toEqual('new string');
        expect(htCore.find('tbody tr:eq(1) td:eq(0)').html()).toEqual('another new string');
        done();
      }, 300);
    });

    it('should be possible to resume observing changes after it was paused', function (done) {
      var data = Handsontable.helper.createSpreadsheetData(2, 2);
      var hot = createHOT(data, true);
      var htCore = getHtCore();

      hot.pauseObservingChanges();

      data[0][0] = 'new string';

      setTimeout(function () {
        expect(htCore.find('tbody tr:eq(0) td:eq(0)').html()).toEqual('A1');
        expect(htCore.find('tbody tr:eq(1) td:eq(0)').html()).toEqual('A2');

        hot.resumeObservingChanges();
        data[1][0] = 'another new string';
      }, 100);

      setTimeout(function () {
        expect(htCore.find('tbody tr:eq(0) td:eq(0)').html()).toEqual('new string');
        expect(htCore.find('tbody tr:eq(1) td:eq(0)').html()).toEqual('another new string');
        done();
      }, 1200);
    });
  });

  describe('observeChanges fires appropriate events when changes are detected', function () {
    describe('array data', function () {
      it('should fire afterChangesObserved event after changes has been noticed', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);

        var afterChangesObservedCallback = jasmine.createSpy('afterChangesObservedCallback');
        hot.addHook('afterChangesObserved', afterChangesObservedCallback);

        data[0][0] = 'new string';

        setTimeout(function () {
          expect(afterChangesObservedCallback.calls.count()).toEqual(1);
          done();
        }, 200);
      });

      it('should fire afterCreateRow event after detecting that new row has been added', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);

        var afterCreateRowCallback = jasmine.createSpy('afterCreateRowCallback');
        hot.addHook('afterCreateRow', afterCreateRowCallback);

        data.push(['A2', 'B2']);

        setTimeout(function () {
          expect(afterCreateRowCallback.calls.count()).toEqual(1);
          expect(afterCreateRowCallback).toHaveBeenCalledWith(2, 1, 'ObserveChanges.change', undefined, undefined, undefined);
          done();
        }, 200);
      });

      it('should fire afterRemoveRow event after detecting that row has been removed', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);

        var afterRemoveRowCallback = jasmine.createSpy('afterRemoveRowCallback');
        hot.addHook('afterRemoveRow', afterRemoveRowCallback);

        data.pop();

        setTimeout(function () {
          expect(afterRemoveRowCallback.calls.count()).toEqual(1);
          expect(afterRemoveRowCallback).toHaveBeenCalledWith(1, 1, 'ObserveChanges.change', undefined, undefined, undefined);
          done();
        }, 200);
      });

      it('should fire afterRemoveRow event after detecting that multiple rows have been removed', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);

        var afterRemoveRowCallback = jasmine.createSpy('afterRemoveRowCallback');
        hot.addHook('afterRemoveRow', afterRemoveRowCallback);

        data.splice(0, 2);

        setTimeout(function () {
          expect(afterRemoveRowCallback.calls.count()).toEqual(2);

          // The order of run hooks depends on whether objectObserve uses native Object.observe or a shim
          var args = [];
          args.push(afterRemoveRowCallback.calls.argsFor(0));
          args.push(afterRemoveRowCallback.calls.argsFor(1));
          expect(args).toContain([1, 1, 'ObserveChanges.change', undefined, undefined, undefined]);
          expect(args).toContain([0, 1, 'ObserveChanges.change', undefined, undefined, undefined]);
          done();
        }, 200);
      });

      it('should fire afterCreateCol event after detecting that new col has been added', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);

        var afterCreateColCallback = jasmine.createSpy('afterCreateColCallback');
        hot.addHook('afterCreateCol', afterCreateColCallback);

        data[0].push('C1');
        data[1].push('C2');

        setTimeout(function () {
          expect(afterCreateColCallback.calls.count()).toEqual(1);
          expect(afterCreateColCallback.calls.argsFor(0)).toEqual([2, 1, 'ObserveChanges.change', undefined, undefined, undefined]);
          done();
        }, 200);
      });

      it('should fire afterRemoveCol event after detecting that col has been removed', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);

        var afterRemoveColCallback = jasmine.createSpy('afterRemoveColCallback');
        hot.addHook('afterRemoveCol', afterRemoveColCallback);

        data[0].pop();
        data[1].pop();

        setTimeout(function () {
          expect(afterRemoveColCallback.calls.count()).toEqual(1);
          expect(afterRemoveColCallback.calls.argsFor(0)).toEqual([1, 1, 'ObserveChanges.change', undefined, undefined, undefined]);
          done();
        }, 200);
      });

      it('should fire afterRemoveCol event after detecting that multiple cols have been removed', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);

        var afterRemoveColCallback = jasmine.createSpy('afterRemoveColCallback');
        hot.addHook('afterRemoveCol', afterRemoveColCallback);

        data[0].pop();
        data[0].pop();
        data[1].pop();
        data[1].pop();

        setTimeout(function () {
          expect(afterRemoveColCallback.calls.count()).toEqual(2);

          // The order of run hooks depends on whether objectObserve uses native Object.observe or a shim
          var args = [];
          args.push(afterRemoveColCallback.calls.argsFor(0));
          args.push(afterRemoveColCallback.calls.argsFor(1));
          expect(args).toContain([1, 1, 'ObserveChanges.change', undefined, undefined, undefined]);
          expect(args).toContain([0, 1, 'ObserveChanges.change', undefined, undefined, undefined]);
          done();
        }, 200);
      });

      it('should fire afterChange event after detecting that table data has changed', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);

        var afterChangeCallback = jasmine.createSpy('afterChangeCallback');
        hot.addHook('afterChange', afterChangeCallback);

        data[0][0] = 'new string';

        setTimeout(function () {
          expect(afterChangeCallback.calls.count()).toEqual(1);
          expect(afterChangeCallback).toHaveBeenCalledWith([0, 0, null, 'new string'], 'ObserveChanges.change', undefined, undefined, undefined, undefined);
          done();
        }, 200);
      });
    });
    describe('object data', function () {
      it('should fire afterChangesObserved event after changes has been noticed', function (done) {
        var data = Handsontable.helper.createSpreadsheetObjectData(2, 2);
        var hot = createHOT(data, true);

        var afterChangesObservedCallback = jasmine.createSpy('afterChangesObservedCallback');
        hot.addHook('afterChangesObserved', afterChangesObservedCallback);

        data[0].prop0 = 'new string';

        setTimeout(function () {
          expect(afterChangesObservedCallback.calls.count()).toEqual(1);
          done();
        }, 200);
      });

      it('should fire afterCreateRow event after detecting that new row has been added', function (done) {
        var data = Handsontable.helper.createSpreadsheetObjectData(2, 2);
        var hot = createHOT(data, true);

        var afterCreateRowCallback = jasmine.createSpy('afterCreateRowCallback');
        hot.addHook('afterCreateRow', afterCreateRowCallback);

        data.push({ prop0: 'A2', prop1: 'B2' });

        setTimeout(function () {
          expect(afterCreateRowCallback.calls.count()).toEqual(1);
          expect(afterCreateRowCallback).toHaveBeenCalledWith(2, 1, 'ObserveChanges.change', undefined, undefined, undefined);
          done();
        }, 200);
      });

      it('should fire afterRemoveRow event after detecting that row has been removed', function (done) {
        var data = Handsontable.helper.createSpreadsheetObjectData(2, 2);
        var hot = createHOT(data, true);

        var afterRemoveRowCallback = jasmine.createSpy('afterRemoveRowCallback');
        hot.addHook('afterRemoveRow', afterRemoveRowCallback);

        data.pop();

        setTimeout(function () {
          expect(afterRemoveRowCallback.calls.count()).toEqual(1);
          expect(afterRemoveRowCallback).toHaveBeenCalledWith(1, 1, 'ObserveChanges.change', undefined, undefined, undefined);
          done();
        }, 200);
      });

      it('should fire afterRemoveRow event after detecting that multiple rows have been removed', function (done) {
        var data = Handsontable.helper.createSpreadsheetObjectData(2, 2);
        var hot = createHOT(data, true);

        var afterRemoveRowCallback = jasmine.createSpy('afterRemoveRowCallback');
        hot.addHook('afterRemoveRow', afterRemoveRowCallback);

        data.splice(0, 2);

        setTimeout(function () {
          expect(afterRemoveRowCallback.calls.count()).toEqual(2);

          // The order of run hooks depends on whether objectObserve uses native Object.observe or a shim
          var args = [];
          args.push(afterRemoveRowCallback.calls.argsFor(0));
          args.push(afterRemoveRowCallback.calls.argsFor(1));
          expect(args).toContain([1, 1, 'ObserveChanges.change', undefined, undefined, undefined]);
          expect(args).toContain([0, 1, 'ObserveChanges.change', undefined, undefined, undefined]);
          done();
        }, 200);
      });

      it('should fire afterChange event after detecting that table data has changed', function (done) {
        var data = Handsontable.helper.createSpreadsheetObjectData(2, 2);
        var hot = createHOT(data, true);

        var afterChangeCallback = jasmine.createSpy('afterChangeCallback');
        hot.addHook('afterChange', afterChangeCallback);

        data[0].prop0 = 'new string';

        setTimeout(function () {
          expect(afterChangeCallback.calls.count()).toEqual(1);
          expect(afterChangeCallback).toHaveBeenCalledWith([0, 'prop0', null, 'new string'], 'ObserveChanges.change', undefined, undefined, undefined, undefined);
          done();
        }, 200);
      });
    });
  });

  describe('using HOT data manipulation methods, when observeChanges plugin is enabled', function () {
    describe('array data', function () {
      it('should run render ONCE after detecting that new row has been added', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);

        var afterRenderSpy = jasmine.createSpy('afterRenderSpy');
        hot.addHook('afterRender', afterRenderSpy);

        alter('insert_row');

        setTimeout(function () {
          expect(countRows()).toEqual(3);
          expect(afterRenderSpy.calls.count()).toEqual(1);
          done();
        }, 200);
      });

      it('should run render ONCE after detecting that row has been removed', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);

        var afterRenderSpy = jasmine.createSpy('afterRenderSpy');
        hot.addHook('afterRender', afterRenderSpy);

        var afterChangesObservedCallback = jasmine.createSpy('afterChangesObservedCallback');
        hot.addHook('afterChangesObserved', afterChangesObservedCallback);

        alter('remove_row');

        setTimeout(function () {
          expect(countRows()).toEqual(1);
          expect(afterChangesObservedCallback.calls.count()).toEqual(1);
          expect(afterRenderSpy.calls.count()).toEqual(1);
          done();
        }, 200);
      });

      it('should run render ONCE after detecting that new column has been added', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);

        var afterRenderSpy = jasmine.createSpy('afterRenderSpy');
        hot.addHook('afterRender', afterRenderSpy);

        alter('insert_col');

        setTimeout(function () {
          expect(countCols()).toEqual(3);
          expect(afterRenderSpy.calls.count()).toEqual(1);
          done();
        }, 200);
      });

      it('should run render ONCE after detecting that column has been removed', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);

        var afterRenderSpy = jasmine.createSpy('afterRenderSpy');
        hot.addHook('afterRender', afterRenderSpy);

        var afterChangesObservedCallback = jasmine.createSpy('afterChangesObservedCallback');
        hot.addHook('afterChangesObserved', afterChangesObservedCallback);

        alter('remove_col');

        setTimeout(function () {
          expect(countCols()).toEqual(1);
          expect(afterChangesObservedCallback.calls.count()).toEqual(1);
          expect(afterRenderSpy.calls.count()).toEqual(1);
          done();
        }, 200);
      });

      it('should run render ONCE after detecting that table data has changed', function (done) {
        var data = Handsontable.helper.createSpreadsheetData(2, 2);
        var hot = createHOT(data, true);
        var htCore = getHtCore();

        var afterRenderSpy = jasmine.createSpy('afterRenderSpy');
        hot.addHook('afterRender', afterRenderSpy);

        var afterChangesObservedCallback = jasmine.createSpy('afterChangesObservedCallback');
        hot.addHook('afterChangesObserved', afterChangesObservedCallback);

        setDataAtCell(0, 0, 'new value');

        setTimeout(function () {
          expect(htCore.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('new value');
          expect(afterChangesObservedCallback.calls.count()).toEqual(1);
          expect(afterRenderSpy.calls.count()).toEqual(1);
          done();
        }, 200);
      });
    });
    describe('object data', function () {
      it('should run render ONCE after detecting that new row has been added', function (done) {
        var data = Handsontable.helper.createSpreadsheetObjectData(2, 2);
        var hot = createHOT(data, true);

        var afterRenderSpy = jasmine.createSpy('afterRenderSpy');
        hot.addHook('afterRender', afterRenderSpy);

        alter('insert_row');

        setTimeout(function () {
          expect(countRows()).toEqual(3);
          expect(afterRenderSpy.calls.count()).toEqual(1);
          done();
        }, 200);
      });

      it('should run render ONCE after detecting that row has been removed', function (done) {
        var data = Handsontable.helper.createSpreadsheetObjectData(2, 2);
        var hot = createHOT(data, true);

        var afterRenderSpy = jasmine.createSpy('afterRenderSpy');
        hot.addHook('afterRender', afterRenderSpy);

        var afterChangesObservedCallback = jasmine.createSpy('afterChangesObservedCallback');
        hot.addHook('afterChangesObserved', afterChangesObservedCallback);

        alter('remove_row');

        setTimeout(function () {
          expect(countRows()).toEqual(1);
          expect(afterChangesObservedCallback.calls.count()).toEqual(1);
          expect(afterRenderSpy.calls.count()).toEqual(1);
          done();
        }, 200);
      });

      it('should run render ONCE after detecting that table data has changed', function (done) {
        var data = Handsontable.helper.createSpreadsheetObjectData(2, 2);
        var hot = createHOT(data, true);

        var afterRenderSpy = jasmine.createSpy('afterRenderSpy');
        hot.addHook('afterRender', afterRenderSpy);

        var afterChangesObservedCallback = jasmine.createSpy('afterChangesObservedCallback');
        hot.addHook('afterChangesObserved', afterChangesObservedCallback);

        setDataAtRowProp(0, 'prop0', 'new value');

        setTimeout(function () {
          expect(spec().$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('new value');
          expect(afterChangesObservedCallback.calls.count()).toEqual(1);
          expect(afterRenderSpy.calls.count()).toEqual(1);
          done();
        }, 200);
      });
    });
  });

  describe('refreshing table after changes have been detected', function () {
    it('should observe changes to new data bound using loadData', function (done) {
      var data = Handsontable.helper.createSpreadsheetData(2, 2);
      var newData = Handsontable.helper.createSpreadsheetData(2, 2);
      var hot = createHOT(data, true);
      var htCore = getHtCore();
      hot.loadData(newData);

      var afterRenderSpy = jasmine.createSpy('afterRenderSpy');
      hot.addHook('afterRender', afterRenderSpy);

      newData.push(['A3', 'B3']);

      setTimeout(function () {
        expect(afterRenderSpy.calls.count()).toBe(1);
        expect(htCore.find('tr').length).toEqual(3);
        expect(htCore.find('col').length).toEqual(2);
        done();
      }, 200);
    });

    it('should not observe changes to old data after it was replaced using loadData', function (done) {
      var data = Handsontable.helper.createSpreadsheetData(2, 2);
      var newData = Handsontable.helper.createSpreadsheetData(2, 2);
      var hot = createHOT(data, true);
      var htCore = getHtCore();
      hot.loadData(newData);

      var afterRenderSpy = jasmine.createSpy('afterRenderSpy');
      hot.addHook('afterRender', afterRenderSpy);

      data.push(['A3', 'B3']);

      setTimeout(function () {
        expect(afterRenderSpy.calls.count()).toBe(0);
        expect(htCore.find('tr').length).toEqual(2);
        expect(htCore.find('col').length).toEqual(2);
        done();
      }, 1000);
    });
  });
});

/***/ }),
/* 146 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('persistentState', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }

    window.localStorage.clear();
  });

  it('should save data, when persistentStateSave is run', function () {
    var hot = handsontable({
      persistentState: true
    });

    hot.runHooks('persistentStateSave', 'testData', 100);

    var rawStoredData = window.localStorage[id + '_testData'];

    expect(rawStoredData).toBeDefined();

    var storedData = JSON.parse(rawStoredData);

    expect(storedData).toEqual(100);
  });

  it('should NOT save data, when persistentStateSave is run, if plugin is not enabled', function () {
    var hot = handsontable({
      persistentState: false
    });

    hot.runHooks('persistentStateSave', 'testData', 100);

    var rawStoredData = window.localStorage[id + '_testData'];

    expect(rawStoredData).toBeUndefined();
  });

  it('should load data, when persistentStateLoad is run', function () {
    var hot = handsontable({
      persistentState: true
    });

    hot.runHooks('persistentStateSave', 'testData', 100);

    var storedData = {};
    hot.runHooks('persistentStateLoad', 'testData', storedData);

    expect(storedData.value).toEqual(100);
  });

  it('should NOT load data, when persistentStateLoad is run, if plugin is not enabled', function () {
    var hot = handsontable({
      persistentState: false
    });

    // We have to manually save data, as persistentStateSave won't work when the plugin is disabled
    window.localStorage[id + '_testData'] = JSON.stringify(100);

    var storedData = {};
    hot.runHooks('persistentStateLoad', 'testData', storedData);

    expect(storedData.value).toBeUndefined();
  });

  it('should clear the data under the given key, when persistentStateReset is run', function () {
    var hot = handsontable({
      persistentState: true
    });

    hot.runHooks('persistentStateSave', 'testData', 100);

    var storedData = {};
    hot.runHooks('persistentStateLoad', 'testData', storedData);

    expect(storedData.value).toEqual(100);

    hot.runHooks('persistentStateReset', 'testData');

    storedData = {};
    hot.runHooks('persistentStateLoad', 'testData', storedData);

    expect(storedData.value).toBeUndefined();
  });

  it('should NOT clear the data under the given key, when persistentStateReset is run', function () {
    var hot = handsontable({
      persistentState: false
    });

    // We have to manually save data, as persistentStateSave won't work when the plugin is disabled
    window.localStorage[id + '_testData'] = JSON.stringify(100);

    var storedData = {};
    hot.runHooks('persistentStateReset', 'testData');

    expect(JSON.parse(window.localStorage[id + '_testData'])).toEqual(100);
  });

  it('should clear all data, when persistentStateReset is run without specifying a key to reset', function () {
    var hot = handsontable({
      persistentState: true
    });

    hot.runHooks('persistentStateSave', 'testData0', 100);
    hot.runHooks('persistentStateSave', 'testData1', 'foo');
    hot.runHooks('persistentStateSave', 'testData2', 200);

    var storedData = [{}, {}, {}];
    hot.runHooks('persistentStateLoad', 'testData0', storedData[0]);
    hot.runHooks('persistentStateLoad', 'testData1', storedData[1]);
    hot.runHooks('persistentStateLoad', 'testData2', storedData[2]);

    expect(storedData[0].value).toEqual(100);
    expect(storedData[1].value).toEqual('foo');
    expect(storedData[2].value).toEqual(200);

    hot.runHooks('persistentStateReset');

    storedData = [{}, {}, {}];
    hot.runHooks('persistentStateLoad', 'testData0', storedData[0]);
    hot.runHooks('persistentStateLoad', 'testData1', storedData[1]);
    hot.runHooks('persistentStateLoad', 'testData2', storedData[2]);

    expect(storedData[0].value).toBeUndefined();
    expect(storedData[1].value).toBeUndefined();
    expect(storedData[2].value).toBeUndefined();
  });

  it('should allow to DISABLE plugin with updateSettings', function () {
    var hot = handsontable({
      persistentState: true
    });

    hot.runHooks('persistentStateSave', 'testData', 100);

    var storedData = {};
    hot.runHooks('persistentStateLoad', 'testData', storedData);

    expect(storedData.value).toEqual(100);

    updateSettings({
      persistentState: false
    });

    storedData = {};
    hot.runHooks('persistentStateLoad', 'testData', storedData);

    expect(storedData.value).toBeUndefined();
  });

  it('should allow to ENABLE plugin with updateSettings', function () {
    var hot = handsontable({
      persistentState: false
    });

    hot.runHooks('persistentStateSave', 'testData', 100);

    var storedData = {};
    hot.runHooks('persistentStateLoad', 'testData', storedData);

    expect(storedData.value).toBeUndefined();

    updateSettings({
      persistentState: true
    });

    hot.runHooks('persistentStateSave', 'testData', 100);

    storedData = {};
    hot.runHooks('persistentStateLoad', 'testData', storedData);

    expect(storedData.value).toEqual(100);
  });
});

/***/ }),
/* 147 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Search plugin', function () {

  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  describe('enabling/disabling plugin', function () {
    it('should expose `search` object when plugin is enabled', function () {

      var hot = handsontable({
        search: true
      });

      expect(hot.search).toBeDefined();
    });

    it('should NOT expose `search` object when plugin is disabled', function () {
      var hot = handsontable({
        search: false
      });

      expect(hot.search).not.toBeDefined();
    });

    it('plugin should be disabled by default', function () {
      var hot = handsontable();

      expect(hot.search).not.toBeDefined();
    });

    it('should disable plugin using updateSettings', function () {
      var hot = handsontable({
        search: true
      });

      expect(hot.search).toBeDefined();

      updateSettings({
        search: false
      });

      expect(hot.search).not.toBeDefined();
    });

    it('should enable plugin using updateSettings', function () {
      var hot = handsontable({
        search: false
      });

      expect(hot.search).not.toBeDefined();

      updateSettings({
        search: true
      });

      expect(hot.search).toBeDefined();
    });
  });

  describe('query method', function () {
    afterEach(function () {
      Handsontable.plugins.Search.global.setDefaultQueryMethod(Handsontable.plugins.Search.DEFAULT_QUERY_METHOD);
    });

    it('should use the default query method if no queryMethod is passed to query function', function () {
      spyOn(Handsontable.plugins.Search, 'DEFAULT_QUERY_METHOD');

      var defaultQueryMethod = Handsontable.plugins.Search.DEFAULT_QUERY_METHOD;

      Handsontable.plugins.Search.global.setDefaultQueryMethod(defaultQueryMethod);

      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        search: true
      });

      var searchResult = hot.search.query('A');

      expect(defaultQueryMethod.calls.count()).toEqual(25);
    });

    it('should use the custom default query method if no queryMethod is passed to query function', function () {
      var customDefaultQueryMethod = jasmine.createSpy('customDefaultQueryMethod');

      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        search: true
      });

      Handsontable.plugins.Search.global.setDefaultQueryMethod(customDefaultQueryMethod);

      var searchResult = hot.search.query('A');

      expect(customDefaultQueryMethod.calls.count()).toEqual(25);
    });

    it('should use the query method from the constructor if no queryMethod is passed to query function', function () {
      var customQueryMethod = jasmine.createSpy('customDefaultQueryMethod');

      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        search: {
          queryMethod: customQueryMethod
        }
      });

      var searchResult = hot.search.query('A');

      expect(customQueryMethod.calls.count()).toEqual(25);
    });

    it('should use method passed to query function', function () {
      var customQueryMethod = jasmine.createSpy('customQueryMethod');

      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        search: true
      });

      var searchResult = hot.search.query('A', null, customQueryMethod);

      expect(customQueryMethod.calls.count()).toEqual(25);
    });
  });

  describe('default query method', function () {

    it('should use query method to find phrase', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        search: true
      });

      var searchResult = hot.search.query('A');

      expect(searchResult.length).toEqual(5);

      for (var i = 0; i < searchResult.length; i++) {
        expect(searchResult[i].row).toEqual(i);
        expect(searchResult[i].col).toEqual(0);
        expect(searchResult[i].data).toEqual(hot.getDataAtCell(i, 0));
      }
    });

    it('default query method should be case insensitive', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        search: true
      });

      var searchResult = hot.search.query('a');

      expect(searchResult.length).toEqual(5);

      searchResult = hot.search.query('A');

      expect(searchResult.length).toEqual(5);
    });

    it('default query method should work with numeric values', function () {
      var hot = handsontable({
        data: [[1, 2], [22, 4]],
        search: true
      });

      var searchResult = hot.search.query('2');

      expect(searchResult.length).toEqual(2);
    });

    it('default query method should interpret query as string, not regex', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        search: true
      });

      var searchResult = hot.search.query('A*');

      expect(searchResult.length).toEqual(0);
    });

    it('default query method should always return false if query string is empty', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        search: true
      });

      var searchResult = hot.search.query('A');

      expect(searchResult.length).toEqual(5);

      searchResult = hot.search.query('');

      expect(searchResult.length).toEqual(0);
    });

    it('default query method should always return false if no query string has been specified', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        search: true
      });

      var searchResult = hot.search.query('A');

      expect(searchResult.length).toEqual(5);

      searchResult = hot.search.query();

      expect(searchResult.length).toEqual(0);
    });

    it('default query method should always return false if no query string is not a string', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        search: true
      });

      var searchResult = hot.search.query('A');

      expect(searchResult.length).toEqual(5);

      searchResult = hot.search.query([1, 2, 3]);

      expect(searchResult.length).toEqual(0);
    });
  });

  describe('search callback', function () {
    afterEach(function () {
      Handsontable.plugins.Search.global.setDefaultCallback(Handsontable.plugins.Search.DEFAULT_CALLBACK);
    });

    it('should invoke default callback for each cell', function () {
      spyOn(Handsontable.plugins.Search, 'DEFAULT_CALLBACK');

      var defaultCallback = Handsontable.plugins.Search.DEFAULT_CALLBACK;

      Handsontable.plugins.Search.global.setDefaultCallback(defaultCallback);

      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        search: true
      });

      var searchResult = hot.search.query('A');

      expect(defaultCallback.calls.count()).toEqual(25);
    });

    it('should change the default callback', function () {
      spyOn(Handsontable.plugins.Search, 'DEFAULT_CALLBACK');

      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        search: true
      });

      var defaultCallback = jasmine.createSpy('defaultCallback');
      Handsontable.plugins.Search.global.setDefaultCallback(defaultCallback);

      var searchResult = hot.search.query('A');

      expect(Handsontable.plugins.Search.DEFAULT_CALLBACK).not.toHaveBeenCalled();
      expect(defaultCallback.calls.count()).toEqual(25);
    });

    it('should invoke callback passed in constructor', function () {
      var searchCallback = jasmine.createSpy('searchCallback');

      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        search: {
          callback: searchCallback
        }
      });

      var searchResult = hot.search.query('A');

      expect(searchCallback.calls.count()).toEqual(25);
    });

    it('should invoke custom callback for each cell which has been tested', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        search: true
      });

      var searchCallback = jasmine.createSpy('searchCallback');

      var searchResult = hot.search.query('A', searchCallback);

      expect(searchCallback.calls.count()).toEqual(25);

      for (var rowIndex = 0, rowCount = countRows(); rowIndex < rowCount; rowIndex++) {
        for (var colIndex = 0, colCount = countCols(); colIndex < colCount; colIndex++) {
          var callArgs = searchCallback.calls.argsFor(rowIndex * 5 + colIndex);
          expect(callArgs[0]).toEqual(hot);
          expect(callArgs[1]).toEqual(rowIndex);
          expect(callArgs[2]).toEqual(colIndex);
          expect(callArgs[3]).toEqual(hot.getDataAtCell(rowIndex, colIndex));

          if (colIndex == 0) {
            expect(callArgs[4]).toBe(true);
          } else {
            expect(callArgs[4]).toBe(false);
          }
        }
      }
    });
  });

  describe('default search callback', function () {
    it('should add isSearchResult = true, to cell properties of all matched cells', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        search: true
      });

      var searchResult = hot.search.query('2');

      for (var rowIndex = 0, rowCount = countRows(); rowIndex < rowCount; rowIndex++) {
        for (var colIndex = 0, colCount = countCols(); colIndex < colCount; colIndex++) {
          var cellProperties = getCellMeta(rowIndex, colIndex);

          if (rowIndex == 1) {
            expect(cellProperties.isSearchResult).toBeTruthy();
          } else {
            expect(cellProperties.isSearchResult).toBeFalsy();
          }
        }
      }
    });
  });

  describe('search result decorator', function () {
    it('should add default search result class to cells which mach the query', function () {

      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        search: true
      });

      var searchResult = hot.search.query('2');

      render();

      for (var rowIndex = 0, rowCount = countRows(); rowIndex < rowCount; rowIndex++) {
        for (var colIndex = 0, colCount = countCols(); colIndex < colCount; colIndex++) {
          var cell = getCell(rowIndex, colIndex);

          if (rowIndex == 1) {
            expect($(cell).hasClass(Handsontable.plugins.Search.DEFAULT_SEARCH_RESULT_CLASS)).toBe(true);
          } else {
            expect($(cell).hasClass(Handsontable.plugins.Search.DEFAULT_SEARCH_RESULT_CLASS)).toBe(false);
          }
        }
      }
    });

    it('should add custom search result class to cells which mach the query', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        search: {
          searchResultClass: 'customSearchResultClass'
        }
      });

      var searchResult = hot.search.query('2');

      render();

      for (var rowIndex = 0, rowCount = countRows(); rowIndex < rowCount; rowIndex++) {
        for (var colIndex = 0, colCount = countCols(); colIndex < colCount; colIndex++) {
          var cell = getCell(rowIndex, colIndex);

          if (rowIndex == 1) {
            expect($(cell).hasClass('customSearchResultClass')).toBe(true);
          } else {
            expect($(cell).hasClass('customSearchResultClass')).toBe(false);
          }
        }
      }
    });
  });

  describe('HOT properties compatibility', function () {
    it('should work properly when the last row is empty', function () {
      // connected with https://github.com/handsontable/handsontable/issues/1606
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 5),
        colHeaders: true,
        search: true,
        minSpareRows: 1
      }),
          errorThrown = false;

      try {
        hot.search.query('A');
      } catch (err) {
        errorThrown = true;
      }

      expect(errorThrown).toBe(false);
    });
  });
});

/***/ }),
/* 148 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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; };

describe('UndoRedo', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  describe('core features', function () {
    describe('Array data', function () {
      describe('undo', function () {
        it('should undo single change', function () {
          handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2)
          });
          var HOT = getInstance();

          setDataAtCell(0, 0, 'X1');
          expect(getDataAtCell(0, 0)).toBe('X1');

          HOT.undo();
          expect(getDataAtCell(0, 0)).toBe('A1');
        });

        it('should undo single change on cell with validator', function (done) {
          handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2)
          });
          var HOT = getInstance();

          setDataAtCell(0, 0, 'X1');

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('X1');

            HOT.undo();
          }, 200);

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('A1');
            done();
          }, 400);
        });

        it('should undo creation of a single row', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2)
          });

          expect(countRows()).toEqual(2);

          alter('insert_row');

          expect(countRows()).toEqual(3);

          HOT.undo();

          expect(countRows()).toEqual(2);
        });

        it('should undo creation of multiple rows', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2)
          });

          expect(countRows()).toEqual(2);

          alter('insert_row', 0, 5);

          expect(countRows()).toEqual(7);

          HOT.undo();

          expect(countRows()).toEqual(2);
        });

        it('should undo creation of multiple rows with minSpareRows', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 1),
            minSpareRows: 2
          });

          expect(getData()).toEqual([['A1'], ['A2'], [null], [null]]);

          setDataAtCell(2, 0, 'A3');
          setDataAtCell(4, 0, 'A4');

          expect(getData()).toEqual([['A1'], ['A2'], ['A3'], [null], ['A4'], [null], [null]]);

          HOT.undo();
          HOT.undo();

          expect(getData()).toEqual([['A1'], ['A2'], [null], [null]]);
        });

        it('should undo removal of single row', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(3, 2)
          });

          expect(countRows()).toEqual(3);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(2, 0)).toEqual('A3');
          expect(getDataAtCell(2, 1)).toEqual('B3');

          alter('remove_row', 1);

          expect(countRows()).toEqual(2);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A3');
          expect(getDataAtCell(1, 1)).toEqual('B3');

          HOT.undo();

          expect(countRows()).toEqual(3);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(2, 0)).toEqual('A3');
          expect(getDataAtCell(2, 1)).toEqual('B3');
        });

        it('should undo removal of multiple rows', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(4, 2)
          });

          expect(countRows()).toEqual(4);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(2, 0)).toEqual('A3');
          expect(getDataAtCell(2, 1)).toEqual('B3');
          expect(getDataAtCell(3, 0)).toEqual('A4');
          expect(getDataAtCell(3, 1)).toEqual('B4');

          alter('remove_row', 1, 2);

          expect(countRows()).toEqual(2);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A4');
          expect(getDataAtCell(1, 1)).toEqual('B4');

          HOT.undo();

          expect(countRows()).toEqual(4);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(2, 0)).toEqual('A3');
          expect(getDataAtCell(2, 1)).toEqual('B3');
          expect(getDataAtCell(3, 0)).toEqual('A4');
          expect(getDataAtCell(3, 1)).toEqual('B4');
        });

        it('should undo creation of a single column (colHeaders: undefined)', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 3)
          });

          expect(countCols()).toEqual(3);

          alter('insert_col');

          expect(countCols()).toEqual(4);

          HOT.undo();

          expect(countCols()).toEqual(3);
        });

        it('should undo creation of a single column (colHeaders: true)', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 3),
            colHeaders: true
          });

          expect(countCols()).toEqual(3);
          expect(getColHeader()).toEqual(['A', 'B', 'C']);

          alter('insert_col');

          expect(countCols()).toEqual(4);
          expect(getColHeader()).toEqual(['A', 'B', 'C', 'D']);

          HOT.undo();

          expect(countCols()).toEqual(3);
          expect(getColHeader()).toEqual(['A', 'B', 'C']);
        });

        it('should undo creation of a single column (colHeaders: Array)', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 3),
            colHeaders: ['Header1', 'Header2', 'Header3']
          });

          expect(countCols()).toEqual(3);
          expect(getColHeader()).toEqual(['Header1', 'Header2', 'Header3']);

          alter('insert_col', 1);

          expect(countCols()).toEqual(4);
          expect(getColHeader()).toEqual(['Header1', 'B', 'Header2', 'Header3']);

          HOT.undo();

          expect(countCols()).toEqual(3);
          expect(getColHeader()).toEqual(['Header1', 'Header2', 'Header3']);
        });

        it('should undo creation of multiple columns (colHeaders: undefined)', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2)
          });

          expect(countCols()).toEqual(2);

          alter('insert_col', 1, 5);

          expect(countCols()).toEqual(7);

          HOT.undo();

          expect(countCols()).toEqual(2);
        });

        it('should undo creation of multiple columns (colHeaders: true)', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2),
            colHeaders: true
          });

          expect(countCols()).toEqual(2);
          expect(getColHeader()).toEqual(['A', 'B']);

          alter('insert_col', 1, 5);

          expect(countCols()).toEqual(7);
          expect(getColHeader()).toEqual(['A', 'B', 'C', 'D', 'E', 'F', 'G']);

          HOT.undo();

          expect(countCols()).toEqual(2);
          expect(getColHeader()).toEqual(['A', 'B']);
        });

        it('should undo creation of multiple columns (colHeaders: Array)', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2),
            colHeaders: ['Header1', 'Header2']
          });

          expect(countCols()).toEqual(2);
          expect(getColHeader()).toEqual(['Header1', 'Header2']);

          alter('insert_col', 1, 5);

          expect(countCols()).toEqual(7);
          expect(getColHeader()).toEqual(['Header1', 'B', 'C', 'D', 'E', 'F', 'Header2']);

          HOT.undo();

          expect(countCols()).toEqual(2);
          expect(getColHeader()).toEqual(['Header1', 'Header2']);
        });

        it('should undo creation of multiple columns with minSpareCols', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(1, 1),
            minSpareCols: 2
          });

          expect(getData()).toEqual([['A1', null, null]]);

          setDataAtCell(0, 1, 'B1');
          setDataAtCell(0, 3, 'C1');

          expect(getData()).toEqual([['A1', 'B1', null, 'C1', null, null]]);

          HOT.undo();
          HOT.undo();

          expect(getData()).toEqual([['A1', null, null]]);
        });

        it('should undo removal of single column (colHeaders: undefined)', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 3)
          });

          expect(countCols()).toEqual(3);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(0, 2)).toEqual('C1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(1, 2)).toEqual('C2');

          alter('remove_col', 1);

          expect(countCols()).toEqual(2);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('C1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('C2');

          HOT.undo();

          expect(countCols()).toEqual(3);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(0, 2)).toEqual('C1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(1, 2)).toEqual('C2');
        });

        it('should undo removal of single column (colHeaders: true)', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2),
            colHeaders: true
          });

          expect(countCols()).toEqual(2);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getColHeader()).toEqual(['A', 'B']);

          alter('remove_col');

          expect(countCols()).toEqual(1);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toBeNull();
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toBeNull();
          expect(getColHeader()).toEqual(['A']);

          HOT.undo();

          expect(countCols()).toEqual(2);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');

          expect(getColHeader()).toEqual(['A', 'B']);
        });

        it('should undo removal of single column (colHeaders: Array)', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2),
            colHeaders: ['Header1', 'Header2']
          });

          expect(countCols()).toEqual(2);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getColHeader()).toEqual(['Header1', 'Header2']);

          alter('remove_col');

          expect(countCols()).toEqual(1);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toBeNull();
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toBeNull();
          expect(getColHeader()).toEqual(['Header1']);

          HOT.undo();

          expect(countCols()).toEqual(2);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');

          expect(getColHeader()).toEqual(['Header1', 'Header2']);
        });

        it('should undo removal of multiple columns (colHeaders: undefined)', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 4)
          });

          expect(countCols()).toEqual(4);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(0, 2)).toEqual('C1');
          expect(getDataAtCell(0, 3)).toEqual('D1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(1, 2)).toEqual('C2');
          expect(getDataAtCell(1, 3)).toEqual('D2');

          alter('remove_col', 1, 2);

          expect(countCols()).toEqual(2);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('D1');
          expect(getDataAtCell(0, 2)).toBeNull();
          expect(getDataAtCell(0, 3)).toBeNull();
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('D2');
          expect(getDataAtCell(1, 2)).toBeNull();
          expect(getDataAtCell(1, 3)).toBeNull();

          HOT.undo();

          expect(countCols()).toEqual(4);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(0, 2)).toEqual('C1');
          expect(getDataAtCell(0, 3)).toEqual('D1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(1, 2)).toEqual('C2');
          expect(getDataAtCell(1, 3)).toEqual('D2');
        });

        it('should undo removal of multiple columns (colHeaders: true)', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 4),
            colHeaders: true
          });

          expect(countCols()).toEqual(4);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(0, 2)).toEqual('C1');
          expect(getDataAtCell(0, 3)).toEqual('D1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(1, 2)).toEqual('C2');
          expect(getDataAtCell(1, 3)).toEqual('D2');
          expect(getColHeader()).toEqual(['A', 'B', 'C', 'D']);

          alter('remove_col', 1, 3);

          expect(countCols()).toEqual(1);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toBeNull();
          expect(getDataAtCell(0, 2)).toBeNull();
          expect(getDataAtCell(0, 3)).toBeNull();
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toBeNull();
          expect(getDataAtCell(1, 2)).toBeNull();
          expect(getDataAtCell(1, 3)).toBeNull();
          expect(getColHeader()).toEqual(['A']);

          HOT.undo();

          expect(countCols()).toEqual(4);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(0, 2)).toEqual('C1');
          expect(getDataAtCell(0, 3)).toEqual('D1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(1, 2)).toEqual('C2');
          expect(getDataAtCell(1, 3)).toEqual('D2');
          expect(getColHeader()).toEqual(['A', 'B', 'C', 'D']);
        });

        it('should undo removal of multiple columns (colHeaders: Array)', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 4),
            colHeaders: ['Header1', 'Header2', 'Header3', 'Header4']
          });

          expect(countCols()).toEqual(4);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(0, 2)).toEqual('C1');
          expect(getDataAtCell(0, 3)).toEqual('D1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(1, 2)).toEqual('C2');
          expect(getDataAtCell(1, 3)).toEqual('D2');
          expect(getColHeader()).toEqual(['Header1', 'Header2', 'Header3', 'Header4']);

          alter('remove_col', 1, 2);

          expect(countCols()).toEqual(2);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('D1');
          expect(getDataAtCell(0, 2)).toBeNull();
          expect(getDataAtCell(0, 3)).toBeNull();
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('D2');
          expect(getDataAtCell(1, 2)).toBeNull();
          expect(getDataAtCell(1, 3)).toBeNull();
          expect(getColHeader()).toEqual(['Header1', 'Header4']);

          HOT.undo();

          expect(countCols()).toEqual(4);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(0, 2)).toEqual('C1');
          expect(getDataAtCell(0, 3)).toEqual('D1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(1, 2)).toEqual('C2');
          expect(getDataAtCell(1, 3)).toEqual('D2');
          expect(getColHeader()).toEqual(['Header1', 'Header2', 'Header3', 'Header4']);
        });

        it('should undo removal of multiple columns (with a used manualColumnMove)', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 7),
            manualColumnMove: [3, 2, 0, 6, 1, 5, 4]
          });

          expect(countCols()).toEqual(7);
          expect(getDataAtRow(0)).toEqual(['D1', 'C1', 'A1', 'G1', 'B1', 'F1', 'E1']);

          alter('remove_col', 1, 3);

          expect(countCols()).toEqual(4);
          expect(getDataAtRow(0)).toEqual(['D1', 'B1', 'F1', 'E1']);

          // HOT.undo();
          //
          // expect(countCols()).toEqual(7);
          // expect(getDataAtRow(0)).toEqual(['D1', 'C1', 'A1', 'G1', 'B1', 'F1', 'E1']);
        });

        it('should undo multiple changes', function () {
          handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2)
          });
          var HOT = getInstance();

          setDataAtCell(0, 0, 'X1');
          setDataAtCell(1, 0, 'X2');
          setDataAtCell(0, 1, 'Y1');
          setDataAtCell(1, 1, 'Y2');

          expect(getDataAtCell(0, 0)).toBe('X1');
          expect(getDataAtCell(1, 0)).toBe('X2');
          expect(getDataAtCell(0, 1)).toBe('Y1');
          expect(getDataAtCell(1, 1)).toBe('Y2');

          HOT.undo();
          expect(getDataAtCell(0, 0)).toBe('X1');
          expect(getDataAtCell(1, 0)).toBe('X2');
          expect(getDataAtCell(0, 1)).toBe('Y1');
          expect(getDataAtCell(1, 1)).toBe('B2');

          HOT.undo();
          expect(getDataAtCell(0, 0)).toBe('X1');
          expect(getDataAtCell(1, 0)).toBe('X2');
          expect(getDataAtCell(0, 1)).toBe('B1');
          expect(getDataAtCell(1, 1)).toBe('B2');

          HOT.undo();
          expect(getDataAtCell(0, 0)).toBe('X1');
          expect(getDataAtCell(1, 0)).toBe('A2');
          expect(getDataAtCell(0, 1)).toBe('B1');
          expect(getDataAtCell(1, 1)).toBe('B2');

          HOT.undo();
          expect(getDataAtCell(0, 0)).toBe('A1');
          expect(getDataAtCell(1, 0)).toBe('A2');
          expect(getDataAtCell(0, 1)).toBe('B1');
          expect(getDataAtCell(1, 1)).toBe('B2');

          HOT.undo();
          expect(getDataAtCell(0, 0)).toBe('A1');
          expect(getDataAtCell(1, 0)).toBe('A2');
          expect(getDataAtCell(0, 1)).toBe('B1');
          expect(getDataAtCell(1, 1)).toBe('B2');
        });

        it('should undo multiple changes in cells with validators', function (done) {
          handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2)
          });
          var HOT = getInstance();

          setDataAtCell(0, 0, 'X1');
          setDataAtCell(1, 0, 'X2');
          setDataAtCell(0, 1, 'Y1');
          setDataAtCell(1, 1, 'Y2');

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('X1');
            expect(getDataAtCell(1, 0)).toBe('X2');
            expect(getDataAtCell(0, 1)).toBe('Y1');
            expect(getDataAtCell(1, 1)).toBe('Y2');

            HOT.undo();
          }, 200);

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('X1');
            expect(getDataAtCell(1, 0)).toBe('X2');
            expect(getDataAtCell(0, 1)).toBe('Y1');
            expect(getDataAtCell(1, 1)).toBe('B2');

            HOT.undo();
          }, 400);

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('X1');
            expect(getDataAtCell(1, 0)).toBe('X2');
            expect(getDataAtCell(0, 1)).toBe('B1');
            expect(getDataAtCell(1, 1)).toBe('B2');

            HOT.undo();
          }, 600);

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('X1');
            expect(getDataAtCell(1, 0)).toBe('A2');
            expect(getDataAtCell(0, 1)).toBe('B1');
            expect(getDataAtCell(1, 1)).toBe('B2');

            HOT.undo();
          }, 800);

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('A1');
            expect(getDataAtCell(1, 0)).toBe('A2');
            expect(getDataAtCell(0, 1)).toBe('B1');
            expect(getDataAtCell(1, 1)).toBe('B2');

            HOT.undo();
          }, 1000);

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('A1');
            expect(getDataAtCell(1, 0)).toBe('A2');
            expect(getDataAtCell(0, 1)).toBe('B1');
            expect(getDataAtCell(1, 1)).toBe('B2');
            done();
          }, 1200);
        });

        it('should undo multiple row creations', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2)
          });

          expect(countRows()).toEqual(2);

          alter('insert_row');
          alter('insert_row');
          alter('insert_row');
          alter('insert_row');

          expect(countRows()).toEqual(6);

          HOT.undo();
          expect(countRows()).toEqual(5);

          HOT.undo();
          expect(countRows()).toEqual(4);

          HOT.undo();
          expect(countRows()).toEqual(3);

          HOT.undo();
          expect(countRows()).toEqual(2);

          HOT.undo();
          expect(countRows()).toEqual(2);
        });

        it('should undo multiple row removals', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(4, 2)
          });

          expect(countRows()).toEqual(4);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(2, 0)).toEqual('A3');
          expect(getDataAtCell(2, 1)).toEqual('B3');
          expect(getDataAtCell(3, 0)).toEqual('A4');
          expect(getDataAtCell(3, 1)).toEqual('B4');

          alter('remove_row');
          alter('remove_row');
          alter('remove_row');

          expect(countRows()).toEqual(1);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');

          HOT.undo();
          expect(countRows()).toEqual(2);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');

          HOT.undo();
          expect(countRows()).toEqual(3);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(2, 0)).toEqual('A3');
          expect(getDataAtCell(2, 1)).toEqual('B3');

          HOT.undo();
          expect(countRows()).toEqual(4);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(2, 0)).toEqual('A3');
          expect(getDataAtCell(2, 1)).toEqual('B3');
          expect(getDataAtCell(3, 0)).toEqual('A4');
          expect(getDataAtCell(3, 1)).toEqual('B4');

          HOT.undo();
          expect(countRows()).toEqual(4);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(2, 0)).toEqual('A3');
          expect(getDataAtCell(2, 1)).toEqual('B3');
          expect(getDataAtCell(3, 0)).toEqual('A4');
          expect(getDataAtCell(3, 1)).toEqual('B4');
        });

        it('should undo changes only for table where the change actually took place', function () {
          this.$container2 = $('<div id="' + id + '-2"></div>').appendTo('body');

          var hot1 = handsontable({
            data: [[1], [2], [3]]
          });

          this.$container2.handsontable({
            data: [['A'], ['B'], ['C']]
          });

          var hot2 = this.$container2.handsontable('getInstance');

          hot1.setDataAtCell(0, 0, 4);
          expect(hot1.getDataAtCell(0, 0)).toEqual(4);
          expect(hot2.getDataAtCell(0, 0)).toEqual('A');

          hot2.undo();
          expect(hot2.getDataAtCell(0, 0)).toEqual('A');
          expect(hot1.getDataAtCell(0, 0)).toEqual(4);

          hot1.undo();
          expect(hot2.getDataAtCell(0, 0)).toEqual('A');
          expect(hot1.getDataAtCell(0, 0)).toEqual(1);

          hot2.destroy();
          this.$container2.remove();
        });
      });
      describe('redo', function () {
        it('should redo single change', function () {
          handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2)
          });
          var HOT = getInstance();

          setDataAtCell(0, 0, 'new value');

          expect(getDataAtCell(0, 0)).toBe('new value');

          HOT.undo();
          expect(getDataAtCell(0, 0)).toBe('A1');

          HOT.redo();
          expect(getDataAtCell(0, 0)).toBe('new value');
        });

        it('should redo single change in cell with validator', function (done) {
          handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2)
          });
          var HOT = getInstance();

          setDataAtCell(0, 0, 'new value');

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('new value');

            HOT.undo();
          }, 200);

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('A1');

            HOT.redo();
          }, 400);

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('new value');
            done();
          }, 600);
        });

        it('should redo creation of a single row', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2)
          });

          expect(countRows()).toEqual(2);

          alter('insert_row');

          expect(countRows()).toEqual(3);

          HOT.undo();

          expect(countRows()).toEqual(2);

          HOT.redo();

          expect(countRows()).toEqual(3);
        });

        it('should redo creation of multiple rows', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2)
          });

          expect(countRows()).toEqual(2);

          alter('insert_row', 0, 5);

          expect(countRows()).toEqual(7);

          HOT.undo();

          expect(countRows()).toEqual(2);

          HOT.redo();

          expect(countRows()).toEqual(7);
        });

        it('should redo removal of single row', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(3, 2)
          });

          expect(countRows()).toEqual(3);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(2, 0)).toEqual('A3');
          expect(getDataAtCell(2, 1)).toEqual('B3');

          alter('remove_row', 1);

          expect(countRows()).toEqual(2);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A3');
          expect(getDataAtCell(1, 1)).toEqual('B3');

          HOT.undo();

          expect(countRows()).toEqual(3);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(2, 0)).toEqual('A3');
          expect(getDataAtCell(2, 1)).toEqual('B3');

          HOT.redo();

          expect(countRows()).toEqual(2);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A3');
          expect(getDataAtCell(1, 1)).toEqual('B3');
        });

        it('should redo removal of multiple rows', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(4, 2)
          });

          expect(countRows()).toEqual(4);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(2, 0)).toEqual('A3');
          expect(getDataAtCell(2, 1)).toEqual('B3');
          expect(getDataAtCell(3, 0)).toEqual('A4');
          expect(getDataAtCell(3, 1)).toEqual('B4');

          alter('remove_row', 1, 2);

          expect(countRows()).toEqual(2);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A4');
          expect(getDataAtCell(1, 1)).toEqual('B4');

          HOT.undo();

          expect(countRows()).toEqual(4);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(2, 0)).toEqual('A3');
          expect(getDataAtCell(2, 1)).toEqual('B3');
          expect(getDataAtCell(3, 0)).toEqual('A4');
          expect(getDataAtCell(3, 1)).toEqual('B4');

          HOT.redo();

          expect(countRows()).toEqual(2);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A4');
          expect(getDataAtCell(1, 1)).toEqual('B4');
        });

        it('should redo creation of a single column', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2)
          });

          expect(countCols()).toEqual(2);

          alter('insert_col');

          expect(countCols()).toEqual(3);

          HOT.undo();

          expect(countCols()).toEqual(2);

          HOT.redo();

          expect(countCols()).toEqual(3);
        });

        it('should redo creation of multiple columns', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2)
          });

          expect(countCols()).toEqual(2);

          alter('insert_col', 1, 5);

          expect(countCols()).toEqual(7);

          HOT.undo();

          expect(countCols()).toEqual(2);

          HOT.redo();

          expect(countCols()).toEqual(7);
        });

        it('should redo removal of single column', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2)
          });

          expect(countCols()).toEqual(2);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');

          alter('remove_col');

          expect(countCols()).toEqual(1);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toBeNull();
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toBeNull();

          HOT.undo();

          expect(countCols()).toEqual(2);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');

          HOT.redo();

          expect(countCols()).toEqual(1);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toBeNull();
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toBeNull();
        });

        it('should redo removal of multiple columns', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 4)
          });

          expect(countCols()).toEqual(4);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(0, 2)).toEqual('C1');
          expect(getDataAtCell(0, 3)).toEqual('D1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(1, 2)).toEqual('C2');
          expect(getDataAtCell(1, 3)).toEqual('D2');

          alter('remove_col', 1, 3);

          expect(countCols()).toEqual(1);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toBeNull();
          expect(getDataAtCell(0, 2)).toBeNull();
          expect(getDataAtCell(0, 3)).toBeNull();
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toBeNull();
          expect(getDataAtCell(1, 2)).toBeNull();
          expect(getDataAtCell(1, 3)).toBeNull();

          HOT.undo();

          expect(countCols()).toEqual(4);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(0, 2)).toEqual('C1');
          expect(getDataAtCell(0, 3)).toEqual('D1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(1, 2)).toEqual('C2');
          expect(getDataAtCell(1, 3)).toEqual('D2');

          HOT.redo();

          expect(countCols()).toEqual(1);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toBeNull();
          expect(getDataAtCell(0, 2)).toBeNull();
          expect(getDataAtCell(0, 3)).toBeNull();
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toBeNull();
          expect(getDataAtCell(1, 2)).toBeNull();
          expect(getDataAtCell(1, 3)).toBeNull();
        });

        it('should redo multiple changes', function () {
          handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2)
          });
          var HOT = getInstance();

          setDataAtCell(0, 0, 'X1');
          setDataAtCell(1, 0, 'X2');
          setDataAtCell(0, 1, 'Y1');
          setDataAtCell(1, 1, 'Y2');

          expect(getDataAtCell(0, 0)).toBe('X1');
          expect(getDataAtCell(1, 0)).toBe('X2');
          expect(getDataAtCell(0, 1)).toBe('Y1');
          expect(getDataAtCell(1, 1)).toBe('Y2');

          HOT.undo();
          HOT.undo();
          HOT.undo();
          HOT.undo();

          expect(getDataAtCell(0, 0)).toBe('A1');
          expect(getDataAtCell(1, 0)).toBe('A2');
          expect(getDataAtCell(0, 1)).toBe('B1');
          expect(getDataAtCell(1, 1)).toBe('B2');

          HOT.redo();
          expect(getDataAtCell(0, 0)).toBe('X1');
          expect(getDataAtCell(1, 0)).toBe('A2');
          expect(getDataAtCell(0, 1)).toBe('B1');
          expect(getDataAtCell(1, 1)).toBe('B2');

          HOT.redo();
          expect(getDataAtCell(0, 0)).toBe('X1');
          expect(getDataAtCell(1, 0)).toBe('X2');
          expect(getDataAtCell(0, 1)).toBe('B1');
          expect(getDataAtCell(1, 1)).toBe('B2');

          HOT.redo();
          expect(getDataAtCell(0, 0)).toBe('X1');
          expect(getDataAtCell(1, 0)).toBe('X2');
          expect(getDataAtCell(0, 1)).toBe('Y1');
          expect(getDataAtCell(1, 1)).toBe('B2');

          HOT.redo();
          expect(getDataAtCell(0, 0)).toBe('X1');
          expect(getDataAtCell(1, 0)).toBe('X2');
          expect(getDataAtCell(0, 1)).toBe('Y1');
          expect(getDataAtCell(1, 1)).toBe('Y2');

          HOT.redo();
          expect(getDataAtCell(0, 0)).toBe('X1');
          expect(getDataAtCell(1, 0)).toBe('X2');
          expect(getDataAtCell(0, 1)).toBe('Y1');
          expect(getDataAtCell(1, 1)).toBe('Y2');
        });

        it('should redo multiple changes in cell with validator', function (done) {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2)
          });

          setDataAtCell(0, 0, 'X1');
          setDataAtCell(1, 0, 'X2');
          setDataAtCell(0, 1, 'Y1');
          setDataAtCell(1, 1, 'Y2');

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('X1');
            expect(getDataAtCell(1, 0)).toBe('X2');
            expect(getDataAtCell(0, 1)).toBe('Y1');
            expect(getDataAtCell(1, 1)).toBe('Y2');

            HOT.undo();
          }, 200);

          setTimeout(function () {
            HOT.undo();
          }, 400);

          setTimeout(function () {
            HOT.undo();
          }, 600);

          setTimeout(function () {
            HOT.undo();
          }, 800);

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('A1');
            expect(getDataAtCell(1, 0)).toBe('A2');
            expect(getDataAtCell(0, 1)).toBe('B1');
            expect(getDataAtCell(1, 1)).toBe('B2');

            HOT.redo();
          }, 1000);

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('X1');
            expect(getDataAtCell(1, 0)).toBe('A2');
            expect(getDataAtCell(0, 1)).toBe('B1');
            expect(getDataAtCell(1, 1)).toBe('B2');

            HOT.redo();
          }, 1200);

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('X1');
            expect(getDataAtCell(1, 0)).toBe('X2');
            expect(getDataAtCell(0, 1)).toBe('B1');
            expect(getDataAtCell(1, 1)).toBe('B2');

            HOT.redo();
          }, 1400);

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('X1');
            expect(getDataAtCell(1, 0)).toBe('X2');
            expect(getDataAtCell(0, 1)).toBe('Y1');
            expect(getDataAtCell(1, 1)).toBe('B2');

            HOT.redo();
          }, 1600);

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('X1');
            expect(getDataAtCell(1, 0)).toBe('X2');
            expect(getDataAtCell(0, 1)).toBe('Y1');
            expect(getDataAtCell(1, 1)).toBe('Y2');

            HOT.redo();
          }, 1800);

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('X1');
            expect(getDataAtCell(1, 0)).toBe('X2');
            expect(getDataAtCell(0, 1)).toBe('Y1');
            expect(getDataAtCell(1, 1)).toBe('Y2');
            done();
          }, 2000);
        });

        it('should redo multiple row creations', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(2, 2)
          });

          expect(countRows()).toEqual(2);

          alter('insert_row');
          alter('insert_row');
          alter('insert_row');
          alter('insert_row');

          expect(countRows()).toEqual(6);

          HOT.undo();
          HOT.undo();
          HOT.undo();
          HOT.undo();

          expect(countRows()).toEqual(2);

          HOT.redo();
          expect(countRows()).toEqual(3);

          HOT.redo();
          expect(countRows()).toEqual(4);

          HOT.redo();
          expect(countRows()).toEqual(5);

          HOT.redo();
          expect(countRows()).toEqual(6);

          HOT.redo();
          expect(countRows()).toEqual(6);
        });

        it('should undo multiple row removals', function () {
          var HOT = handsontable({
            data: Handsontable.helper.createSpreadsheetData(4, 2)
          });

          expect(countRows()).toEqual(4);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(2, 0)).toEqual('A3');
          expect(getDataAtCell(2, 1)).toEqual('B3');
          expect(getDataAtCell(3, 0)).toEqual('A4');
          expect(getDataAtCell(3, 1)).toEqual('B4');

          alter('remove_row');
          alter('remove_row');
          alter('remove_row');

          expect(countRows()).toEqual(1);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');

          HOT.undo();
          HOT.undo();
          HOT.undo();

          expect(countRows()).toEqual(4);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(2, 0)).toEqual('A3');
          expect(getDataAtCell(2, 1)).toEqual('B3');
          expect(getDataAtCell(3, 0)).toEqual('A4');
          expect(getDataAtCell(3, 1)).toEqual('B4');

          HOT.redo();
          expect(countRows()).toEqual(3);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');
          expect(getDataAtCell(2, 0)).toEqual('A3');
          expect(getDataAtCell(2, 1)).toEqual('B3');

          HOT.redo();
          expect(countRows()).toEqual(2);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
          expect(getDataAtCell(1, 0)).toEqual('A2');
          expect(getDataAtCell(1, 1)).toEqual('B2');

          HOT.redo();
          expect(countRows()).toEqual(1);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');

          HOT.redo();
          expect(countRows()).toEqual(1);
          expect(getDataAtCell(0, 0)).toEqual('A1');
          expect(getDataAtCell(0, 1)).toEqual('B1');
        });

        it('should redo changes only for table where the change actually took place', function () {
          this.$container2 = $('<div id="' + id + '-2"></div>').appendTo('body');

          var hot1 = handsontable({
            data: [[1], [2], [3]]
          });

          this.$container2.handsontable({
            data: [['A'], ['B'], ['C']]
          });

          var hot2 = this.$container2.handsontable('getInstance');

          hot1.setDataAtCell(0, 0, 4);
          expect(hot1.getDataAtCell(0, 0)).toEqual(4);
          expect(hot2.getDataAtCell(0, 0)).toEqual('A');

          hot1.undo();
          expect(hot1.getDataAtCell(0, 0)).toEqual(1);
          expect(hot2.getDataAtCell(0, 0)).toEqual('A');

          hot2.redo();
          expect(hot1.getDataAtCell(0, 0)).toEqual(1);
          expect(hot2.getDataAtCell(0, 0)).toEqual('A');

          hot1.redo();
          expect(hot1.getDataAtCell(0, 0)).toEqual(4);
          expect(hot2.getDataAtCell(0, 0)).toEqual('A');

          hot2.destroy();
          this.$container2.remove();
        });
      });
    });

    describe('Object data', function () {

      function createObjectData() {
        return [{ name: 'Timothy', surname: 'Dalton' }, { name: 'Sean', surname: 'Connery' }, { name: 'Roger', surname: 'Moore' }];
      }

      describe('undo', function () {
        it('should undo single change', function () {
          handsontable({
            data: createObjectData()
          });
          var HOT = getInstance();

          setDataAtRowProp(0, 0, 'Pearce');
          expect(getDataAtRowProp(0, 0)).toBe('Pearce');

          HOT.undo();
          expect(getDataAtCell(0, 0)).toBe('Timothy');
        });

        it('should undo single change in cell with validator', function (done) {
          handsontable({
            data: createObjectData()
          });
          var HOT = getInstance();

          setDataAtRowProp(0, 0, 'Pearce');

          setTimeout(function () {
            expect(getDataAtRowProp(0, 0)).toBe('Pearce');

            HOT.undo();
          }, 200);

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('Timothy');
            done();
          }, 400);
        });

        it('should undo creation of a single row', function () {
          var HOT = handsontable({
            data: createObjectData().slice(0, 2)
          });

          expect(countRows()).toEqual(2);

          alter('insert_row');

          expect(countRows()).toEqual(3);

          HOT.undo();

          expect(countRows()).toEqual(2);
        });

        it('should undo creation of multiple rows', function () {
          var HOT = handsontable({
            data: createObjectData().slice(0, 2)
          });

          expect(countRows()).toEqual(2);

          alter('insert_row', 0, 5);

          expect(countRows()).toEqual(7);

          HOT.undo();

          expect(countRows()).toEqual(2);
        });

        it('should undo removal of single row', function () {
          var HOT = handsontable({
            data: createObjectData().slice(0, 2)
          });

          expect(countRows()).toEqual(2);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toEqual('Sean');
          expect(getDataAtRowProp(1, 'surname')).toEqual('Connery');

          alter('remove_row');

          expect(countRows()).toEqual(1);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toBeNull();
          expect(getDataAtRowProp(1, 'surname')).toBeNull();

          HOT.undo();

          expect(countRows()).toEqual(2);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toEqual('Sean');
          expect(getDataAtRowProp(1, 'surname')).toEqual('Connery');
        });

        it('should undo removal of multiple rows', function () {
          var HOT = handsontable({
            data: createObjectData()
          });

          expect(countRows()).toEqual(3);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toEqual('Sean');
          expect(getDataAtRowProp(1, 'surname')).toEqual('Connery');
          expect(getDataAtRowProp(2, 'name')).toEqual('Roger');
          expect(getDataAtRowProp(2, 'surname')).toEqual('Moore');

          alter('remove_row', 1, 2);

          expect(countRows()).toEqual(1);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toBeNull();
          expect(getDataAtRowProp(1, 'surname')).toBeNull();
          expect(getDataAtRowProp(2, 'name')).toBeNull();
          expect(getDataAtRowProp(2, 'surname')).toBeNull();

          HOT.undo();

          expect(countRows()).toEqual(3);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toEqual('Sean');
          expect(getDataAtRowProp(1, 'surname')).toEqual('Connery');
          expect(getDataAtRowProp(2, 'name')).toEqual('Roger');
          expect(getDataAtRowProp(2, 'surname')).toEqual('Moore');
        });

        it('should undo multiple changes', function () {
          handsontable({
            data: createObjectData().slice(0, 2)
          });
          var HOT = getInstance();

          setDataAtRowProp(0, 'name', 'Pierce');
          setDataAtRowProp(0, 'surname', 'Brosnan');
          setDataAtRowProp(1, 'name', 'Daniel');
          setDataAtRowProp(1, 'surname', 'Craig');

          expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
          expect(getDataAtRowProp(0, 'surname')).toBe('Brosnan');
          expect(getDataAtRowProp(1, 'name')).toBe('Daniel');
          expect(getDataAtRowProp(1, 'surname')).toBe('Craig');

          HOT.undo();
          expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
          expect(getDataAtRowProp(0, 'surname')).toBe('Brosnan');
          expect(getDataAtRowProp(1, 'name')).toBe('Daniel');
          expect(getDataAtRowProp(1, 'surname')).toBe('Connery');

          HOT.undo();
          expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
          expect(getDataAtRowProp(0, 'surname')).toBe('Brosnan');
          expect(getDataAtRowProp(1, 'name')).toBe('Sean');
          expect(getDataAtRowProp(1, 'surname')).toBe('Connery');

          HOT.undo();
          expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
          expect(getDataAtRowProp(0, 'surname')).toBe('Dalton');
          expect(getDataAtRowProp(1, 'name')).toBe('Sean');
          expect(getDataAtRowProp(1, 'surname')).toBe('Connery');

          HOT.undo();
          expect(getDataAtRowProp(0, 'name')).toBe('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toBe('Dalton');
          expect(getDataAtRowProp(1, 'name')).toBe('Sean');
          expect(getDataAtRowProp(1, 'surname')).toBe('Connery');

          HOT.undo();
          expect(getDataAtRowProp(0, 'name')).toBe('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toBe('Dalton');
          expect(getDataAtRowProp(1, 'name')).toBe('Sean');
          expect(getDataAtRowProp(1, 'surname')).toBe('Connery');
        });

        it('should undo multiple changes in cells with validators', function (done) {
          handsontable({
            data: createObjectData().slice(0, 2)
          });
          var HOT = getInstance();

          setDataAtRowProp(0, 'name', 'Pierce');
          setDataAtRowProp(0, 'surname', 'Brosnan');
          setDataAtRowProp(1, 'name', 'Daniel');
          setDataAtRowProp(1, 'surname', 'Craig');

          setTimeout(function () {
            expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
            expect(getDataAtRowProp(0, 'surname')).toBe('Brosnan');
            expect(getDataAtRowProp(1, 'name')).toBe('Daniel');
            expect(getDataAtRowProp(1, 'surname')).toBe('Craig');

            HOT.undo();
          }, 200);

          setTimeout(function () {
            expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
            expect(getDataAtRowProp(0, 'surname')).toBe('Brosnan');
            expect(getDataAtRowProp(1, 'name')).toBe('Daniel');
            expect(getDataAtRowProp(1, 'surname')).toBe('Connery');

            HOT.undo();
          }, 400);

          setTimeout(function () {
            expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
            expect(getDataAtRowProp(0, 'surname')).toBe('Brosnan');
            expect(getDataAtRowProp(1, 'name')).toBe('Sean');
            expect(getDataAtRowProp(1, 'surname')).toBe('Connery');

            HOT.undo();
          }, 600);

          setTimeout(function () {
            expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
            expect(getDataAtRowProp(0, 'surname')).toBe('Dalton');
            expect(getDataAtRowProp(1, 'name')).toBe('Sean');
            expect(getDataAtRowProp(1, 'surname')).toBe('Connery');

            HOT.undo();
          }, 800);

          setTimeout(function () {
            expect(getDataAtRowProp(0, 'name')).toBe('Timothy');
            expect(getDataAtRowProp(0, 'surname')).toBe('Dalton');
            expect(getDataAtRowProp(1, 'name')).toBe('Sean');
            expect(getDataAtRowProp(1, 'surname')).toBe('Connery');

            HOT.undo();
          }, 1000);

          setTimeout(function () {
            expect(getDataAtRowProp(0, 'name')).toBe('Timothy');
            expect(getDataAtRowProp(0, 'surname')).toBe('Dalton');
            expect(getDataAtRowProp(1, 'name')).toBe('Sean');
            expect(getDataAtRowProp(1, 'surname')).toBe('Connery');
            done();
          }, 1200);
        });

        it('should undo multiple row creations', function () {
          var HOT = handsontable({
            data: createObjectData().slice(0, 2)
          });

          expect(countRows()).toEqual(2);

          alter('insert_row');
          alter('insert_row');
          alter('insert_row');
          alter('insert_row');

          expect(countRows()).toEqual(6);

          HOT.undo();
          expect(countRows()).toEqual(5);

          HOT.undo();
          expect(countRows()).toEqual(4);

          HOT.undo();
          expect(countRows()).toEqual(3);

          HOT.undo();
          expect(countRows()).toEqual(2);

          HOT.undo();
          expect(countRows()).toEqual(2);
        });

        it('should undo multiple row removals', function () {
          var HOT = handsontable({
            data: createObjectData()
          });

          expect(countRows()).toEqual(3);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toEqual('Sean');
          expect(getDataAtRowProp(1, 'surname')).toEqual('Connery');
          expect(getDataAtRowProp(2, 'name')).toEqual('Roger');
          expect(getDataAtRowProp(2, 'surname')).toEqual('Moore');

          alter('remove_row');
          alter('remove_row');

          expect(countRows()).toEqual(1);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');

          HOT.undo();
          expect(countRows()).toEqual(2);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toEqual('Sean');
          expect(getDataAtRowProp(1, 'surname')).toEqual('Connery');

          HOT.undo();
          expect(countRows()).toEqual(3);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toEqual('Sean');
          expect(getDataAtRowProp(1, 'surname')).toEqual('Connery');
          expect(getDataAtRowProp(2, 'name')).toEqual('Roger');
          expect(getDataAtRowProp(2, 'surname')).toEqual('Moore');

          HOT.undo();
          expect(countRows()).toEqual(3);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toEqual('Sean');
          expect(getDataAtRowProp(1, 'surname')).toEqual('Connery');
          expect(getDataAtRowProp(2, 'name')).toEqual('Roger');
          expect(getDataAtRowProp(2, 'surname')).toEqual('Moore');
        });
      });

      describe('redo', function () {
        it('should redo single change', function () {
          handsontable({
            data: createObjectData()
          });
          var HOT = getInstance();

          setDataAtRowProp(0, 0, 'Pearce');
          expect(getDataAtRowProp(0, 0)).toBe('Pearce');

          HOT.undo();
          expect(getDataAtCell(0, 0)).toBe('Timothy');

          HOT.redo();
          expect(getDataAtRowProp(0, 0)).toBe('Pearce');
        });

        it('should redo single change in cell with validator', function (done) {
          handsontable({
            data: createObjectData()
          });
          var HOT = getInstance();

          setDataAtRowProp(0, 0, 'Pearce');

          setTimeout(function () {
            expect(getDataAtRowProp(0, 0)).toBe('Pearce');

            HOT.undo();
          }, 200);

          setTimeout(function () {
            expect(getDataAtCell(0, 0)).toBe('Timothy');

            HOT.redo();
          }, 400);

          setTimeout(function () {
            expect(getDataAtRowProp(0, 0)).toBe('Pearce');
            done();
          }, 600);
        });

        it('should redo creation of a single row', function () {
          var HOT = handsontable({
            data: createObjectData().slice(0, 2)
          });

          expect(countRows()).toEqual(2);

          alter('insert_row');

          expect(countRows()).toEqual(3);

          HOT.undo();

          expect(countRows()).toEqual(2);

          HOT.redo();

          expect(countRows()).toEqual(3);
        });

        it('should redo creation of multiple rows', function () {
          var HOT = handsontable({
            data: createObjectData().slice(0, 2)
          });

          expect(countRows()).toEqual(2);

          alter('insert_row', 0, 5);

          expect(countRows()).toEqual(7);

          HOT.undo();

          expect(countRows()).toEqual(2);

          HOT.redo();

          expect(countRows()).toEqual(7);
        });

        it('should redo removal of single row', function () {
          var HOT = handsontable({
            data: createObjectData().slice(0, 2)
          });

          expect(countRows()).toEqual(2);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toEqual('Sean');
          expect(getDataAtRowProp(1, 'surname')).toEqual('Connery');

          alter('remove_row');

          expect(countRows()).toEqual(1);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toBeNull();
          expect(getDataAtRowProp(1, 'surname')).toBeNull();

          HOT.undo();

          expect(countRows()).toEqual(2);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toEqual('Sean');
          expect(getDataAtRowProp(1, 'surname')).toEqual('Connery');

          HOT.redo();

          expect(countRows()).toEqual(1);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toBeNull();
          expect(getDataAtRowProp(1, 'surname')).toBeNull();
        });

        it('should redo removal of multiple rows', function () {
          var HOT = handsontable({
            data: createObjectData()
          });

          expect(countRows()).toEqual(3);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toEqual('Sean');
          expect(getDataAtRowProp(1, 'surname')).toEqual('Connery');
          expect(getDataAtRowProp(2, 'name')).toEqual('Roger');
          expect(getDataAtRowProp(2, 'surname')).toEqual('Moore');

          alter('remove_row', 1, 2);

          expect(countRows()).toEqual(1);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toBeNull();
          expect(getDataAtRowProp(1, 'surname')).toBeNull();
          expect(getDataAtRowProp(2, 'name')).toBeNull();
          expect(getDataAtRowProp(2, 'surname')).toBeNull();

          HOT.undo();

          expect(countRows()).toEqual(3);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toEqual('Sean');
          expect(getDataAtRowProp(1, 'surname')).toEqual('Connery');
          expect(getDataAtRowProp(2, 'name')).toEqual('Roger');
          expect(getDataAtRowProp(2, 'surname')).toEqual('Moore');

          HOT.redo();

          expect(countRows()).toEqual(1);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toBeNull();
          expect(getDataAtRowProp(1, 'surname')).toBeNull();
          expect(getDataAtRowProp(2, 'name')).toBeNull();
          expect(getDataAtRowProp(2, 'surname')).toBeNull();
        });

        it('should redo multiple changes', function () {
          handsontable({
            data: createObjectData().slice(0, 2)
          });
          var HOT = getInstance();

          setDataAtRowProp(0, 'name', 'Pierce');
          setDataAtRowProp(0, 'surname', 'Brosnan');
          setDataAtRowProp(1, 'name', 'Daniel');
          setDataAtRowProp(1, 'surname', 'Craig');

          expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
          expect(getDataAtRowProp(0, 'surname')).toBe('Brosnan');
          expect(getDataAtRowProp(1, 'name')).toBe('Daniel');
          expect(getDataAtRowProp(1, 'surname')).toBe('Craig');

          HOT.undo();
          HOT.undo();
          HOT.undo();
          HOT.undo();

          expect(getDataAtRowProp(0, 'name')).toBe('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toBe('Dalton');
          expect(getDataAtRowProp(1, 'name')).toBe('Sean');
          expect(getDataAtRowProp(1, 'surname')).toBe('Connery');

          HOT.redo();
          expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
          expect(getDataAtRowProp(0, 'surname')).toBe('Dalton');
          expect(getDataAtRowProp(1, 'name')).toBe('Sean');
          expect(getDataAtRowProp(1, 'surname')).toBe('Connery');

          HOT.redo();
          expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
          expect(getDataAtRowProp(0, 'surname')).toBe('Brosnan');
          expect(getDataAtRowProp(1, 'name')).toBe('Sean');
          expect(getDataAtRowProp(1, 'surname')).toBe('Connery');

          HOT.redo();
          expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
          expect(getDataAtRowProp(0, 'surname')).toBe('Brosnan');
          expect(getDataAtRowProp(1, 'name')).toBe('Daniel');
          expect(getDataAtRowProp(1, 'surname')).toBe('Connery');

          HOT.redo();
          expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
          expect(getDataAtRowProp(0, 'surname')).toBe('Brosnan');
          expect(getDataAtRowProp(1, 'name')).toBe('Daniel');
          expect(getDataAtRowProp(1, 'surname')).toBe('Craig');

          HOT.redo();
          expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
          expect(getDataAtRowProp(0, 'surname')).toBe('Brosnan');
          expect(getDataAtRowProp(1, 'name')).toBe('Daniel');
          expect(getDataAtRowProp(1, 'surname')).toBe('Craig');
        });

        it('should redo multiple changes in cells with validators', function (done) {
          handsontable({
            data: createObjectData().slice(0, 2)
          });
          var HOT = getInstance();

          setDataAtRowProp(0, 'name', 'Pierce');
          setDataAtRowProp(0, 'surname', 'Brosnan');
          setDataAtRowProp(1, 'name', 'Daniel');
          setDataAtRowProp(1, 'surname', 'Craig');

          setTimeout(function () {
            expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
            expect(getDataAtRowProp(0, 'surname')).toBe('Brosnan');
            expect(getDataAtRowProp(1, 'name')).toBe('Daniel');
            expect(getDataAtRowProp(1, 'surname')).toBe('Craig');

            HOT.undo();
          }, 200);

          setTimeout(function () {
            HOT.undo();
          }, 400);

          setTimeout(function () {
            HOT.undo();
          }, 600);

          setTimeout(function () {
            HOT.undo();
          }, 800);

          setTimeout(function () {
            expect(getDataAtRowProp(0, 'name')).toBe('Timothy');
            expect(getDataAtRowProp(0, 'surname')).toBe('Dalton');
            expect(getDataAtRowProp(1, 'name')).toBe('Sean');
            expect(getDataAtRowProp(1, 'surname')).toBe('Connery');

            HOT.redo();
          }, 1000);

          setTimeout(function () {
            expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
            expect(getDataAtRowProp(0, 'surname')).toBe('Dalton');
            expect(getDataAtRowProp(1, 'name')).toBe('Sean');
            expect(getDataAtRowProp(1, 'surname')).toBe('Connery');

            HOT.redo();
          }, 1200);

          setTimeout(function () {
            expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
            expect(getDataAtRowProp(0, 'surname')).toBe('Brosnan');
            expect(getDataAtRowProp(1, 'name')).toBe('Sean');
            expect(getDataAtRowProp(1, 'surname')).toBe('Connery');

            HOT.redo();
          }, 1400);

          setTimeout(function () {
            expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
            expect(getDataAtRowProp(0, 'surname')).toBe('Brosnan');
            expect(getDataAtRowProp(1, 'name')).toBe('Daniel');
            expect(getDataAtRowProp(1, 'surname')).toBe('Connery');

            HOT.redo();
          }, 1600);

          setTimeout(function () {
            expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
            expect(getDataAtRowProp(0, 'surname')).toBe('Brosnan');
            expect(getDataAtRowProp(1, 'name')).toBe('Daniel');
            expect(getDataAtRowProp(1, 'surname')).toBe('Craig');

            HOT.redo();
          }, 1800);

          setTimeout(function () {
            expect(getDataAtRowProp(0, 'name')).toBe('Pierce');
            expect(getDataAtRowProp(0, 'surname')).toBe('Brosnan');
            expect(getDataAtRowProp(1, 'name')).toBe('Daniel');
            expect(getDataAtRowProp(1, 'surname')).toBe('Craig');
            done();
          }, 2000);
        });

        it('should redo multiple row creations', function () {
          var HOT = handsontable({
            data: createObjectData().slice(0, 2)
          });

          expect(countRows()).toEqual(2);

          alter('insert_row');
          alter('insert_row');
          alter('insert_row');
          alter('insert_row');

          expect(countRows()).toEqual(6);

          HOT.undo();
          HOT.undo();
          HOT.undo();
          HOT.undo();

          expect(countRows()).toEqual(2);

          HOT.redo();
          expect(countRows()).toEqual(3);

          HOT.redo();
          expect(countRows()).toEqual(4);

          HOT.redo();
          expect(countRows()).toEqual(5);

          HOT.redo();
          expect(countRows()).toEqual(6);

          HOT.redo();
          expect(countRows()).toEqual(6);
        });

        it('should undo multiple row removals', function () {
          var HOT = handsontable({
            data: createObjectData()
          });

          expect(countRows()).toEqual(3);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toEqual('Sean');
          expect(getDataAtRowProp(1, 'surname')).toEqual('Connery');
          expect(getDataAtRowProp(2, 'name')).toEqual('Roger');
          expect(getDataAtRowProp(2, 'surname')).toEqual('Moore');

          alter('remove_row');
          alter('remove_row');

          expect(countRows()).toEqual(1);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');

          HOT.undo();
          HOT.undo();
          HOT.undo();

          expect(countRows()).toEqual(3);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toEqual('Sean');
          expect(getDataAtRowProp(1, 'surname')).toEqual('Connery');
          expect(getDataAtRowProp(2, 'name')).toEqual('Roger');
          expect(getDataAtRowProp(2, 'surname')).toEqual('Moore');

          HOT.redo();
          expect(countRows()).toEqual(2);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
          expect(getDataAtRowProp(1, 'name')).toEqual('Sean');
          expect(getDataAtRowProp(1, 'surname')).toEqual('Connery');

          HOT.redo();
          expect(countRows()).toEqual(1);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');

          HOT.redo();
          expect(countRows()).toEqual(1);
          expect(getDataAtRowProp(0, 'name')).toEqual('Timothy');
          expect(getDataAtRowProp(0, 'surname')).toEqual('Dalton');
        });
      });
    });
  });

  describe('plugin features', function () {
    describe('cell alignment', function () {
      it('should undo a sequence of aligning cells', function () {
        var hot = handsontable({
          data: Handsontable.helper.createSpreadsheetData(9, 9),
          contextMenu: true,
          colWidths: [50, 50, 50, 50, 50, 50, 50, 50, 50],
          rowHeights: [50, 50, 50, 50, 50, 50, 50, 50, 50]
        });

        // top 3 rows center
        selectCell(0, 0, 2, 8);
        hot.getPlugin('contextMenu').executeCommand('alignment:center');

        // middle 3 rows unchanged - left

        // bottom 3 rows right
        selectCell(6, 0, 8, 8);
        hot.getPlugin('contextMenu').executeCommand('alignment:right');

        // left 3 columns - middle
        selectCell(0, 0, 8, 2);
        hot.getPlugin('contextMenu').executeCommand('alignment:middle');

        // middle 3 columns unchanged - top

        // right 3 columns - bottom
        selectCell(0, 6, 8, 8);
        hot.getPlugin('contextMenu').executeCommand('alignment:bottom');

        var cellMeta = hot.getCellMeta(0, 0);
        expect(cellMeta.className.indexOf('htCenter')).toBeGreaterThan(-1);
        expect(cellMeta.className.indexOf('htMiddle')).toBeGreaterThan(-1);

        cellMeta = hot.getCellMeta(0, 7);
        expect(cellMeta.className.indexOf('htCenter')).toBeGreaterThan(-1);
        expect(cellMeta.className.indexOf('htBottom')).toBeGreaterThan(-1);

        cellMeta = hot.getCellMeta(5, 1);
        expect(cellMeta.className.indexOf('htMiddle')).toBeGreaterThan(-1);

        cellMeta = hot.getCellMeta(5, 7);
        expect(cellMeta.className.indexOf('htBottom')).toBeGreaterThan(-1);

        cellMeta = hot.getCellMeta(7, 1);
        expect(cellMeta.className.indexOf('htRight')).toBeGreaterThan(-1);
        expect(cellMeta.className.indexOf('htMiddle')).toBeGreaterThan(-1);

        cellMeta = hot.getCellMeta(7, 5);
        expect(cellMeta.className.indexOf('htRight')).toBeGreaterThan(-1);

        cellMeta = hot.getCellMeta(7, 7);
        expect(cellMeta.className.indexOf('htRight')).toBeGreaterThan(-1);
        expect(cellMeta.className.indexOf('htBottom')).toBeGreaterThan(-1);

        hot.undo();
        cellMeta = hot.getCellMeta(0, 7);
        expect(cellMeta.className.indexOf('htCenter')).toBeGreaterThan(-1);
        expect(cellMeta.className.indexOf('htBottom')).toEqual(-1);

        cellMeta = hot.getCellMeta(5, 7);
        expect(cellMeta.className.indexOf('htBottom')).toEqual(-1);

        cellMeta = hot.getCellMeta(7, 7);
        expect(cellMeta.className.indexOf('htRight')).toBeGreaterThan(-1);
        expect(cellMeta.className.indexOf('htBottom')).toEqual(-1);

        hot.undo();

        cellMeta = hot.getCellMeta(0, 0);
        expect(cellMeta.className.indexOf('htCenter')).toBeGreaterThan(-1);
        expect(cellMeta.className.indexOf('htMiddle')).toEqual(-1);

        cellMeta = hot.getCellMeta(5, 1);
        expect(cellMeta.className.indexOf('htMiddle')).toEqual(-1);

        cellMeta = hot.getCellMeta(7, 1);
        expect(cellMeta.className.indexOf('htRight')).toBeGreaterThan(-1);
        expect(cellMeta.className.indexOf('htMiddle')).toEqual(-1);

        hot.undo();

        cellMeta = hot.getCellMeta(7, 1);
        expect(cellMeta.className.indexOf('htRight')).toEqual(-1);
        expect(cellMeta.className.indexOf('htMiddle')).toEqual(-1);

        cellMeta = hot.getCellMeta(7, 5);
        expect(cellMeta.className.indexOf('htRight')).toEqual(-1);

        cellMeta = hot.getCellMeta(7, 7);
        expect(cellMeta.className.indexOf('htRight')).toEqual(-1);
        expect(cellMeta.className.indexOf('htBottom')).toEqual(-1);

        hot.undo();

        // check if all cells are either non-adjusted or adjusted to the left (as default)
        var finish;
        for (var i = 0; i < 9; i++) {
          for (var j = 0; j < 9; j++) {
            cellMeta = hot.getCellMeta(i, j);
            finish = cellMeta.className === void 0 || cellMeta.className.trim() === '' || cellMeta.className.trim() === 'htLeft';
            expect(finish).toBe(true);
          }
        }
      });

      it('should redo a sequence of aligning cells', function () {
        var hot = handsontable({
          data: Handsontable.helper.createSpreadsheetData(9, 9),
          contextMenu: true,
          colWidths: [50, 50, 50, 50, 50, 50, 50, 50, 50],
          rowHeights: [50, 50, 50, 50, 50, 50, 50, 50, 50]
        });

        // top 3 rows center
        selectCell(0, 0, 2, 8);
        hot.getPlugin('contextMenu').executeCommand('alignment:center');

        // middle 3 rows unchanged - left

        // bottom 3 rows right
        selectCell(6, 0, 8, 8);
        hot.getPlugin('contextMenu').executeCommand('alignment:right');

        // left 3 columns - middle
        selectCell(0, 0, 8, 2);
        hot.getPlugin('contextMenu').executeCommand('alignment:middle');

        // middle 3 columns unchanged - top

        // right 3 columns - bottom
        selectCell(0, 6, 8, 8);
        hot.getPlugin('contextMenu').executeCommand('alignment:bottom');

        var cellMeta = hot.getCellMeta(0, 0);
        expect(cellMeta.className.indexOf('htCenter')).toBeGreaterThan(-1);
        expect(cellMeta.className.indexOf('htMiddle')).toBeGreaterThan(-1);

        cellMeta = hot.getCellMeta(0, 7);
        expect(cellMeta.className.indexOf('htCenter')).toBeGreaterThan(-1);
        expect(cellMeta.className.indexOf('htBottom')).toBeGreaterThan(-1);

        cellMeta = hot.getCellMeta(5, 1);
        expect(cellMeta.className.indexOf('htMiddle')).toBeGreaterThan(-1);

        cellMeta = hot.getCellMeta(5, 7);
        expect(cellMeta.className.indexOf('htBottom')).toBeGreaterThan(-1);

        cellMeta = hot.getCellMeta(7, 1);
        expect(cellMeta.className.indexOf('htRight')).toBeGreaterThan(-1);
        expect(cellMeta.className.indexOf('htMiddle')).toBeGreaterThan(-1);

        cellMeta = hot.getCellMeta(7, 5);
        expect(cellMeta.className.indexOf('htRight')).toBeGreaterThan(-1);

        cellMeta = hot.getCellMeta(7, 7);
        expect(cellMeta.className.indexOf('htRight')).toBeGreaterThan(-1);
        expect(cellMeta.className.indexOf('htBottom')).toBeGreaterThan(-1);

        hot.undo();
        hot.undo();
        hot.undo();
        hot.undo();

        // check if all cells are either non-adjusted or adjusted to the left (as default)
        var finish;
        for (var i = 0; i < 9; i++) {
          for (var j = 0; j < 9; j++) {
            cellMeta = hot.getCellMeta(i, j);
            finish = cellMeta.className === void 0 || cellMeta.className.trim() === '' || cellMeta.className.trim() === 'htLeft';
            expect(finish).toBe(true);
          }
        }

        hot.redo();
        cellMeta = hot.getCellMeta(0, 0);
        expect(cellMeta.className.indexOf('htCenter')).toBeGreaterThan(-1);
        cellMeta = hot.getCellMeta(1, 5);
        expect(cellMeta.className.indexOf('htCenter')).toBeGreaterThan(-1);
        cellMeta = hot.getCellMeta(2, 8);
        expect(cellMeta.className.indexOf('htCenter')).toBeGreaterThan(-1);

        hot.redo();
        cellMeta = hot.getCellMeta(6, 0);
        expect(cellMeta.className.indexOf('htRight')).toBeGreaterThan(-1);
        cellMeta = hot.getCellMeta(7, 5);
        expect(cellMeta.className.indexOf('htRight')).toBeGreaterThan(-1);
        cellMeta = hot.getCellMeta(8, 8);
        expect(cellMeta.className.indexOf('htRight')).toBeGreaterThan(-1);

        hot.redo();
        cellMeta = hot.getCellMeta(0, 0);
        expect(cellMeta.className.indexOf('htMiddle')).toBeGreaterThan(-1);
        expect(cellMeta.className.indexOf('htCenter')).toBeGreaterThan(-1);
        cellMeta = hot.getCellMeta(5, 1);
        expect(cellMeta.className.indexOf('htMiddle')).toBeGreaterThan(-1);
        cellMeta = hot.getCellMeta(8, 2);
        expect(cellMeta.className.indexOf('htMiddle')).toBeGreaterThan(-1);
        expect(cellMeta.className.indexOf('htRight')).toBeGreaterThan(-1);

        hot.redo();
        cellMeta = hot.getCellMeta(0, 6);
        expect(cellMeta.className.indexOf('htBottom')).toBeGreaterThan(-1);
        expect(cellMeta.className.indexOf('htCenter')).toBeGreaterThan(-1);
        cellMeta = hot.getCellMeta(5, 7);
        expect(cellMeta.className.indexOf('htBottom')).toBeGreaterThan(-1);
        cellMeta = hot.getCellMeta(8, 8);
        expect(cellMeta.className.indexOf('htBottom')).toBeGreaterThan(-1);
        expect(cellMeta.className.indexOf('htRight')).toBeGreaterThan(-1);
      });
    });

    it('should exposed new methods when plugin is enabled', function () {
      var hot = handsontable({
        undo: false
      });

      expect(hot.undo).toBeUndefined();
      expect(hot.redo).toBeUndefined();
      expect(hot.isUndoAvailable).toBeUndefined();
      expect(hot.isRedoAvailable).toBeUndefined();
      expect(hot.clearUndo).toBeUndefined();

      updateSettings({
        undo: true
      });

      expect(_typeof(hot.undo)).toEqual('function');
      expect(_typeof(hot.redo)).toEqual('function');
      expect(_typeof(hot.isUndoAvailable)).toEqual('function');
      expect(_typeof(hot.isRedoAvailable)).toEqual('function');
      expect(_typeof(hot.clearUndo)).toEqual('function');
    });

    it('should remove exposed methods when plugin is disbaled', function () {
      var hot = handsontable({
        undo: true
      });

      expect(_typeof(hot.undo)).toEqual('function');
      expect(_typeof(hot.redo)).toEqual('function');
      expect(_typeof(hot.isUndoAvailable)).toEqual('function');
      expect(_typeof(hot.isRedoAvailable)).toEqual('function');
      expect(_typeof(hot.clearUndo)).toEqual('function');

      updateSettings({
        undo: false
      });

      expect(hot.undo).toBeUndefined();
      expect(hot.redo).toBeUndefined();
      expect(hot.isUndoAvailable).toBeUndefined();
      expect(hot.isRedoAvailable).toBeUndefined();
      expect(hot.clearUndo).toBeUndefined();
    });

    describe('Keyboard shortcuts', function () {
      it('should undo single change after hitting CTRL+Z', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(2, 2)
        });
        var HOT = getInstance();

        selectCell(0, 0);
        setDataAtCell(0, 0, 'new value');

        this.$container.simulate('keydown', { ctrlKey: true, keyCode: 'Z'.charCodeAt(0) });
        expect(getDataAtCell(0, 0)).toBe('A1');
      });

      it('should redo single change after hitting CTRL+Y', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(2, 2)
        });
        var HOT = getInstance();

        selectCell(0, 0);
        setDataAtCell(0, 0, 'new value');

        expect(getDataAtCell(0, 0)).toBe('new value');

        HOT.undo();
        expect(getDataAtCell(0, 0)).toBe('A1');

        this.$container.simulate('keydown', { ctrlKey: true, keyCode: 'Y'.charCodeAt(0) });

        expect(getDataAtCell(0, 0)).toBe('new value');
      });

      it('should redo single change after hitting CTRL+SHIFT+Z', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(2, 2)
        });
        var HOT = getInstance();

        selectCell(0, 0);
        setDataAtCell(0, 0, 'new value');

        expect(getDataAtCell(0, 0)).toBe('new value');

        HOT.undo();
        expect(getDataAtCell(0, 0)).toBe('A1');

        this.$container.simulate('keydown', { ctrlKey: true, shiftKey: true, keyCode: 'Z'.charCodeAt(0) });

        expect(getDataAtCell(0, 0)).toBe('new value');
      });
    });
  });

  describe('Hooks', function () {
    it('should fire a `beforeUndo` hook after the undo process begins', function (done) {
      var beforeUndoSpy = jasmine.createSpy('beforeUndo');
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(2, 2)
      });
      var hookData = null;

      hot.addHook('beforeUndo', beforeUndoSpy);
      hot.addHook('beforeUndo', function (data) {
        hookData = data;
      });

      alter('remove_row', 1);

      setTimeout(function () {
        hot.undo();
      }, 10);

      setTimeout(function () {
        expect(beforeUndoSpy.calls.count()).toEqual(1);
        expect(hookData).not.toBe(null);
        expect(hookData.actionType).toEqual('remove_row');
        expect(hookData.data).toEqual([['A2', 'B2']]);
        done();
      }, 100);
    });

    it('should fire a `beforeRedo` hook before the redo process begins', function (done) {
      var beforeRedoSpy = jasmine.createSpy('beforeRedo');
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(2, 2)
      });
      var hookData = null;

      hot.addHook('beforeRedo', beforeRedoSpy);
      hot.addHook('beforeRedo', function (data) {
        hookData = data;
      });

      alter('remove_row', 1);

      setTimeout(function () {
        hot.undo();
        hot.redo();
      }, 10);

      setTimeout(function () {
        expect(beforeRedoSpy.calls.count()).toEqual(1);
        expect(hookData).not.toBe(null);
        expect(hookData.actionType).toEqual('remove_row');
        expect(hookData.data).toEqual([['A2', 'B2']]);
        done();
      }, 100);
    });

    it('should fire a `afterRedo` hook after the redo process begins', function (done) {
      var afterRedoSpy = jasmine.createSpy('afterRedo');
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(2, 2)
      });
      var hookData = null;

      hot.addHook('beforeRedo', afterRedoSpy);
      hot.addHook('beforeRedo', function (data) {
        hookData = data;
      });

      alter('remove_row', 1);

      setTimeout(function () {
        hot.undo();
        hot.redo();
      }, 10);

      setTimeout(function () {
        expect(afterRedoSpy.calls.count()).toEqual(1);
        expect(hookData).not.toBe(null);
        expect(hookData.actionType).toEqual('remove_row');
        expect(hookData.data).toEqual([['A2', 'B2']]);
        done();
      }, 100);
    });
  });
});

/***/ }),
/* 149 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('ColHeader', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should not show col headers by default', function () {
    var that = this;
    handsontable();

    expect(that.$container.find('thead th').length).toEqual(0);
  });

  it('should show col headers if true', function () {
    var that = this;
    handsontable({
      colHeaders: true
    });

    expect(that.$container.find('thead th').length).toBeGreaterThan(0);
  });

  it('should show default columns headers labelled A-(Z * n)', function () {
    var that = this;
    var startCols = 5;

    handsontable({
      startCols: startCols,
      colHeaders: true
    });

    var ths = getHtCore().find('thead th');
    expect(ths.length).toEqual(startCols);
    expect($.trim(ths.eq(0).text())).toEqual('A');
    expect($.trim(ths.eq(1).text())).toEqual('B');
    expect($.trim(ths.eq(2).text())).toEqual('C');
    expect($.trim(ths.eq(3).text())).toEqual('D');
    expect($.trim(ths.eq(4).text())).toEqual('E');
  });

  it('should show default columns headers labelled A-(Z * n) when columns as an array is present', function () {
    var that = this;
    var startCols = 5;

    handsontable({
      startCols: startCols,
      colHeaders: true,
      columns: [{}, {}, {}, {}, {}]
    });

    var ths = getHtCore().find('thead th');
    expect(ths.length).toEqual(startCols);
    expect($.trim(ths.eq(0).text())).toEqual('A');
    expect($.trim(ths.eq(1).text())).toEqual('B');
    expect($.trim(ths.eq(2).text())).toEqual('C');
    expect($.trim(ths.eq(3).text())).toEqual('D');
    expect($.trim(ths.eq(4).text())).toEqual('E');
  });

  it('should show default columns headers labelled A-(Z * n) when columns as a function is present', function () {
    var that = this;
    var startCols = 5;

    handsontable({
      startCols: startCols,
      colHeaders: true,
      columns: function columns(column) {
        return {};
      }
    });

    var ths = getHtCore().find('thead th');
    expect(ths.length).toEqual(startCols);
    expect($.trim(ths.eq(0).text())).toEqual('A');
    expect($.trim(ths.eq(1).text())).toEqual('B');
    expect($.trim(ths.eq(2).text())).toEqual('C');
    expect($.trim(ths.eq(3).text())).toEqual('D');
    expect($.trim(ths.eq(4).text())).toEqual('E');
  });

  it('should show col headers with custom label', function () {
    var that = this;
    var startCols = 5;
    handsontable({
      startCols: startCols,
      colHeaders: ['First', 'Second', 'Third']
    });

    var ths = getHtCore().find('thead th');
    expect(ths.length).toEqual(startCols);
    expect($.trim(ths.eq(0).text())).toEqual('First');
    expect($.trim(ths.eq(1).text())).toEqual('Second');
    expect($.trim(ths.eq(2).text())).toEqual('Third');
    expect($.trim(ths.eq(3).text())).toEqual('D');
    expect($.trim(ths.eq(4).text())).toEqual('E');
  });

  it('should not show col headers if false', function () {
    var that = this;
    handsontable({
      colHeaders: false
    });

    expect(that.$container.find('th.htColHeader').length).toEqual(0);
  });

  it('should hide columns headers after updateSettings', function () {
    var hot = handsontable({
      startCols: 5,
      colHeaders: true
    });

    expect(getHtCore().find('thead th').length).toEqual(5);
    expect(getTopClone().find('thead th').length).toEqual(5);

    hot.updateSettings({
      colHeaders: false
    });

    expect(getHtCore().find('thead th').length).toEqual(0);
    expect(getTopClone().width()).toEqual(0);
  });

  it('should show/hide columns headers after updateSettings', function () {
    var hot = handsontable({
      startCols: 5,
      colHeaders: true
    });

    expect(getHtCore().find('thead th').length).toEqual(5);
    expect(getTopClone().find('thead th').length).toEqual(5);

    hot.updateSettings({
      colHeaders: false
    });

    expect(getHtCore().find('thead th').length).toEqual(0);
    expect(getTopClone().width()).toEqual(0);

    hot.updateSettings({
      colHeaders: true
    });

    expect(getHtCore().find('thead th').length).toEqual(5);
    expect(getTopClone().width()).toBeGreaterThan(0);

    hot.updateSettings({
      colHeaders: false
    });

    expect(getHtCore().find('thead th').length).toEqual(0);
    expect(getTopClone().width()).toEqual(0);
  });

  it('should show columns headers after updateSettings', function () {
    var hot = handsontable({
      startCols: 5,
      colHeaders: false
    });

    expect(getHtCore().find('thead th').length).toEqual(0);
    expect(getTopClone().find('thead th').length).toEqual(0);

    hot.updateSettings({
      colHeaders: true
    });

    expect(getHtCore().find('thead th').length).toEqual(5);
    expect(getTopClone().find('thead th').length).toEqual(5);
  });

  it('should show new columns headers after updateSettings', function () {
    var hot = handsontable({
      startCols: 3,
      colHeaders: ['A', 'B', 'C']
    });

    var htCore = getHtCore();
    expect(htCore.find('thead th:eq(0)').text()).toEqual('A');
    expect(htCore.find('thead th:eq(1)').text()).toEqual('B');
    expect(htCore.find('thead th:eq(2)').text()).toEqual('C');

    hot.updateSettings({
      colHeaders: ['X', 'Y', 'Z']
    });

    expect(htCore.find('thead th:eq(0)').text()).toEqual('X');
    expect(htCore.find('thead th:eq(1)').text()).toEqual('Y');
    expect(htCore.find('thead th:eq(2)').text()).toEqual('Z');
  });

  it('should be possible to define colHeaders with a function', function () {
    var hot = handsontable({
      startCols: 2,
      colHeaders: function colHeaders(col) {
        switch (col) {
          case 0:
            return 'One';
          case 1:
            return 'Two';
          default:
            break;
        }
      }
    });

    var htCore = getHtCore();

    expect(htCore.find('thead th:eq(0)').text()).toEqual('One');
    expect(htCore.find('thead th:eq(1)').text()).toEqual('Two');
  });

  it('should be possible to set HTML in colHeaders', function () {
    var hot = handsontable({
      startCols: 2,
      colHeaders: ['One <input type="checkbox">', 'Two <input type="checkbox">']
    });

    var htCore = getHtCore();

    expect(htCore.find('thead th:eq(0) input[type=checkbox]').length).toEqual(1);
    expect(htCore.find('thead th:eq(1) input[type=checkbox]').length).toEqual(1);
  });

  it('should be possible to set colHeaders when columns array is present', function () {
    var hot = handsontable({
      startCols: 2,
      colHeaders: ['One', 'Two'],
      columns: [{ type: 'text' }, { type: 'text' }]
    });

    var htCore = getHtCore();

    expect(htCore.find('thead th:eq(0)').text()).toEqual('One');
    expect(htCore.find('thead th:eq(1)').text()).toEqual('Two');
  });

  it('should be possible to set colHeaders when columns function is present', function () {
    var hot = handsontable({
      startCols: 2,
      colHeaders: ['One', 'Two'],
      columns: function columns(column) {
        var colMeta = { type: 'text' };

        if ([0, 1].indexOf(column) < 0) {
          colMeta = null;
        }

        return colMeta;
      }
    });

    var htCore = getHtCore();

    expect(htCore.find('thead th:eq(0)').text()).toEqual('One');
    expect(htCore.find('thead th:eq(1)').text()).toEqual('Two');
  });

  it('should be possible to set colHeaders using columns title property', function () {
    var hot = handsontable({
      startCols: 2,
      colHeaders: ['One', 'Two'],
      columns: [{ type: 'text', title: 'Special title' }, { type: 'text' }]
    });

    var htCore = getHtCore();

    expect(htCore.find('thead th:eq(0)').text()).toEqual('Special title');
    expect(htCore.find('thead th:eq(1)').text()).toEqual('Two');
  });

  it('should be possible to set colHeaders using columns title property when columns is a function', function () {
    var hot = handsontable({
      startCols: 2,
      colHeaders: ['One', 'Two'],
      columns: function columns(column) {
        var colMeta = { type: 'text' };

        if (column === 0) {
          colMeta.title = 'Special title';
        }
        if ([0, 1].indexOf(column) < 0) {
          colMeta = null;
        }

        return colMeta;
      }
    });

    var htCore = getHtCore();

    expect(htCore.find('thead th:eq(0)').text()).toEqual('Special title');
    expect(htCore.find('thead th:eq(1)').text()).toEqual('Two');
  });

  it('should resize all the column headers in the overlays, according to the other overlays\' height', function () {
    var hot = handsontable({
      startCols: 5,
      colHeaders: ['a', 'a', 'a', 'a<BR>a', 'a'],
      fixedColumnsLeft: 2
    });

    var topHeaderExample = $('.ht_clone_top').find('thead tr:first-child th:nth-child(1)'),
        masterHeaderExample = $('.ht_master').find('thead tr:first-child th:nth-child(3)');

    expect(topHeaderExample.height()).toEqual(masterHeaderExample.height());
  });

  it('should allow defining custom column header height using the columnHeaderHeight config option', function () {
    var hot = handsontable({
      startCols: 3,
      colHeaders: true,
      columnHeaderHeight: 40
    });

    hot.render();

    expect(this.$container.find('th').eq(0).height()).toEqual(40);
  });

  it('should allow defining custom column header heights using the columnHeaderHeight config option, when multiple column header levels are defined', function () {
    var hot = handsontable({
      startCols: 3,
      colHeaders: true,
      columnHeaderHeight: [45, 65],
      afterGetColumnHeaderRenderers: function afterGetColumnHeaderRenderers(array) {
        array.push(function (index, TH) {
          TH.innerHTML = '';

          var div = document.createElement('div');
          var span = document.createElement('span');

          div.className = 'relative';
          span.className = 'colHeader';

          span.innerText = index;

          div.appendChild(span);
          TH.appendChild(div);
        });

        return array;
      }
    });
    hot.render();

    expect(this.$container.find('.handsontable.ht_clone_top tr:nth-child(1) th:nth-child(1)').height()).toEqual(45);
    expect(this.$container.find('.handsontable.ht_clone_top tr:nth-child(2) th:nth-child(1)').height()).toEqual(65);
  });
});

/***/ }),
/* 150 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_alter', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  var arrayOfNestedObjects = function arrayOfNestedObjects() {
    return [{ id: 1,
      name: {
        first: 'Ted',
        last: 'Right'
      },
      address: 'Street Name',
      zip: '80410',
      city: 'City Name' }, { id: 2,
      name: {
        first: 'Frank',
        last: 'Honest'
      },
      address: 'Street Name',
      zip: '80410',
      city: 'City Name' }, { id: 3,
      name: {
        first: 'Joan',
        last: 'Well'
      },
      address: 'Street Name',
      zip: '80410',
      city: 'City Name' }];
  };

  var arrayOfArrays = function arrayOfArrays() {
    return [['', 'Kia', 'Nissan', 'Toyota', 'Honda'], ['2008', 10, 11, 12, 13], ['2009', 20, 11, 14, 13], ['2010', 30, 15, 12, 13]];
  };

  describe('remove row', function () {
    it('should remove row', function () {
      handsontable({
        minRows: 5,
        data: arrayOfNestedObjects(),
        columns: [{ data: 'id' }, { data: 'name.first' }]
      });
      alter('remove_row', 1);

      expect(getDataAtCell(1, 1)).toEqual('Joan'); // Joan should be moved up
      expect(getData().length).toEqual(5); // new row should be added by keepEmptyRows
    });

    it('should fire beforeRemoveRow event before removing row', function () {
      var onBeforeRemoveRow = jasmine.createSpy('onBeforeRemoveRow');

      var hot = handsontable({
        data: arrayOfNestedObjects(),
        columns: [{ data: 'id' }, { data: 'name.first' }],
        beforeRemoveRow: onBeforeRemoveRow
      });
      alter('remove_row', 2, 1, 'customSource');

      expect(onBeforeRemoveRow).toHaveBeenCalledWith(countRows(), 1, [2], 'customSource', undefined, undefined);
    });

    it('should not remove row if removing has been canceled by beforeRemoveRow event handler', function () {
      var onBeforeRemoveRow = jasmine.createSpy('onBeforeRemoveRow');

      onBeforeRemoveRow.and.callFake(function () {
        return false;
      });

      var hot = handsontable({
        data: arrayOfNestedObjects(),
        columns: [{ data: 'id' }, { data: 'name.first' }],
        beforeRemoveRow: onBeforeRemoveRow
      });

      expect(countRows()).toEqual(3);

      alter('remove_row');

      expect(countRows()).toEqual(3);
    });

    it('should not remove rows below minRows', function () {
      handsontable({
        startRows: 5,
        minRows: 4
      });
      alter('remove_row', 1);
      alter('remove_row', 1);
      alter('remove_row', 1);

      expect(countRows()).toEqual(4);
    });

    it('should not remove cols below minCols', function () {
      handsontable({
        startCols: 5,
        minCols: 4
      });
      alter('remove_col', 1);
      alter('remove_col', 1);
      alter('remove_col', 1);

      expect(countCols()).toEqual(4);
    });

    it('should remove one row if amount parameter is empty', function () {
      handsontable({
        data: [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3'], ['c1', 'c2', 'c3'], ['d1', 'd2', 'd3'], ['e1', 'e2', 'e3']]
      });
      alter('remove_row', 1);

      expect(countRows()).toEqual(4);
      expect(this.$container.find('tr:eq(0) td:eq(0)').html()).toEqual('a1');
      expect(this.$container.find('tr:eq(1) td:eq(1)').html()).toEqual('c2');
    });

    it('should remove as many rows as given in the amount parameter', function () {
      handsontable({
        data: [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3'], ['c1', 'c2', 'c3'], ['d1', 'd2', 'd3'], ['e1', 'e2', 'e3']]
      });
      alter('remove_row', 1, 3);

      expect(countRows()).toEqual(2);
      expect(this.$container.find('tr:eq(0) td:eq(0)').html()).toEqual('a1');
      expect(this.$container.find('tr:eq(1) td:eq(1)').html()).toEqual('e2');
    });

    it('should not remove more rows that exist', function () {
      handsontable({
        data: [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3'], ['c1', 'c2', 'c3'], ['d1', 'd2', 'd3'], ['e1', 'e2', 'e3']]
      });
      alter('remove_row', 1, 10);

      expect(countRows()).toEqual(1);
      expect(getHtCore().find('tr:last td:last').html()).toEqual('a3');
    });

    it('should remove one row from end if no parameters are given', function () {
      handsontable({
        data: [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3'], ['c1', 'c2', 'c3'], ['d1', 'd2', 'd3'], ['e1', 'e2', 'e3']]
      });
      alter('remove_row');

      expect(countRows()).toEqual(4);
      expect(getHtCore().find('tr:last td:eq(0)').html()).toEqual('d1');
    });

    it('should remove amount of rows from end if index parameter is not given', function () {
      handsontable({
        data: [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3'], ['c1', 'c2', 'c3'], ['d1', 'd2', 'd3'], ['e1', 'e2', 'e3']]
      });
      alter('remove_row', null, 3);

      expect(countRows()).toEqual(2);
      expect(getHtCore().find('tr:last td:eq(0)').html()).toEqual('b1');
    });

    it('should remove rows from table with fixedRows', function () {
      handsontable({
        data: [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']],
        fixedRowsTop: 1,
        minSpareRows: 0
      });

      alter('remove_row', 1);

      expect(countRows()).toEqual(1);
    });

    it('should remove all rows from table with fixedRows', function () {
      handsontable({
        data: [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']],
        fixedRowsTop: 1,
        minSpareRows: 0
      });

      alter('remove_row', 1);
      alter('remove_row', 1);

      expect(countRows()).toEqual(0);
    });

    it('should remove row\'s cellProperties', function () {
      handsontable({
        startCols: 1,
        startRows: 3
      });

      getCellMeta(0, 0).someValue = [0, 0];
      getCellMeta(1, 0).someValue = [1, 0];
      getCellMeta(2, 0).someValue = [2, 0];

      alter('remove_row', 0);

      expect(getCellMeta(0, 0).someValue).toEqual([1, 0]);
      expect(getCellMeta(1, 0).someValue).toEqual([2, 0]);
    });

    it('should fire callback on remove row', function () {
      var outputBefore;
      var outputAfter;

      handsontable({
        minRows: 5,
        data: arrayOfNestedObjects(),
        columns: [{ data: 'id' }, { data: 'name.first' }],
        beforeRemoveRow: function beforeRemoveRow(index, amount, removedRows, source) {
          outputBefore = [index, amount, removedRows, source];
        },
        afterRemoveRow: function afterRemoveRow(index, amount, removedRows, source) {
          outputAfter = [index, amount, removedRows, source];
        }
      });
      alter('remove_row', 1, 2, 'customSource');

      expect(outputBefore).toEqual([1, 2, [1, 2], 'customSource']);
      expect(outputAfter).toEqual([1, 2, [1, 2], 'customSource']);
    });

    it('should decrement the number of fixed rows, if a fix row is removed', function () {
      var hot = handsontable({
        startCols: 1,
        startRows: 3,
        fixedRowsTop: 4
      });

      alter('remove_row', 1, 1);
      expect(hot.getSettings().fixedRowsTop).toEqual(3);
      alter('remove_row', 1, 2);
      expect(hot.getSettings().fixedRowsTop).toEqual(1);
    });

    it('should shift the cell meta according to the new row layout', function () {
      var hot = handsontable({
        startCols: 3,
        startRows: 4
      });

      setCellMeta(2, 1, 'className', 'test');
      alter('remove_row', 1, 1);

      expect(getCellMeta(1, 1).className).toEqual('test');
    });

    it('should shift the cell meta according to the new rows (>1) layout', function () {
      var hot = handsontable({
        startCols: 3,
        startRows: 4
      });

      setCellMeta(2, 1, 'className', 'test');
      alter('remove_row', 0, 2);

      expect(getCellMeta(0, 1).className).toEqual('test');
    });
  });

  describe('remove column', function () {
    it('should remove one column if amount parameter is empty', function () {
      handsontable({
        data: [['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'], ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']]
      });
      alter('remove_col', 1);

      expect(countCols()).toEqual(7);
      expect(this.$container.find('tr:eq(0) td:eq(0)').html()).toEqual('a');
      expect(this.$container.find('tr:eq(1) td:eq(1)').html()).toEqual('c');
    });

    it('should remove as many columns as given in the amount parameter', function () {
      handsontable({
        data: [['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'], ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']]
      });
      alter('remove_col', 1, 3);

      expect(countCols()).toEqual(5);
      expect(this.$container.find('tr:eq(0) td:eq(0)').html()).toEqual('a');
      expect(this.$container.find('tr:eq(1) td:eq(1)').html()).toEqual('e');
    });

    it('should not remove more columns that exist', function () {
      handsontable({
        data: [['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'], ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']]
      });
      alter('remove_col', 6, 3);

      expect(countCols()).toEqual(6);
      expect(this.$container.find('tr:eq(1) td:last').html()).toEqual('f');
    });

    it('should remove one column from end if no parameters are given', function () {
      handsontable({
        data: [['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'], ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']]
      });
      alter('remove_col');

      expect(countCols()).toEqual(7);
      expect(this.$container.find('tr:eq(1) td:last').html()).toEqual('g');
    });

    it('should remove amount of columns from end if index parameter is not given', function () {
      handsontable({
        data: [['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'], ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']]
      });
      alter('remove_col', null, 3);

      expect(countCols()).toEqual(5);
      expect(this.$container.find('tr:eq(1) td:last').html()).toEqual('e');
    });

    it('should fire beforeRemoveCol event before removing col', function () {
      var onBeforeRemoveCol = jasmine.createSpy('onBeforeRemoveCol');

      var hot = handsontable({
        beforeRemoveCol: onBeforeRemoveCol
      });
      alter('remove_col');

      expect(onBeforeRemoveCol).toHaveBeenCalledWith(countCols(), 1, [4], undefined, undefined, undefined);
    });

    it('should not remove column if removing has been canceled by beforeRemoveCol event handler', function () {
      var onBeforeRemoveCol = jasmine.createSpy('onBeforeRemoveCol');

      onBeforeRemoveCol.and.callFake(function () {
        return false;
      });

      var hot = handsontable({
        beforeRemoveCol: onBeforeRemoveCol
      });

      expect(countCols()).toEqual(5);

      alter('remove_col');

      expect(countCols()).toEqual(5);
    });

    it('should fire callback on remove col', function () {
      var outputBefore;
      var outputAfter;

      handsontable({
        minRows: 5,
        data: arrayOfArrays(),
        beforeRemoveCol: function beforeRemoveCol(index, amount, removedCols, source) {
          outputBefore = [index, amount, removedCols, source];
        },
        afterRemoveCol: function afterRemoveCol(index, amount, removedCols, source) {
          outputAfter = [index, amount, removedCols, source];
        }
      });
      alter('remove_col', 1, 2, 'customSource');

      expect(outputBefore).toEqual([1, 2, [1, 2], 'customSource']);
      expect(outputAfter).toEqual([1, 2, [1, 2], 'customSource']);
    });

    it('should remove column\'s properties', function () {
      handsontable({
        startCols: 3,
        startRows: 1
      });

      getCellMeta(0, 0).someValue = [0, 0];
      getCellMeta(0, 1).someValue = [0, 1];
      getCellMeta(0, 2).someValue = [0, 2];

      alter('remove_col', 0);

      expect(getCellMeta(0, 0).someValue).toEqual([0, 1]);
      expect(getCellMeta(0, 1).someValue).toEqual([0, 2]);
    });

    it('should remove column when not all rows are visible in the viewport', function () {
      this.$container.css({
        height: '100',
        overflow: 'auto'
      });

      handsontable({
        startCols: 3,
        startRows: 20
      });

      expect(getHtCore().find('tbody tr').length).toBeLessThan(20);
      expect(countCols()).toEqual(3);

      alter('remove_col', 0);

      expect(countCols()).toEqual(2);
    });

    it('should not remove column header together with the column, if headers were NOT specified explicitly', function () {

      handsontable({
        startCols: 3,
        startRows: 2,
        colHeaders: true
      });

      expect(getColHeader()).toEqual(['A', 'B', 'C']);

      expect(countCols()).toEqual(3);

      alter('remove_col', 1);

      expect(countCols()).toEqual(2);

      expect(getColHeader()).toEqual(['A', 'B']);
    });

    it('should remove column header together with the column, if headers were specified explicitly', function () {

      handsontable({
        startCols: 3,
        startRows: 2,
        colHeaders: ['Header0', 'Header1', 'Header2']
      });

      expect(getColHeader()).toEqual(['Header0', 'Header1', 'Header2']);

      expect(countCols()).toEqual(3);

      alter('remove_col', 1);

      expect(countCols()).toEqual(2);

      expect(getColHeader()).toEqual(['Header0', 'Header2']);
    });

    it('should decrement the number of fixed columns, if a fix column is removed', function () {
      var hot = handsontable({
        startCols: 1,
        startRows: 3,
        fixedColumnsLeft: 4
      });

      alter('remove_col', 1, 1);
      expect(hot.getSettings().fixedColumnsLeft).toEqual(3);
      alter('remove_col', 1, 2);
      expect(hot.getSettings().fixedColumnsLeft).toEqual(1);
    });

    it('should shift the cell meta according to the new column layout', function () {
      var hot = handsontable({
        startCols: 4,
        startRows: 3
      });

      setCellMeta(1, 2, 'className', 'test');
      alter('remove_col', 1, 1);

      expect(getCellMeta(1, 1).className).toEqual('test');
    });

    it('should shift the cell meta according to the new columns (>1) layout', function () {
      var hot = handsontable({
        startCols: 4,
        startRows: 3
      });

      setCellMeta(1, 2, 'className', 'test');
      alter('remove_col', 0, 2);

      expect(getCellMeta(1, 0).className).toEqual('test');
    });
  });

  describe('insert row', function () {
    it('should insert row at given index', function () {
      handsontable({
        data: [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3'], ['c1', 'c2', 'c3'], ['d1', 'd2', 'd3'], ['e1', 'e2', 'e3']]
      });
      alter('insert_row', 1);

      expect(countRows()).toEqual(6);
      expect(this.$container.find('tr:eq(2) td:eq(0)').html()).toEqual('b1');
    });

    it('should insert row at the end if index is not given', function () {
      handsontable({
        data: [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3'], ['c1', 'c2', 'c3'], ['d1', 'd2', 'd3'], ['e1', 'e2', 'e3']]
      });
      alter('insert_row');

      expect(countRows()).toEqual(6);
      expect(getHtCore().find('tr:eq(4) td:eq(0)').html()).toEqual('e1');

      expect(getHtCore().find('tr:last td:eq(0)').html()).toEqual('');
    });

    it('should not change cellMeta after executing `insert row` without parameters (#3581, #3989, #2114)', function () {
      var greenRenderer = function greenRenderer(instance, td, row, col, prop, value, cellProperties) {
        Handsontable.renderers.TextRenderer.apply(this, arguments);
        td.style.backgroundColor = 'green';
      };

      handsontable({
        data: [[0, 'a', true], [1, 'b', false], [2, 'c', true], [3, 'd', true]],
        cell: [{ row: 0, col: 0, renderer: greenRenderer, type: 'text', readOnly: true }],
        columns: [{ type: 'numeric' }, { type: 'text' }, { type: 'checkbox' }]
      });

      alter('insert_row');

      expect(getCellMeta(1, 0).renderer).not.toBe(greenRenderer);
      expect(getCellMeta(1, 0).readOnly).toBe(false);

      expect(getCellMeta(4, 0).renderer).not.toBe(greenRenderer);
      expect(getCellMeta(4, 0).readOnly).toBe(false);
    });

    it('should add new row which respect defined type of cells after executing `insert_row`', function () {
      handsontable({
        data: [[0, 'a', true], [1, 'b', false], [2, 'c', true], [3, 'd', true]],
        cell: [{ row: 0, col: 0, type: 'text' }],
        columns: [{ type: 'numeric' }, { type: 'text' }, { type: 'checkbox' }]
      });

      alter('insert_row');

      // added row

      expect(getCellMeta(4, 0).type).toEqual('numeric');
      expect(getDataAtCell(4, 0)).toEqual(null);

      expect(getCellMeta(4, 2).type).toEqual('checkbox');
      expect(getDataAtCell(4, 2)).toEqual(null);
    });

    it('should insert the amount of rows at given index', function () {
      handsontable({
        data: [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3'], ['c1', 'c2', 'c3'], ['d1', 'd2', 'd3'], ['e1', 'e2', 'e3']]
      });
      alter('insert_row', 1, 3);

      expect(countRows()).toEqual(8);

      expect(this.$container.find('tr:eq(1) td:eq(0)').html()).toEqual('');

      expect(this.$container.find('tr:eq(4) td:eq(0)').html()).toEqual('b1');
    });

    it('should insert the amount of rows at the end if index is not given', function () {
      handsontable({
        data: [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3'], ['c1', 'c2', 'c3'], ['d1', 'd2', 'd3'], ['e1', 'e2', 'e3']]
      });
      alter('insert_row', null, 3);

      expect(countRows()).toEqual(8);
      expect(getHtCore().find('tr:eq(4) td:eq(0)').html()).toEqual('e1');

      expect(getHtCore().find('tr:eq(5) td:eq(0)').html()).toEqual('');
      expect(getHtCore().find('tr:eq(6) td:eq(0)').html()).toEqual('');
      expect(getHtCore().find('tr:eq(7) td:eq(0)').html()).toEqual('');
    });

    it('should insert not more rows than maxRows', function () {
      handsontable({
        startRows: 5,
        maxRows: 7
      });
      alter('insert_row', 1);
      alter('insert_row', 1);
      alter('insert_row', 1);

      expect(countRows()).toEqual(7);
    });

    it('when amount parameter is used, should not insert more rows than allowed by maxRows', function () {
      handsontable({
        data: [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3'], ['c1', 'c2', 'c3'], ['d1', 'd2', 'd3'], ['e1', 'e2', 'e3']],
        maxRows: 10
      });
      alter('insert_row', 1, 10);

      expect(countRows()).toEqual(10);
      expect(this.$container.find('tr:eq(6) td:eq(0)').html()).toEqual('b1');
    });

    it('should not add more source rows than defined in maxRows when trimming rows using the modifyRow hook', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 4),
        modifyRow: function modifyRow(row) {
          return [8, 9].indexOf(row) > -1 ? null : row;
        },

        maxRows: 10
      });

      expect(hot.countRows()).toEqual(8);

      hot.populateFromArray(7, 0, [['a'], ['b'], ['c']]);

      expect(hot.countSourceRows()).toEqual(10);
      expect(hot.getDataAtCell(7, 0)).toEqual('a');
    });

    it('should fire callback on create row', function () {
      var outputBefore;
      var outputAfter;

      handsontable({
        minRows: 5,
        data: arrayOfNestedObjects(),
        columns: [{ data: 'id' }, { data: 'name.first' }],
        beforeCreateRow: function beforeCreateRow(index, amount, source) {
          outputBefore = [index, amount, source];
        },
        afterCreateRow: function afterCreateRow(index, amount, source) {
          outputAfter = [index, amount, source];
        }
      });
      alter('insert_row', 3, 1, 'customSource');

      expect(outputBefore).toEqual([3, 1, 'customSource']);
      expect(outputAfter).toEqual([3, 1, 'customSource']);
    });

    it('should keep the single-cell selection in the same position as before inserting the row', function () {
      handsontable({
        minRows: 5,
        data: [['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'], ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'], ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']]
      });

      selectCell(2, 2);
      alter('insert_row', 2);

      var selected = getSelected();
      expect(selected[0]).toEqual(3);
      expect(selected[2]).toEqual(3);
    });

    it('should shift the cell meta according to the new row layout', function () {
      var hot = handsontable({
        startCols: 4,
        startRows: 3
      });

      setCellMeta(2, 1, 'className', 'test');
      alter('insert_row', 1, 1);

      expect(getCellMeta(3, 1).className).toEqual('test');
    });

    it('should shift the cell meta according to the new rows (>1) layout', function () {
      var hot = handsontable({
        startCols: 4,
        startRows: 3
      });

      setCellMeta(2, 1, 'className', 'test');
      alter('insert_row', 0, 3);

      expect(getCellMeta(5, 1).className).toEqual('test');
    });
  });

  describe('insert column', function () {
    it('should insert column at given index', function () {
      handsontable({
        data: [['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'], ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']]
      });
      alter('insert_col', 1);

      expect(countCols()).toEqual(9);
      expect(this.$container.find('tr:eq(1) td:eq(2)').html()).toEqual('b');
    });

    it('should insert column at the end if index is not given', function () {
      handsontable({
        data: [['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'], ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']]
      });
      alter('insert_col');

      expect(countCols()).toEqual(9);
      expect(this.$container.find('tr:eq(1) td:eq(7)').html()).toEqual('h');
    });

    it('should insert the amount of columns at given index', function () {
      handsontable({
        data: [['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'], ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']]
      });
      alter('insert_col', 1, 3);

      expect(countCols()).toEqual(11);
      expect(this.$container.find('tr:eq(1) td:eq(4)').html()).toEqual('b');
    });

    it('should insert the amount of columns at the end if index is not given', function () {
      handsontable({
        data: [['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'], ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']]
      });
      alter('insert_col', null, 3);

      expect(countCols()).toEqual(11);
      expect(this.$container.find('tr:eq(1) td:eq(7)').html()).toEqual('h');

      expect(this.$container.find('tr:eq(1) td:eq(8)').html()).toEqual('');
      expect(this.$container.find('tr:eq(1) td:eq(9)').html()).toEqual('');
      expect(this.$container.find('tr:eq(1) td:eq(10)').html()).toEqual('');
    });

    it('should insert not more cols than maxCols', function () {
      handsontable({
        startCols: 5,
        maxCols: 7
      });
      alter('insert_col', 1);
      alter('insert_col', 1);
      alter('insert_col', 1);

      expect(countCols()).toEqual(7);
    });

    it('should not insert more columns than allowed by maxCols, when amount parameter is used', function () {
      handsontable({
        data: [['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'], ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']],
        maxCols: 10
      });
      alter('insert_col', 1, 10);

      expect(countCols()).toEqual(10);
      expect(this.$container.find('tr:eq(1) td:eq(1)').html()).toEqual('');
      expect(this.$container.find('tr:eq(1) td:eq(2)').html()).toEqual('');
      expect(this.$container.find('tr:eq(1) td:eq(3)').html()).toEqual('b');
    });

    it('should fire callback on create col', function () {
      var outputBefore;
      var outputAfter;

      handsontable({
        minRows: 5,
        data: arrayOfArrays(),
        beforeCreateCol: function beforeCreateCol(index, amount, source) {
          outputBefore = [index, amount, source];
        },
        afterCreateCol: function afterCreateCol(index, amount, source) {
          outputAfter = [index, amount, source];
        }
      });
      alter('insert_col', 2, 1, 'customSource');

      expect(outputBefore).toEqual([2, 1, 'customSource']);
      expect(outputAfter).toEqual([2, 1, 'customSource']);
    });

    it('should not create column header together with the column, if headers were NOT specified explicitly', function () {

      handsontable({
        startCols: 3,
        startRows: 2,
        colHeaders: true
      });

      expect(getColHeader()).toEqual(['A', 'B', 'C']);

      expect(countCols()).toEqual(3);

      alter('insert_col', 1);

      expect(countCols()).toEqual(4);

      expect(getColHeader()).toEqual(['A', 'B', 'C', 'D']);
    });

    it('should create column header together with the column, if headers were specified explicitly', function () {

      handsontable({
        startCols: 3,
        startRows: 2,
        colHeaders: ['Header0', 'Header1', 'Header2']
      });

      expect(getColHeader()).toEqual(['Header0', 'Header1', 'Header2']);

      expect(countCols()).toEqual(3);

      alter('insert_col', 1);

      expect(countCols()).toEqual(4);

      expect(getColHeader()).toEqual(['Header0', 'B', 'Header1', 'Header2']);
    });

    it('should stretch the table after adding another column (if stretching is set to \'all\')', function () {
      this.$container.css({
        width: 500
      });

      var hot = handsontable({
        startCols: 5,
        startRows: 10,
        stretchH: 'all'
      });

      expect(Handsontable.dom.outerWidth(hot.view.TBODY)).toEqual(500);
      alter('insert_col', null, 1);
      expect(Handsontable.dom.outerWidth(hot.view.TBODY)).toEqual(500);
      alter('insert_col', null, 1);
      expect(Handsontable.dom.outerWidth(hot.view.TBODY)).toEqual(500);
    });

    it('should shift the cell meta according to the new column layout', function () {
      var hot = handsontable({
        startCols: 4,
        startRows: 3
      });

      setCellMeta(1, 2, 'className', 'test');
      alter('insert_col', 1, 1);

      expect(getCellMeta(1, 3).className).toEqual('test');
    });

    it('should shift the cell meta according to the new columns (>1) layout', function () {
      var hot = handsontable({
        startCols: 4,
        startRows: 3
      });

      setCellMeta(1, 2, 'className', 'test');
      alter('insert_col', 0, 3);

      expect(getCellMeta(1, 5).className).toEqual('test');
    });
  });
});

/***/ }),
/* 151 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_beforeKeyDown', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should run beforeKeyDown hook', function () {
    var called = false;

    handsontable({
      data: [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]],
      beforeKeyDown: function beforeKeyDown(event) {
        called = true;
      }
    });
    selectCell(0, 0);

    keyDown('arrow_right');

    expect(called).toEqual(true);
  });

  it('should run afterDocumentKeyDown and beforeKeyDown hook', function () {
    var called = [];

    handsontable({
      data: [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]],
      afterDocumentKeyDown: function afterDocumentKeyDown() {
        called.push('afterDocumentKeyDown');
      },
      beforeKeyDown: function beforeKeyDown() {
        called.push('beforeKeyDown');
      }
    });
    selectCell(0, 0);

    keyDown('arrow_right');

    expect(called).toEqual(['afterDocumentKeyDown', 'beforeKeyDown']);
  });

  it('should prevent hook from running default action', function () {
    var called = false;

    handsontable({
      data: [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]],
      beforeKeyDown: function beforeKeyDown(event) {

        event = serveImmediatePropagation(event);

        event.stopImmediatePropagation();
        called = true;
      }
    });
    selectCell(0, 0);

    keyDown('arrow_right');

    expect(getSelected()).toEqual([0, 0, 0, 0]);
    expect(getSelected()).not.toEqual([0, 1, 0, 1]);
  });

  it('should overwrite default behavior of delete key, but not this of right arrow', function () {
    var called = 0;

    handsontable({
      data: [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]],
      beforeKeyDown: function beforeKeyDown(event) {
        if (event.keyCode === 8) {
          event.stopImmediatePropagation();
          getInstance().alter('insert_row', 1, 1);
        }

        called++;
      }
    });

    selectCell(0, 0);

    keyDown('backspace');
    keyDown('arrow_right');

    expect(getData().length).toEqual(3);
    expect(getSelected()).toEqual([0, 1, 0, 1]);
  });

  it('should run beforeKeyDown hook in cell editor handler', function () {
    var called = 0;

    handsontable({
      data: [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]],
      beforeKeyDown: function beforeKeyDown(event) {
        called++;
      }
    });
    selectCell(0, 0);

    keyDown('enter');
    keyDown('enter');

    expect(called).toEqual(2);
  });
});

/***/ }),
/* 152 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_beforechange', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('this.rootElement should point to handsontable rootElement', function () {
    var output = null;

    handsontable({
      beforeChange: function beforeChange() {
        output = this.rootElement;
      }
    });
    setDataAtCell(0, 0, 'test');

    expect(output).toEqual(this.$container[0]);
  });

  it('should remove change from stack', function () {
    var output = null;

    handsontable({
      data: [['a', 'b'], ['c', 'd']],
      beforeChange: function beforeChange(changes) {
        changes[1] = null;
      },
      afterChange: function afterChange(changes) {
        output = changes;
      }
    });
    setDataAtCell([[0, 0, 'test'], [1, 0, 'test'], [1, 1, 'test']]);

    expect(getDataAtCell(0, 0)).toEqual('test');
    expect(getDataAtCell(1, 0)).toEqual('c');
    expect(getDataAtCell(1, 1)).toEqual('test');
    expect(output).toEqual([[0, 0, 'a', 'test'], [1, 1, 'd', 'test']]);
  });

  it('should drop all changes when beforeChange return false', function () {
    var fired = false;

    handsontable({
      data: [['a', 'b'], ['c', 'd']],
      beforeChange: function beforeChange(changes) {
        fired = true;
        return false;
      }
    });
    setDataAtCell([[0, 0, 'test'], [1, 0, 'test'], [1, 1, 'test']]);

    expect(getDataAtCell(0, 0)).toEqual('a');
    expect(getDataAtCell(1, 0)).toEqual('c');
    expect(getDataAtCell(1, 1)).toEqual('d');
  });

  function beforechangeOnKeyFactory(keyCode) {
    return function () {
      var called = false;

      handsontable({
        beforeChange: function beforeChange(changes) {
          if (changes[0][2] === 'test' && changes[0][3] === '') {
            called = true;
          }
        }
      });

      setDataAtCell(0, 0, 'test');
      selectCell(0, 0);

      keyDown(keyCode);

      expect(called).toEqual(true);
    };
  }

  it('should be called on Delete key', beforechangeOnKeyFactory(46)); // 46 = Delete key

  it('should be called on Backspace key', beforechangeOnKeyFactory(8)); // 8 = Backspace key
});

/***/ }),
/* 153 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

describe('Core_copy', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  var arrayOfArrays = function arrayOfArrays() {
    return [['', 'Kia', 'Nissan', 'Toyota', 'Honda'], ['2008', 10, 11, 12, 13], ['2009', 20, 11, 14, 13], ['2010', 30, 15, 12, 13]];
  };

  it('should set copyable text until copyRowsLimit is reached', function () {
    handsontable({
      data: arrayOfArrays(),
      copyRowsLimit: 2
    });

    selectCell(0, 0, countRows() - 1, countCols() - 1); // selectAll
    keyDownUp('ctrl');

    // should prepare 2 rows for copying
    expect($('textarea.copyPaste').val()).toEqual('\tKia\tNissan\tToyota\tHonda\n2008\t10\t11\t12\t13');
  });

  it('should set copyable text until copyColsLimit is reached', function () {
    handsontable({
      data: arrayOfArrays(),
      copyColsLimit: 2
    });

    selectCell(0, 0, countRows() - 1, countCols() - 1); // selectAll
    keyDownUp('ctrl');

    // should prepare 2 columns for copying
    expect($('textarea.copyPaste').val()).toEqual('\tKia\n2008\t10\n2009\t20\n2010\t30');
  });

  it('should call onCopyLimit callback when copy limit was reached', function () {
    var result;

    handsontable({
      data: arrayOfArrays(),
      copyRowsLimit: 2,
      copyColsLimit: 2,
      afterCopyLimit: function afterCopyLimit(selectedRowsCount, selectedColsCount, copyRowsLimit, copyColsLimit) {
        result = [selectedRowsCount, selectedColsCount, copyRowsLimit, copyColsLimit];
      }
    });

    selectCell(0, 0, countRows() - 1, countCols() - 1); // selectAll
    keyDownUp('ctrl');
    expect(result).toEqual([4, 5, 2, 2]);
  });

  it('ctrl+x should cut selected data', _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
    var hot;
    return regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            hot = handsontable({
              data: arrayOfArrays()
            });


            selectCell(0, 0, countRows() - 1, countCols() - 1); // selectAll
            keyDownUp('ctrl+x');

            _context.next = 5;
            return sleep(300);

          case 5:

            expect(hot.getDataAtCell(0, 0)).toEqual('');
            expect(hot.getDataAtCell(1, 1)).toEqual('');
            expect(hot.getDataAtCell(2, 2)).toEqual('');

          case 8:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, undefined);
  })));

  it('ctrl+v should paste copied data to selected range', _asyncToGenerator(regeneratorRuntime.mark(function _callee2() {
    var hot;
    return regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            hot = handsontable({
              data: arrayOfArrays()
            });

            $('textarea.copyPaste').val('\tKia\tNissan\tToyota\tHonda\n2008\t10\t11\t12\t13');

            selectCell(0, 0, countRows() - 1, countCols() - 1); // selectAll
            keyDownUp('ctrl+v');

            _context2.next = 6;
            return sleep(200);

          case 6:

            expect(hot.getDataAtCell(0, 0)).toEqual('');
            expect(hot.getDataAtCell(0, 1)).toEqual('Kia');
            expect(hot.getDataAtCell(0, 2)).toEqual('Nissan');
            expect(hot.getDataAtCell(0, 3)).toEqual('Toyota');
            expect(hot.getDataAtCell(1, 0)).toEqual('2008');
            expect(hot.getDataAtCell(1, 1)).toEqual('10');
            expect(hot.getDataAtCell(1, 2)).toEqual('11');
            expect(hot.getDataAtCell(1, 3)).toEqual('12');

          case 14:
          case 'end':
            return _context2.stop();
        }
      }
    }, _callee2, undefined);
  })));
});

/***/ }),
/* 154 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_count', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    destroy();
    this.$container.remove();
  });

  describe('countVisibleRows', function () {
    it('should return number of visible rows', function () {
      var instance = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        height: 100,
        width: 600
      });
      expect(instance.countVisibleRows()).toEqual(4);
    });

    it('should return -1 if table is not rendered', function () {
      this.$container.remove();
      var instance = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        width: 100
      });
      expect(instance.countVisibleRows()).toEqual(-1);
    });
  });

  describe('countRenderedRows', function () {
    it('should return number of rendered rows', function () {
      var instance = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        height: 100,
        viewportRowRenderingOffset: 0
      });
      expect(instance.countRenderedRows()).toEqual(5);
    });

    it('should return number of rendered rows, including rows rendered becausee of viewportRowRenderingOffset', function () {
      var instance = handsontable({
        data: Handsontable.helper.createSpreadsheetData(50, 10),
        height: 100,
        viewportRowRenderingOffset: 20
      });
      expect(instance.countRenderedRows()).toEqual(25);
    });

    it('should return -1 if table is not rendered', function () {
      this.$container.remove();
      var instance = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        width: 100
      });
      expect(instance.countRenderedRows()).toEqual(-1);
    });
  });

  describe('countVisibleCols', function () {
    it('should return number of visible columns', function () {
      var instance = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        width: 100
      });
      expect(instance.countVisibleCols()).toEqual(10);
    });

    it('should return -1 if table is not rendered', function () {
      this.$container.remove();
      var instance = handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 10),
        width: 100
      });

      expect(instance.countVisibleCols()).toEqual(-1);
    });
  });
});

/***/ }),
/* 155 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_dataSchema', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should be equal to `hot.getSchema()` when dataSchema is defined in settings (as object)', function () {
    var schema = { id: null, name: { first: null, last: null }, cars: [{ brand: null }] },
        hot = handsontable({
      data: [],
      dataSchema: schema,
      minRows: 5,
      minCols: 4,
      colHeaders: ['ID', 'First Name', 'Last Name'],
      columns: [{ data: 'id' }, { data: 'name.first' }, { data: 'name.last' }],
      minSpareRows: 1
    });

    expect(JSON.stringify(hot.getSchema())).toEqual(JSON.stringify(schema));
  });

  it('should be equal to `hot.getSchema()` when dataSchema is defined in settings (as object) when columns is a function', function () {
    var schema = { id: null, name: { first: null, last: null }, cars: [{ brand: null }] },
        hot = handsontable({
      data: [],
      dataSchema: schema,
      minRows: 5,
      minCols: 4,
      colHeaders: ['ID', 'First Name', 'Last Name'],
      columns: function columns(column) {
        var colMeta = {};

        if (column === 0) {
          colMeta.data = 'id';
        } else if (column === 1) {
          colMeta.data = 'name.first';
        } else if (column === 2) {
          colMeta.data = 'name.last';
        } else {
          colMeta = null;
        }

        return colMeta;
      },

      minSpareRows: 1
    });

    expect(JSON.stringify(hot.getSchema())).toEqual(JSON.stringify(schema));
  });

  it('should be equal to `hot.getSchema()` when dataSchema is defined in settings (as function)', function () {
    var schema = { id: null, name: { first: null, last: null }, cars: [{ brand: null }] },
        hot = handsontable({
      data: [],
      dataSchema: function dataSchema() {
        return schema;
      },

      minRows: 5,
      minCols: 4,
      colHeaders: ['ID', 'First Name', 'Last Name'],
      columns: [{ data: 'id' }, { data: 'name.first' }, { data: 'name.last' }],
      minSpareRows: 1
    });
    expect(JSON.stringify(hot.getSchema())).toEqual(JSON.stringify(schema));
  });

  it('should be equal to `hot.getSchema()` when dataSchema is defined in settings (as function) when columns is a function', function () {
    var schema = { id: null, name: { first: null, last: null }, cars: [{ brand: null }] },
        hot = handsontable({
      data: [],
      dataSchema: function dataSchema() {
        return schema;
      },

      minRows: 5,
      minCols: 4,
      colHeaders: ['ID', 'First Name', 'Last Name'],
      columns: function columns(column) {
        var colMeta = {};

        if (column === 0) {
          colMeta.data = 'id';
        } else if (column === 1) {
          colMeta.data = 'name.first';
        } else if (column === 2) {
          colMeta.data = 'name.last';
        } else {
          colMeta = null;
        }

        return colMeta;
      },

      minSpareRows: 1
    });
    expect(JSON.stringify(hot.getSchema())).toEqual(JSON.stringify(schema));
  });

  it('should be equal to `hot.getSchema()` when dataSchema is generated based on data structure', function () {
    var hot = handsontable({
      data: [{ id: 1, name: { first: 'Alan', last: 'Pakoli' }, cars: [{ brand: 'Ford' }] }],
      minRows: 5,
      minCols: 4,
      colHeaders: ['ID', 'First Name', 'Last Name'],
      columns: [{ data: 'id' }, { data: 'name.first' }, { data: 'name.last' }],
      minSpareRows: 1
    });

    expect(JSON.stringify(hot.getSchema())).toEqual(JSON.stringify({ id: null, name: { first: null, last: null }, cars: [{ brand: null }] }));
  });

  it('should be equal to `hot.getSchema()` when dataSchema is generated based on data structure when columns is a function', function () {
    var hot = handsontable({
      data: [{ id: 1, name: { first: 'Alan', last: 'Pakoli' }, cars: [{ brand: 'Ford' }] }],
      minRows: 5,
      minCols: 4,
      colHeaders: ['ID', 'First Name', 'Last Name'],
      columns: function columns(column) {
        var colMeta = {};

        if (column === 0) {
          colMeta.data = 'id';
        } else if (column === 1) {
          colMeta.data = 'name.first';
        } else if (column === 2) {
          colMeta.data = 'name.last';
        } else {
          colMeta = null;
        }

        return colMeta;
      },

      minSpareRows: 1
    });

    expect(JSON.stringify(hot.getSchema())).toEqual(JSON.stringify({ id: null, name: { first: null, last: null }, cars: [{ brand: null }] }));
  });

  it('should create new row from dataSchema', function () {
    handsontable({
      data: [],
      dataSchema: { id: null, name: { first: null, last: null }, address: null },
      minRows: 5,
      minCols: 4,
      colHeaders: ['ID', 'First Name', 'Last Name', 'Address'],
      columns: [{ data: 'id' }, { data: 'name.first' }, { data: 'name.last' }, { data: 'address' }],
      minSpareRows: 1
    });
    selectCell(0, 1);

    keyDownUp('enter');
    keyProxy().val('Ted');
    keyDownUp('enter');
    expect(getData()[0][1]).toEqual('Ted');
    expect(getSourceData()[0].name.first).toEqual('Ted');
  });

  it('should create new row from dataSchema when columns is a function', function () {
    handsontable({
      data: [],
      dataSchema: { id: null, name: { first: null, last: null }, address: null },
      minRows: 5,
      minCols: 4,
      colHeaders: ['ID', 'First Name', 'Last Name', 'Address'],
      columns: function columns(column) {
        var colMeta = {};

        if (column === 0) {
          colMeta.data = 'id';
        } else if (column === 1) {
          colMeta.data = 'name.first';
        } else if (column === 2) {
          colMeta.data = 'name.last';
        } else if (column === 3) {
          colMeta.data = 'address';
        } else {
          colMeta = null;
        }

        return colMeta;
      },

      minSpareRows: 1
    });
    selectCell(0, 1);

    keyDownUp('enter');
    keyProxy().val('Ted');
    keyDownUp('enter');
    expect(getData()[0][1]).toEqual('Ted');
    expect(getSourceData()[0].name.first).toEqual('Ted');
  });

  it('should create new row from dataSchema (functional)', function () {
    handsontable({
      data: [],
      dataSchema: function dataSchema(index) {
        return { id: 1000 + index, name: { first: null, last: null }, address: null };
      },
      isEmptyRow: function isEmptyRow(r) {
        var row = this.getSourceData()[r];

        return (row.name.first === null || row.name.first === '') && (row.name.last === null || row.name.last === '') && (row.address === null || row.address === '');
      },

      minRows: 5,
      minCols: 4,
      colHeaders: ['ID', 'First Name', 'Last Name', 'Address'],
      columns: [{ data: 'id' }, { data: 'name.first' }, { data: 'name.last' }, { data: 'address' }],
      minSpareRows: 1
    });
    selectCell(4, 1);

    expect(countRows()).toEqual(5);
    keyDownUp('enter');
    keyProxy().val('Ted');

    // need it in next frame as long as HT is rendered in async
    keyDownUp('enter');
    // need it in next frame as long as HT is rendered in async
    keyDownUp('enter');

    expect(getSourceData()[4].name.first).toEqual('Ted');
    expect(getSourceData()[4].id).toEqual(1004);
    expect(getData()[4][1]).toEqual('Ted');
    expect(getData()[4][0]).toEqual(1004);
    expect(countRows()).toEqual(6); // row should be added by keepEmptyRows
  });

  it('should create new row from dataSchema (functional) when columns is a function', function () {
    handsontable({
      data: [],
      dataSchema: function dataSchema(index) {
        return { id: 1000 + index, name: { first: null, last: null }, address: null };
      },
      isEmptyRow: function isEmptyRow(r) {
        var row = this.getSourceData()[r];

        return (row.name.first === null || row.name.first === '') && (row.name.last === null || row.name.last === '') && (row.address === null || row.address === '');
      },

      minRows: 5,
      minCols: 4,
      colHeaders: ['ID', 'First Name', 'Last Name', 'Address'],
      columns: function columns(column) {
        var colMeta = {};

        if (column === 0) {
          colMeta.data = 'id';
        } else if (column === 1) {
          colMeta.data = 'name.first';
        } else if (column === 2) {
          colMeta.data = 'name.last';
        } else if (column === 3) {
          colMeta.data = 'address';
        } else {
          colMeta = null;
        }

        return colMeta;
      },

      minSpareRows: 1
    });
    selectCell(4, 1);

    expect(countRows()).toEqual(5);
    keyDownUp('enter');
    keyProxy().val('Ted');

    // need it in next frame as long as HT is rendered in async
    keyDownUp('enter');
    // need it in next frame as long as HT is rendered in async
    keyDownUp('enter');

    expect(getSourceData()[4].name.first).toEqual('Ted');
    expect(getSourceData()[4].id).toEqual(1004);
    expect(getData()[4][1]).toEqual('Ted');
    expect(getData()[4][0]).toEqual(1004);
    expect(countRows()).toEqual(6); // row should be added by keepEmptyRows
  });

  it('should translate prop to col, when prop is a function', function () {
    var idAccessor = createAccessorForProperty('id');
    var nameAccessor = createAccessorForProperty('name');

    hot = handsontable({
      data: [Model({
        id: 1,
        name: 'Tom'
      }), Model({
        id: 2,
        name: 'Hanna'
      }), Model({
        id: 3,
        name: 'Jerry'
      })],
      dataSchema: Model,
      columns: [{
        data: idAccessor
      }, {
        data: nameAccessor
      }]
    });

    expect(hot.propToCol(idAccessor)).toEqual(0);
    expect(hot.propToCol(nameAccessor)).toEqual(1);
  });

  it('should translate prop to col, when prop and columns is a function', function () {
    var idAccessor = createAccessorForProperty('id');
    var nameAccessor = createAccessorForProperty('name');

    hot = handsontable({
      data: [Model({
        id: 1,
        name: 'Tom'
      }), Model({
        id: 2,
        name: 'Hanna'
      }), Model({
        id: 3,
        name: 'Jerry'
      })],
      dataSchema: Model,
      columns: function columns(column) {
        var colMeta = {};

        if (column === 0) {
          colMeta.data = idAccessor;
        } else if (column === 1) {
          colMeta.data = nameAccessor;
        } else {
          colMeta = null;
        }

        return colMeta;
      }
    });

    expect(hot.propToCol(idAccessor)).toEqual(0);
    expect(hot.propToCol(nameAccessor)).toEqual(1);
  });

  it('should create new row data matched to dataSchema (data type as `array`)', function () {
    var spy = jasmine.createSpy();
    var hot = handsontable({
      data: [[{ id: 1 }]],
      dataSchema: [{ id: null }],
      columns: [{ data: '0', renderer: spy }],
      autoColumnSize: false,
      autoRowSize: false
    });

    expect(spy.calls.count()).toBe(1);
    expect(spy.calls.argsFor(0)[5]).toEqual({ id: 1 });

    spy.calls.reset();
    hot.alter('insert_row', 0);

    expect(spy.calls.count()).toBe(2);
    expect(spy.calls.argsFor(0)[5]).toEqual({ id: null });
    expect(spy.calls.argsFor(1)[5]).toEqual({ id: 1 });
  });

  it('should create new row data matched to dataSchema (data type as `array`) when columns is a function', function () {
    var spy = jasmine.createSpy();
    var hot = handsontable({
      data: [[{ id: 1 }]],
      dataSchema: [{ id: null }],
      columns: function columns(column) {
        var colMeta = {};

        if (column === 0) {
          colMeta.data = '0';
          colMeta.renderer = spy;
        } else {
          colMeta = null;
        }

        return colMeta;
      },

      autoColumnSize: false,
      autoRowSize: false
    });

    expect(spy.calls.count()).toBe(1);
    expect(spy.calls.argsFor(0)[5]).toEqual({ id: 1 });

    spy.calls.reset();
    hot.alter('insert_row', 0);

    expect(spy.calls.count()).toBe(2);
    expect(spy.calls.argsFor(0)[5]).toEqual({ id: null });
    expect(spy.calls.argsFor(1)[5]).toEqual({ id: 1 });
  });

  it('should create an array of objects as the source structure, when dataSchema is defined (as an object) but no data is provided', function () {
    var hot = handsontable({
      startCols: 2,
      minSpareRows: 4,
      dataSchema: { id: null, name: null, surname: null }
    });

    var dataAtRow = hot.getSourceDataAtRow(0);

    expect(Array.isArray(dataAtRow)).toBe(false);
    expect(dataAtRow.id).toEqual(null);
    expect(dataAtRow.name).toEqual(null);
    expect(dataAtRow.surname).toEqual(null);
  });

  it('should create an array of objects as the source structure, when dataSchema is defined (as a function) but no data is provided', function () {
    var hot = handsontable({
      startCols: 2,
      minSpareRows: 4,
      dataSchema: function dataSchema() {
        return { id: null, name: null, surname: null };
      }
    });

    var dataAtRow = hot.getSourceDataAtRow(0);

    expect(Array.isArray(dataAtRow)).toBe(false);
    expect(dataAtRow.id).toEqual(null);
    expect(dataAtRow.name).toEqual(null);
    expect(dataAtRow.surname).toEqual(null);
  });

  it('should create an array of objects as the source structure, when dataSchema is defined (as an array with an object) but no data is provided', function () {
    var hot = handsontable({
      startCols: 2,
      minSpareRows: 4,
      dataSchema: [{ id: null, name: null, surname: null }]
    });

    var dataAtRow = hot.getSourceDataAtRow(0);

    expect(Array.isArray(dataAtRow)).toBe(false);
    expect(dataAtRow.id).toEqual(null);
    expect(dataAtRow.name).toEqual(null);
    expect(dataAtRow.surname).toEqual(null);
  });
});

/***/ }),
/* 156 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_datachange', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should call onChange callback', function () {
    var output = null;

    handsontable({
      afterChange: function afterChange(changes) {
        output = changes;
      }
    });
    setDataAtCell(1, 2, 'test');

    expect(output[0][0]).toEqual(1);
    expect(output[0][1]).toEqual(2);
    expect(output[0][2]).toEqual(null);
    expect(output[0][3]).toEqual('test');
  });

  it('should use custom source for datachange', function () {
    var output = null,
        src = null;

    handsontable({
      afterChange: function afterChange(changes, source) {
        output = changes;
        src = source;
      }
    });
    setDataAtCell(1, 2, 'abc', 'test');

    expect(output[0][3]).toEqual('abc');
    expect(src).toEqual('test');
  });

  it('should use custom source for datachange with array', function () {
    var output = null,
        src = null;

    handsontable({
      afterChange: function afterChange(changes, source) {
        output = changes;
        src = source;
      }
    });
    setDataAtCell([[1, 2, 'abc']], 'test');

    expect(output[0][3]).toEqual('abc');
    expect(src).toEqual('test');
  });

  it('should trigger datachange event', function () {
    var output = null;

    handsontable();
    Handsontable.hooks.add('afterChange', function (changes) {
      output = changes;
    });
    setDataAtCell(1, 2, 'test');

    expect(output[0][0]).toEqual(1);
    expect(output[0][1]).toEqual(2);
    expect(output[0][2]).toEqual(null);
    expect(output[0][3]).toEqual('test');
  });

  it('this.rootElement should point to handsontable rootElement', function () {
    var output = null;
    var $container = this.$container;

    handsontable({
      afterChange: function afterChange() {
        output = this.rootElement;
      }
    });
    setDataAtCell(0, 0, 'test');

    expect(output).toEqual($container[0]);
  });

  it('onChange should be triggered after data is rendered to DOM (init)', function () {
    var output = null;
    var $container = this.$container;

    handsontable({
      data: [['Joe Red']],
      afterChange: function afterChange(changes, source) {
        if (source === 'loadData') {
          output = $container.find('table.htCore tbody td:first').html();
        }
      }
    });

    expect(output).toEqual('Joe Red');
  });

  it('onChange should be triggered after data is rendered to DOM (setDataAtCell)', function () {
    var output = null;
    var $container = this.$container;

    handsontable({
      data: [['Joe Red']],
      afterChange: function afterChange(changes, source) {
        if (source === 'edit') {
          output = $container.find('table.htCore tbody td:first').html();
        }
      }
    });
    setDataAtCell(0, 0, 'Alice Red');

    expect(output).toEqual('Alice Red');
  });

  it('onChange event object should contain documented keys and values when triggered by edit', function () {
    var sampleData = [{
      col1: 'a',
      col2: 'b',
      col3: 'c'
    }];
    var event = null;

    handsontable({
      data: sampleData,
      afterChange: function afterChange(changes, source) {
        if (source === 'edit') {
          event = changes.shift();
        }
      }
    });
    setDataAtCell(0, 0, 'test');

    expect(event[0]).toEqual(0);
    expect(event[1]).toEqual('col1');
    expect(event[2]).toEqual('a');
    expect(event[3]).toEqual('test');
  });

  it('source parameter should be `edit` when cell value is changed through editor', function () {
    var sources = [];

    handsontable({
      data: [['Joe Red']],
      afterChange: function afterChange(changes, source) {
        sources.push(source);
      }
    });
    selectCell(0, 0);

    keyDown('enter');
    document.activeElement.value = 'Ted';
    keyDown('enter');

    expect(sources).toEqual(['loadData', 'edit']); // loadData is always the first source
  });
});

/***/ }),
/* 157 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_destroy', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should remove table from the root element', function () {
    handsontable();
    destroy();

    expect(this.$container.html()).toEqual('');
  });

  it('should remove events from the root element, document element and window', function () {
    var x = handsontable();

    expect(x.eventListeners.length > 0).toBeTruthy();
    destroy();
    expect(x.eventListeners).toBeNull();
    $(document.documentElement).off('.copypaste'); // remove copypaste.js listeners, which are not removed by destroy (because copypaste is a singleton for whole page)
  });

  it('should NOT remove events from document element and window for other Handsontable instances on the page', function () {
    // test based on Core_selectionSpec.js (should deselect currently selected cell)
    handsontable();

    var $tmp = $('<div id="tmp"></div>').appendTo(document.body);
    $tmp.handsontable();
    $tmp.handsontable('destroy');
    $tmp.remove();

    selectCell(0, 0);

    $('html').simulate('mousedown');

    expect(getSelected()).toBeUndefined();
  });
});

/***/ }),
/* 158 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_destroyEditor', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('editor should not be visible', function () {
    handsontable();
    selectCell(1, 1);

    keyDownUp('enter');

    destroyEditor();
    expect(isEditorVisible()).toEqual(false);
  });

  it('value should be saved', function () {
    handsontable();
    selectCell(1, 1);

    keyDownUp('enter');
    keyProxy().val('Ted');

    destroyEditor();
    expect(getDataAtCell(1, 1)).toEqual('Ted');
  });

  it('cell should be selected', function () {
    handsontable();
    selectCell(1, 1);

    keyDownUp('enter');

    destroyEditor();
    expect(getSelected()).toEqual([1, 1, 1, 1]);
  });

  it('should revert original value when param set to true', function () {
    handsontable();
    selectCell(1, 1);

    keyDownUp('enter');
    keyProxy().val('Ted');

    destroyEditor(true);
    expect(getDataAtCell(1, 1)).toEqual(null);
  });

  it('should not destroy editor on scroll', function () {
    this.$container.css({
      width: 200,
      height: 100
    });

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(20, 10)
    });

    selectCell(0, 0);
    keyDown('enter');

    var editor = $('.handsontableInputHolder');

    expect(editor.is(':visible')).toBe(true);

    this.$container.scroll();

    expect(editor.is(':visible')).toBe(true);
  });
});

/***/ }),
/* 159 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_getCellMeta', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should not allow manual editing of a read only cell', function () {
    var allCellsReadOnly = false;

    handsontable({
      cells: function cells() {
        return { readOnly: allCellsReadOnly };
      }
    });
    allCellsReadOnly = true;
    selectCell(2, 2);

    keyDown('enter');

    expect(isEditorVisible()).toEqual(false);
  });

  it('should allow manual editing of cell that is no longer read only', function () {
    var allCellsReadOnly = true;

    handsontable({
      cells: function cells() {
        return { readOnly: allCellsReadOnly };
      }
    });
    allCellsReadOnly = false;
    selectCell(2, 2);

    keyDown('enter');

    expect(isEditorVisible()).toEqual(true);
  });

  it('should move the selection to the cell below, when hitting the ENTER key on a read-only cell', function () {
    handsontable({
      data: Handsontable.helper.createSpreadsheetData(3, 3),
      cells: function cells() {
        return { readOnly: true };
      }
    });

    selectCell(0, 0);
    expect(getCellMeta(0, 0).readOnly).toBe(true);
    keyDown('enter');
    expect(getSelected()).toEqual([1, 0, 1, 0]);
  });

  it('should use default cell editor for a cell that has declared only cell renderer', function () {
    handsontable({
      cells: function cells() {
        return {
          renderer: function renderer(instance, td, row, col, prop, value, cellProperties) {
            // taken from demo/renderers.html
            Handsontable.renderers.TextRenderer.apply(this, arguments);
            $(td).css({
              background: 'yellow'
            });
          }
        };
      }
    });
    selectCell(2, 2);

    keyDown('enter');
    document.activeElement.value = 'new value';
    destroyEditor();
    expect(getDataAtCell(2, 2)).toEqual('new value');
  });

  it('should allow to use type and renderer in `flat` notation', function () {
    handsontable({
      data: [[1, 2, 3, 4], [5, 6, 7, 8], [0, 9, 8, 7]],
      cells: function cells(row, col) {
        if (row === 2 && col === 2) {
          return {
            type: 'checkbox',
            renderer: function renderer(instance, td, row, col, prop, value, cellProperties) {
              // taken from demo/renderers.html
              Handsontable.renderers.TextRenderer.apply(this, arguments);

              td.style.backgroundColor = 'yellow';
            }
          };
        }
      }
    });

    expect(getCell(2, 2).style.backgroundColor).toEqual('yellow');
    expect(getCell(1, 1).style.backgroundColor).toEqual('');
  });

  it('this in cells should point to cellProperties', function () {
    var called = 0,
        _row,
        _this;

    handsontable({
      cells: function cells(row, col, prop) {
        called++;
        _row = row;
        _this = this;
      }
    });

    var HOT = getInstance();

    expect(called).toBeGreaterThan(0);
    expect(_this.row).toEqual(_row);
    expect(_this.instance).toBe(HOT);
  });

  it('should get proper cellProperties when order of displayed rows is different than order of stored data', function () {
    var hot = handsontable({
      data: [['C'], ['A'], ['B']],
      minSpareRows: 1,
      cells: function cells(row, col, prop) {
        var cellProperties = {};

        if (getSourceData()[row][col] === 'A') {
          cellProperties.readOnly = true;
        }

        return cellProperties;
      }
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('C');
    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').hasClass('htDimmed')).toBe(false);

    expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('A');
    expect(this.$container.find('tbody tr:eq(1) td:eq(0)').hasClass('htDimmed')).toBe(true);

    expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('B');
    expect(this.$container.find('tbody tr:eq(2) td:eq(0)').hasClass('htDimmed')).toBe(false);

    // Column sorting changes the order of displayed rows while keeping table data unchanged
    updateSettings({
      columnSorting: {
        column: 0,
        sortOrder: true
      }
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('A');
    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').hasClass('htDimmed')).toBe(true);

    expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('B');
    expect(this.$container.find('tbody tr:eq(1) td:eq(0)').hasClass('htDimmed')).toBe(false);

    expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('C');
    expect(this.$container.find('tbody tr:eq(2) td:eq(0)').hasClass('htDimmed')).toBe(false);
  });
});

/***/ }),
/* 160 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.getColHeader', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('when not configured, should return undefined', function () {
    handsontable();
    expect(getColHeader(1)).toBe(null);
  });

  it('when configured as true, should return the Excel-style column title', function () {
    handsontable({
      colHeaders: true
    });
    expect(getColHeader(30)).toEqual('AE');
  });

  it('when configured as array, should return value at index', function () {
    handsontable({
      colHeaders: ['One', 'Two', 'Three', 'Four', 'Five']
    });
    expect(getColHeader(1)).toEqual('Two');
  });

  it('when configured as function, should return function output', function () {
    handsontable({
      colHeaders: function colHeaders(index) {
        return 'col' + index;
      }
    });
    expect(getColHeader(1)).toEqual('col1');
  });

  it('when configured as static value, should return the value', function () {
    handsontable({
      colHeaders: 'static'
    });
    expect(getColHeader(1)).toEqual('static');
  });

  it('when configured as HTML value, should render that as HTML', function () {
    handsontable({
      colHeaders: function colHeaders(index) {
        return '<b>col' + index + '</b>';
      }
    });
    expect(getColHeader(1)).toEqual('<b>col1</b>');
  });

  it('when no argument given, should return as much column headers as there are columns', function () {
    handsontable({
      colHeaders: true,
      startCols: 3
    });
    expect(getColHeader()).toEqual(['A', 'B', 'C']);
  });
});

/***/ }),
/* 161 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_getDataAt*', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  var arrayOfArrays = function arrayOfArrays() {
    return [['', 'Kia', 'Nissan', 'Toyota', 'Honda'], ['2008', 10, 11, 12, 13], ['2009', 20, 11, 14, 13], ['2010', 30, 15, 12, 13]];
  };

  var arrayOfObjects = function arrayOfObjects() {
    return [{
      'id.a.b.c': 1,
      id: 1,
      name: 'Nannie Patel',
      address: 'Jenkin ville',
      details: {
        city: 'Chicago'
      }
    }, {
      'id.a.b.c': 2,
      id: 2,
      name: 'Łucja Grożny and Środeńczak',
      address: 'Gardiner',
      details: {
        city: 'New York'
      }
    }];
  };

  it('should return data at specified row', function () {
    handsontable({
      data: arrayOfArrays()
    });

    expect(getDataAtRow(0)).toEqual(['', 'Kia', 'Nissan', 'Toyota', 'Honda']);
  });

  it('should return data at specified col', function () {
    handsontable({
      data: arrayOfArrays()
    });

    expect(getDataAtCol(1)).toEqual(['Kia', 10, 20, 30]);
  });

  describe('Core_getDataAtRowProp', function () {
    it('should return data at specified column', function () {
      handsontable({
        data: arrayOfObjects()
      });

      expect(getDataAtRowProp(1, 'id.a.b.c')).toBe(2);
      expect(getDataAtRowProp(1, 'id')).toBe(2);
      expect(getDataAtRowProp(1, 'id')).toBe(2);
      expect(getDataAtRowProp(1, 'details.city')).toBe('New York');
    });
  });

  describe('`modifyData` hook', function () {
    it('should be fired with specified arguments on every `set`, `get` operation (array of arrays)', function () {
      var spy = jasmine.createSpy();

      handsontable({
        data: arrayOfArrays(),
        autoColumnSize: false,
        modifyData: spy
      });

      expect(spy.calls.count()).toBe(20); // call for all cells
      expect(spy.calls.argsFor(1)[0]).toBe(0);
      expect(spy.calls.argsFor(1)[1]).toBe(1);
      expect(spy.calls.argsFor(1)[2].value).toBe('Kia');
      expect(spy.calls.argsFor(1)[3]).toBe('get');

      spy.calls.reset();
      setDataAtCell(2, 3, 'foo');

      expect(spy.calls.count()).toBe(21); // call for all cells + 1 from setDataAtCell
      expect(spy.calls.argsFor(0)[0]).toBe(2);
      expect(spy.calls.argsFor(0)[1]).toBe(3);
      expect(spy.calls.argsFor(0)[2].value).toBe('foo');
      expect(spy.calls.argsFor(0)[3]).toBe('set');
    });

    it('should be fired with specified arguments on every `set`, `get` operation (array of objects)', function () {
      var spy = jasmine.createSpy();

      handsontable({
        data: arrayOfObjects(),
        autoColumnSize: false,
        modifyData: spy
      });

      expect(spy.calls.count()).toBe(10); // call for all cells
      expect(spy.calls.argsFor(2)[0]).toBe(0);
      expect(spy.calls.argsFor(2)[1]).toBe(2);
      expect(spy.calls.argsFor(2)[2].value).toBe('Nannie Patel');
      expect(spy.calls.argsFor(2)[3]).toBe('get');

      spy.calls.reset();
      setDataAtRowProp(2, 'name', 'foo');

      expect(spy.calls.count()).toBe(16);
      expect(spy.calls.argsFor(0)[0]).toBe(2);
      expect(spy.calls.argsFor(0)[1]).toBe(2);
      expect(spy.calls.argsFor(0)[2].value).toBe('foo');
      expect(spy.calls.argsFor(0)[3]).toBe('set');
    });

    it('should overwrite value while loading data', function () {
      handsontable({
        data: arrayOfArrays(),
        modifyData: function modifyData(row, column, valueHolder, ioMode) {
          if (ioMode === 'get' && row === 1 && column === 2) {
            valueHolder.value = 'foo';
          }
        }
      });

      expect(getDataAtCell(1, 2)).toBe('foo');
      expect(getSourceDataAtCell(1, 2)).toBe(11);
    });

    it('should overwrite value while saving data', function () {
      handsontable({
        data: arrayOfArrays(),
        modifyData: function modifyData(row, column, valueHolder, ioMode) {
          if (ioMode === 'set' && row === 1 && column === 2) {
            valueHolder.value = 'foo';
          }
        }
      });

      setDataAtCell(1, 2, 'bar');

      expect(getDataAtCell(1, 2)).toBe('foo');
      expect(getSourceDataAtCell(1, 2)).toBe('foo');
    });
  });
});

/***/ }),
/* 162 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_getDataType', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  var arrayOfArrays = function arrayOfArrays() {
    return [['', 'Kia', 'Nissan', 'Toyota', 'Honda'], ['2008', 10, 11, 12, 13], ['2009', 20, 11, 14, 13], ['2010', 30, 15, 12, 13]];
  };

  it('should return data type at specyfied range (default type)', function () {
    handsontable({
      data: arrayOfArrays()
    });

    expect(getDataType(0, 0)).toEqual('text');
    expect(getDataType(0, 0, 1, 1)).toEqual('text');
  });

  it('should return data type at specyfied range (type defined in columns)', function () {
    handsontable({
      data: arrayOfArrays(),
      columns: [{ type: 'numeric' }, { type: 'text' }, { type: 'date' }, { type: 'autocomplete' }, { type: 'dropdown' }]
    });

    expect(getDataType(0, 0)).toEqual('numeric');
    expect(getDataType(0, 0, 1, 1)).toEqual('mixed');
    expect(getDataType(0, 1, 1, 1)).toEqual('text');
    expect(getDataType(0, 2, 1, 2)).toEqual('date');
    expect(getDataType(3, 3, 3, 3)).toEqual('autocomplete');
    expect(getDataType(3, 4, 3, 4)).toEqual('dropdown');
  });

  it('should return data type at specyfied range (type defined in columns) when columns is a function', function () {
    handsontable({
      data: arrayOfArrays(),
      columns: function columns(column) {
        var colMeta = {};

        if (column === 0) {
          colMeta.type = 'numeric';
        } else if (column === 1) {
          colMeta.type = 'text';
        } else if (column === 2) {
          colMeta.type = 'date';
        } else if (column === 3) {
          colMeta.type = 'autocomplete';
        } else if (column === 4) {
          colMeta.type = 'dropdown';
        } else {
          colMeta = null;
        }

        return colMeta;
      }
    });

    expect(getDataType(0, 0)).toEqual('numeric');
    expect(getDataType(0, 0, 1, 1)).toEqual('mixed');
    expect(getDataType(0, 1, 1, 1)).toEqual('text');
    expect(getDataType(0, 2, 1, 2)).toEqual('date');
    expect(getDataType(3, 3, 3, 3)).toEqual('autocomplete');
    expect(getDataType(3, 4, 3, 4)).toEqual('dropdown');
  });

  it('should return data type at specyfied range (type defined in cells)', function () {
    handsontable({
      data: arrayOfArrays(),
      cells: function cells(row, column) {
        var cellMeta = {};

        if (row === 1 && column === 1) {
          cellMeta.type = 'date';
        }
        if (column === 2) {
          cellMeta.type = 'checkbox';
        }

        return cellMeta;
      }
    });

    expect(getDataType(0, 0)).toEqual('text');
    expect(getDataType(1, 1)).toEqual('date');
    expect(getDataType(1, 2)).toEqual('checkbox');
    expect(getDataType(0, 0, 1, 1)).toEqual('mixed');
  });
});

/***/ }),
/* 163 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.getRowHeader', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('when not configured, should return undefined', function () {
    handsontable();
    expect(getRowHeader(1)).toEqual(void 0);
  });

  it('when configured as true, should return the index incremented by 1', function () {
    handsontable({
      rowHeaders: true
    });
    expect(getRowHeader(1)).toEqual(2);
  });

  it('when configured as array, should return value at index', function () {
    handsontable({
      rowHeaders: ['One', 'Two', 'Three', 'Four', 'Five']
    });
    expect(getRowHeader(1)).toEqual('Two');
  });

  it('when configured as function, should return function output', function () {
    handsontable({
      rowHeaders: function rowHeaders(index) {
        return 'row' + index;
      }
    });
    expect(getRowHeader(1)).toEqual('row1');
  });

  it('when configured as static value, should return the value', function () {
    handsontable({
      rowHeaders: 'static'
    });
    expect(getRowHeader(1)).toEqual('static');
  });

  it('when configured as HTML value, should render that as HTML', function () {
    handsontable({
      rowHeaders: function rowHeaders(index) {
        return '<b>row' + index + '</b>';
      }
    });
    expect(getRowHeader(1)).toEqual('<b>row1</b>');
  });

  it('when no argument given, should return as much row headers as there are rows', function () {
    handsontable({
      rowHeaders: true,
      startRows: 3
    });
    expect(getRowHeader()).toEqual([1, 2, 3]);
  });
});

/***/ }),
/* 164 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_init', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should respect startRows and startCols when no data is provided', function () {
    this.$container.remove();
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
    handsontable();

    expect(countRows()).toEqual(5); // as given in README.md
    expect(countCols()).toEqual(5); // as given in README.md
  });

  it('should respect width provided in inline style', function () {
    this.$container.css({
      overflow: 'auto',
      width: '200px'
    });
    handsontable({
      data: [['ABC', 'ABC', 'ABC', 'ABC', 'ABC', 'ABC', 'ABC', 'ABC', 'ABC']]
    });

    expect(this.$container.width()).toEqual(200);
  });

  it('should respect width provided in CSS class', function () {
    $('<style>.myTable {overflow: auto; width: 200px}</style>').appendTo('head');
    this.$container.addClass('myTable');
    handsontable({
      data: [['ABC', 'ABC', 'ABC', 'ABC', 'ABC', 'ABC', 'ABC', 'ABC', 'ABC']]
    });

    expect(this.$container.width()).toEqual(200);
  });

  it('should construct when container is not appended to document', function () {
    this.$container.remove();
    handsontable();
    expect(getData()).toBeTruthy();
  });

  it('Handsontable.Dom should be available as a helper to the plugins', function () {
    // all public methods of Handsontable.Dom should be exposed here
    expect(Handsontable.dom.closest).toBeDefined();
    expect(Handsontable.dom.isChildOf).toBeDefined();
    expect(Handsontable.dom.index).toBeDefined();
    expect(Handsontable.dom.hasClass).toBeDefined();
    expect(Handsontable.dom.addClass).toBeDefined();
    expect(Handsontable.dom.removeClass).toBeDefined();
    expect(Handsontable.dom.removeTextNodes).toBeDefined();
    expect(Handsontable.dom.empty).toBeDefined();
    expect(Handsontable.dom.fastInnerHTML).toBeDefined();
    expect(Handsontable.dom.fastInnerText).toBeDefined();
    expect(Handsontable.dom.isVisible).toBeDefined();
    expect(Handsontable.dom.offset).toBeDefined();
    expect(Handsontable.dom.getComputedStyle).toBeDefined();
    expect(Handsontable.dom.outerWidth).toBeDefined();
    expect(Handsontable.dom.outerHeight).toBeDefined();
    expect(Handsontable.dom.getCaretPosition).toBeDefined();
    expect(Handsontable.dom.setCaretPosition).toBeDefined();
  });
});

/***/ }),
/* 165 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.isEmpty*', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  describe('isEmptyRow', function () {
    it('should be empty row', function () {
      handsontable();
      var hot = getInstance();
      expect(hot.isEmptyRow(0)).toEqual(true);
    });

    it('should not be empty row', function () {
      handsontable();
      setDataAtCell(0, 0, 'test');
      var hot = getInstance();
      expect(hot.isEmptyRow(0)).toEqual(false);
    });

    it('should bind this to instance', function () {
      handsontable();
      var hot = getInstance();
      var check = hot.isEmptyRow;
      expect(check(0)).toEqual(true); // this may be change in future when we switch to define isEmptyCol in prototype
    });
  });

  describe('isEmptyCol', function () {
    it('should be empty row', function () {
      handsontable();
      var hot = getInstance();
      expect(hot.isEmptyCol(0)).toEqual(true);
    });

    it('should not be empty row', function () {
      handsontable();
      setDataAtCell(0, 0, 'test');
      var hot = getInstance();
      expect(hot.isEmptyCol(0)).toEqual(false);
    });

    it('should bind this to instance', function () {
      handsontable();
      var hot = getInstance();
      var check = hot.isEmptyCol;
      expect(check(0)).toEqual(true); // this may be change in future when we switch to define isEmptyCol in prototype
    });
  });
});

/***/ }),
/* 166 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_keepEmptyRows', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  var arrayOfNestedObjects = function arrayOfNestedObjects() {
    return [{ id: 1,
      name: {
        first: 'Ted',
        last: 'Right'
      },
      address: 'Street Name',
      zip: '80410',
      city: 'City Name' }, { id: 2,
      name: {
        first: 'Frank',
        last: 'Honest'
      },
      address: 'Street Name',
      zip: '80410',
      city: 'City Name' }, { id: 3,
      name: {
        first: 'Joan',
        last: 'Well'
      },
      address: 'Street Name',
      zip: '80410',
      city: 'City Name' }];
  };

  it('should remove columns if needed', function () {
    handsontable({
      data: arrayOfNestedObjects(),
      columns: [{ data: 'id' }, { data: 'name.first' }]
    });

    expect(this.$container.find('tbody tr:first td').length).toEqual(2);
  });

  it('should remove columns if needed when columns is a function', function () {
    handsontable({
      data: arrayOfNestedObjects(),
      columns: function columns(column) {
        var colMeta = {};

        if (column === 0) {
          colMeta.data = 'id';
        } else if (column === 1) {
          colMeta.data = 'name.first';
        } else {
          colMeta = null;
        }

        return colMeta;
      }
    });

    expect(this.$container.find('tbody tr:first td').length).toEqual(2);
  });

  it('should create columns if needed', function () {
    handsontable({
      data: arrayOfNestedObjects(),
      columns: [{ data: 'id' }, { data: 'name.first' }, { data: 'name.last' }, { data: 'address' }, { data: 'zip' }, { data: 'city' }]
    });

    expect(this.$container.find('tbody tr:first td').length).toEqual(6);
  });

  it('should create columns if needed when columns is a function', function () {
    handsontable({
      data: arrayOfNestedObjects(),
      columns: function columns(column) {
        var colMeta = {};

        if (column === 0) {
          colMeta.data = 'id';
        } else if (column === 1) {
          colMeta.data = 'name.first';
        } else if (column === 2) {
          colMeta.data = 'name.last';
        } else if (column === 3) {
          colMeta.data = 'address';
        } else if (column === 4) {
          colMeta.data = 'zip';
        } else if (column === 5) {
          colMeta.data = 'city';
        } else {
          colMeta = null;
        }

        return colMeta;
      }
    });

    expect(this.$container.find('tbody tr:first td').length).toEqual(6);
  });

  it('should create spare cols and rows on init (array data source)', function () {
    handsontable({
      data: [['one', 'two'], ['three', 'four']],
      minCols: 4,
      minRows: 4,
      minSpareRows: 4,
      minSpareCols: 4
    });

    expect(countCells()).toEqual(36);
  });

  it('should create spare cols and rows on init (object data source)', function () {
    handsontable({
      data: arrayOfNestedObjects(),
      minRows: 4,
      minSpareRows: 1
    });

    expect(countRows()).toEqual(4);
    expect(countCols()).toEqual(6); // because arrayOfNestedObjects has 6 nested properites and they should be figured out if dataSchema/columns is not given
    expect(this.$container.find('tbody tr:first td:last').text()).toEqual('City Name');
  });

  it('should create new row when last cell in last row is edited', function () {
    var data = [['one', 'two'], ['three', 'four']];

    handsontable({
      data: data,
      minRows: 4,
      minCols: 4,
      minSpareRows: 1
    });
    setDataAtCell(3, 3, 'test');

    expect(data.length).toEqual(5);
  });

  it('should create new col when last cell in last row is edited', function () {
    var data = [['one', 'two'], ['three', 'four']];

    handsontable({
      data: data,
      minRows: 4,
      minCols: 4,
      minSpareCols: 1
    });
    setDataAtCell(3, 3, 'test');

    expect(countCols()).toEqual(5);
  });

  it('should create new row when last cell in last row is edited by autocomplete', function (done) {
    var data = [{ id: 1, color: 'orange' }];

    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process(['red', 'dark-yellow', 'yellow', 'light-yellow', 'black']);
    });

    handsontable({
      data: data,
      startRows: 5,
      colHeaders: true,
      minSpareRows: 1,
      columns: [{ data: 'id', type: 'text' }, {
        data: 'color',
        editor: 'autocomplete',
        source: syncSources
      }]
    });

    selectCell(1, 1);
    keyDownUp('enter');

    setTimeout(function () {
      keyDown('arrow_down');
      keyDownUp('enter');

      expect(data.length).toEqual(3);
      done();
    }, 200);
  });

  it('should create new row when last cell in last row is edited by autocomplete when columns is a function', function (done) {
    var data = [{ id: 1, color: 'orange' }];

    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process(['red', 'dark-yellow', 'yellow', 'light-yellow', 'black']);
    });

    handsontable({
      data: data,
      startRows: 5,
      colHeaders: true,
      minSpareRows: 1,
      columns: function columns(column) {
        var colMeta = {};

        if (column === 0) {
          colMeta.data = 'id';
          colMeta.type = 'text';
        } else if (column === 1) {
          colMeta.data = 'color';
          colMeta.editor = 'autocomplete';
          colMeta.source = syncSources;
        } else {
          colMeta = null;
        }

        return colMeta;
      }
    });

    selectCell(1, 1);
    keyDownUp('enter');

    setTimeout(function () {
      keyDown('arrow_down');
      keyDownUp('enter');

      expect(data.length).toEqual(3);
      done();
    }, 200);
  });

  it('should not create more rows that maxRows', function () {
    handsontable({
      startRows: 4,
      maxRows: 6,
      minSpareRows: 1
    });
    setDataAtCell(3, 0, 'test');
    setDataAtCell(4, 0, 'test');
    setDataAtCell(5, 0, 'test');

    expect(countRows()).toEqual(6);
  });

  it('should not create more cols that maxCols', function () {
    handsontable({
      startCols: 4,
      maxCols: 6,
      minSpareCols: 1
    });
    setDataAtCell(0, 3, 'test');
    setDataAtCell(0, 4, 'test');
    setDataAtCell(0, 5, 'test');

    expect(countCols()).toEqual(6);
  });

  it('should ignore minCols if columns is set', function () {
    handsontable({
      startCols: 1,
      minCols: 6,
      columns: [{}, {}]
    });

    expect(countCols()).toEqual(2);
  });

  it('should ignore minCols if columns is set when columns is a function', function () {
    handsontable({
      startCols: 1,
      minCols: 6,
      columns: function columns(column) {
        var colMeta = {};

        if ([0, 1].indexOf(column) < 0) {
          colMeta = null;
        }

        return colMeta;
      }
    });

    expect(countCols()).toEqual(1);
  });

  it('columns should have priority over startCols', function () {
    handsontable({
      startCols: 3,
      minCols: 6,
      columns: [{}, {}]
    });

    expect(countCols()).toEqual(2);
  });

  it('columns should have priority over startCols when columns is a function', function () {
    handsontable({
      startCols: 3,
      minCols: 6,
      columns: function columns(column) {
        var colMeta = {};

        if ([0, 1].indexOf(column) < 0) {
          colMeta = null;
        }

        return colMeta;
      }
    });

    expect(countCols()).toEqual(2);
  });
});

/***/ }),
/* 167 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_listen', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should listen to changes when cell is selected', function () {
    var hot = handsontable();
    hot.selectCell(0, 0);
    expect(hot.isListening()).toEqual(true);
  });

  it('should\'t listen to changes when cell is selected via `selectCell` when `changeListener` argument is `false`', function () {
    var hot = handsontable();

    hot.unlisten();

    expect(hot.isListening()).toEqual(false);

    hot.selectCell(0, 0, undefined, undefined, true, false);

    expect(hot.isListening()).toEqual(false);
  });

  it('should unlisten changes', function () {
    var hot = handsontable();
    hot.selectCell(0, 0);
    expect(hot.isListening()).toEqual(true);
    hot.unlisten();
    expect(hot.isListening()).toEqual(false);
  });

  it('should listen to changes, when called after unlisten', function () {
    var hot = handsontable();
    hot.selectCell(0, 0);
    hot.unlisten();
    hot.listen();
    expect(hot.isListening()).toEqual(true);
  });

  it('when second instance is created, first should unlisten automatically', function () {
    var $container1 = $('<div id="hot1"></div>').appendTo('body').handsontable();
    $container1.handsontable('selectCell', 0, 0);
    var $container2 = $('<div id="hot2"></div>').appendTo('body').handsontable();
    $container2.handsontable('selectCell', 0, 0);

    expect($container1.handsontable('isListening')).toEqual(false);
    expect($container2.handsontable('isListening')).toEqual(true);

    $container1.handsontable('destroy');
    $container1.remove();
    $container2.handsontable('destroy');
    $container2.remove();
  });

  it('when listen is called on first instance, second should unlisten automatically', function () {
    var $container1 = $('<div id="hot1"></div>').appendTo('body').handsontable();
    $container1.handsontable('selectCell', 0, 0);
    var $container2 = $('<div id="hot2"></div>').appendTo('body').handsontable();
    $container2.handsontable('selectCell', 0, 0);

    $container1.handsontable('listen');
    expect($container1.handsontable('isListening')).toEqual(true);
    expect($container2.handsontable('isListening')).toEqual(false);

    $container1.handsontable('destroy');
    $container1.remove();
    $container2.handsontable('destroy');
    $container2.remove();
  });
});

/***/ }),
/* 168 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_loadData', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  var arrayOfArrays = function arrayOfArrays() {
    return [['', 'Kia', 'Nissan', 'Toyota', 'Honda'], ['2008', 10, 11, 12, 13], ['2009', 20, 11, 14, 13], ['2010', 30, 15, 12, 13]];
  };

  var arrayOfObjects = function arrayOfObjects() {
    return [{ id: 1, name: 'Ted', lastName: 'Right' }, { id: 2, name: 'Frank', lastName: 'Honest' }, { id: 3, name: 'Joan', lastName: 'Well' }, { id: 4, name: 'Sid', lastName: 'Strong' }, { id: 5, name: 'Jane', lastName: 'Neat' }, { id: 6, name: 'Chuck', lastName: 'Jackson' }, { id: 7, name: 'Meg', lastName: 'Jansen' }, { id: 8, name: 'Rob', lastName: 'Norris' }, { id: 9, name: 'Sean', lastName: 'O\'Hara' }, { id: 10, name: 'Eve', lastName: 'Branson' }];
  };

  var arrayOfNestedObjects = function arrayOfNestedObjects() {
    return [{
      id: 1,
      name: {
        first: 'Ted',
        last: 'Right'
      },
      'full.street': 'Street I'
    }, {
      id: 2,
      name: {
        first: 'Frank',
        last: 'Honest'
      },
      'full.street': 'Street II'
    }, {
      id: 3,
      name: {
        first: 'Joan',
        last: 'Well'
      },
      'full.street': 'Street III'
    }];
  };

  var htmlData = [['<b>H&M</b>']];

  it('should allow array of arrays', function () {
    handsontable();
    loadData(arrayOfArrays());
    expect(getDataAtCell(0, 2)).toEqual('Nissan');
  });

  it('should allow array of objects', function () {
    handsontable({
      columns: [{ data: 'id' }, { data: 'lastName' }, { data: 'name' }]
    });
    loadData(arrayOfObjects());
    expect(getDataAtCell(0, 2)).toEqual('Ted');
  });

  it('should allow array of objects when columns as a function', function () {
    handsontable({
      columns: function columns(column) {
        var colMeta = {};

        if (column === 0) {
          colMeta.data = 'id';
        } else if (column === 1) {
          colMeta.data = 'lastName';
        } else if (column === 2) {
          colMeta.data = 'name';
        } else {
          colMeta = null;
        }

        return colMeta;
      }
    });
    loadData(arrayOfObjects());
    expect(getDataAtCell(0, 2)).toEqual('Ted');
  });

  it('should allow array of nested objects', function () {
    handsontable({
      data: arrayOfNestedObjects(),
      colHeaders: true,
      columns: [{ data: 'id' }, { data: 'name.last' }, { data: 'name.first' }, { data: 'full.street' }]
    });
    expect(getDataAtCell(0, 2)).toEqual('Ted');
    expect(getDataAtCell(1, 3)).toEqual('Street II');
    expect(getDataAtRowProp(2, 'full.street')).toEqual('Street III');
  });

  it('should allow array of nested objects when columns as a function', function () {
    handsontable({
      data: arrayOfNestedObjects(),
      colHeaders: true,
      columns: function columns(column) {
        var colMeta = {};

        if (column === 0) {
          colMeta.data = 'id';
        } else if (column === 1) {
          colMeta.data = 'name.last';
        } else if (column === 2) {
          colMeta.data = 'name.first';
        } else if (column === 3) {
          colMeta.data = 'full.street';
        } else {
          colMeta = null;
        }

        return colMeta;
      }
    });
    expect(getDataAtCell(0, 2)).toEqual('Ted');
    expect(getDataAtCell(1, 3)).toEqual('Street II');
    expect(getDataAtRowProp(2, 'full.street')).toEqual('Street III');
  });

  it('should figure out default column names for array of nested objects', function () {
    handsontable({
      data: arrayOfNestedObjects(),
      colHeaders: true
    });
    expect(getDataAtCell(0, 2)).toEqual('Right');
  });

  it('should trigger onChange callback when loaded array of arrays', function () {
    var called = false;

    handsontable({
      afterChange: function afterChange(changes, source) {
        if (source === 'loadData') {
          called = true;
        }
      }
    });
    loadData(arrayOfArrays());

    expect(called).toEqual(true);
  });

  it('should trigger onChange callback when loaded array of objects', function () {
    var called = false;

    handsontable({
      afterChange: function afterChange(changes, source) {
        if (source === 'loadData') {
          called = true;
        }
      }
    });
    loadData(arrayOfObjects());

    expect(called).toEqual(true);
  });

  it('should trigger onChange callback when loaded array of nested objects', function () {
    var called = false;

    handsontable({
      afterChange: function afterChange(changes, source) {
        if (source === 'loadData') {
          called = true;
        }
      }
    });
    loadData(arrayOfNestedObjects());

    expect(called).toEqual(true);
  });

  it('should create new rows for array of arrays (and respect minRows)', function () {
    handsontable({
      minRows: 20, // minRows should be respected
      data: arrayOfArrays()
    });

    expect(countRows()).toEqual(20); // TODO why this must be checked after render?
  });

  it('should create new rows for array of nested objects (and respect minRows)', function () {
    handsontable({
      minRows: 20, // minRows should be respected
      data: arrayOfNestedObjects()
    });

    expect(countRows()).toEqual(20); // TODO why this must be checked after render?
  });

  it('HTML special chars should be escaped by default', function () {
    handsontable();
    loadData(htmlData);

    expect(getCell(0, 0).innerHTML).toEqual('&lt;b&gt;H&amp;M&lt;/b&gt;');
  });

  it('should create as many rows as needed by array of objects', function () {
    handsontable({
      minRows: 6,
      data: arrayOfObjects()
    });

    expect(getCell(9, 1).innerHTML).toEqual('Eve');
  });

  // https://github.com/handsontable/handsontable/pull/233
  it('should not invoke the cells callback multiple times with the same row/col (without overlays)', function () {
    var cellsSpy = jasmine.createSpy('cellsSpy');

    handsontable({
      data: arrayOfNestedObjects(),
      colWidths: [90, 90, 90, 90],
      rowHeights: [23, 23, 23, 23],
      cells: cellsSpy
    });
    //
    expect(cellsSpy.calls.count()).toEqual(43);
  });

  it('should not invoke the cells callback multiple times with the same row/col (with overlays)', function () {
    var cellsSpy = jasmine.createSpy('cellsSpy');

    handsontable({
      data: arrayOfNestedObjects(),
      colHeaders: true,
      rowHeaders: true,
      colWidths: [90, 90, 90, 90],
      rowHeights: [90, 90, 90, 90],
      cells: cellsSpy
    });

    expect(cellsSpy.calls.count()).toEqual(56);
  });

  it('should remove grid rows if new data source has less of them', function () {
    var data1 = [['a'], ['b'], ['c'], ['d'], ['e'], ['f'], ['g'], ['h']];

    var data2 = [['a'], ['b'], ['c'], ['d'], ['e']];

    handsontable({
      data: data1,
      rowHeaders: true,
      colHeaders: true
    });
    selectCell(7, 0);
    loadData(data2);

    expect(countRows()).toBe(data2.length);
    expect(getSelected()).toEqual([4, 0, 4, 0]);
  });

  it('should remove grid rows if new data source has less of them (with minSpareRows)', function () {
    var data1 = [['a'], ['b'], ['c'], ['d'], ['e'], ['f'], ['g'], ['h']];
    var data2 = [['a'], ['b'], ['c'], ['d'], ['e']];

    handsontable({
      data: data1,
      minSpareCols: 1,
      minSpareRows: 1,
      rowHeaders: true,
      colHeaders: true
    });
    selectCell(8, 0);
    loadData(data2);

    expect(countRows()).toBe(6); // +1 because of minSpareRows
    expect(getSelected()).toEqual([5, 0, 5, 0]);
  });

  it('loading empty data should remove all rows', function () {
    var data1 = [['a'], ['b'], ['c'], ['d'], ['e'], ['f'], ['g'], ['h']];

    var data2 = [];

    handsontable({
      data: data1,
      rowHeaders: true,
      colHeaders: true
    });
    selectCell(7, 0);
    loadData(data2);

    expect(countRows()).toBe(0);
    expect(getSelected()).toBe(void 0);
  });

  it('should only have as many columns as in settings', function () {
    var data1 = arrayOfArrays();

    handsontable({
      data: data1,
      columns: [{ data: 1 }, { data: 3 }]
    });

    expect(countCols()).toBe(2);
  });

  it('should only have as many columns as in settings when columns is a function', function () {
    var data1 = arrayOfArrays();

    handsontable({
      data: data1,
      columns: function columns(column) {
        var colMeta = {
          data: column
        };

        if ([1, 3].indexOf(column) < 0) {
          colMeta = null;
        }

        return colMeta;
      }
    });

    expect(countCols()).toBe(2);
  });

  it('should throw error when trying to load a string (constructor)', function () {
    var errors = 0;

    try {
      handsontable({
        data: 'string'
      });
    } catch (e) {
      errors++;
    }

    expect(errors).toBe(1);
  });

  it('should throw error when trying to load a string (loadData)', function () {
    var errors = 0;

    try {
      handsontable();
      loadData('string');
    } catch (e) {
      errors++;
    }

    expect(errors).toBe(1);
  });

  it('should load Backbone Collection as data source', function () {
    // code borrowed from demo/backbone.js

    var CarModel = Backbone.Model.extend({});

    var CarCollection = Backbone.Collection.extend({
      model: CarModel,
      // Backbone.Collection doesn't support `splice`, yet! Easy to add.
      splice: hackedSplice
    });
    var cars = new CarCollection();

    cars.add([{ make: 'Dodge', model: 'Ram', year: 2012, weight: 6811 }, { make: 'Toyota', model: 'Camry', year: 2012, weight: 3190 }, { make: 'Smart', model: 'Fortwo', year: 2012, weight: 1808 }]);

    handsontable({
      data: cars,
      columns: [attr('make'), attr('model'), attr('year')]
    });

    // use the "good" Collection methods to emulate Array.splice
    function hackedSplice(index, howMany /* model1, ... modelN */) {
      var args = _.toArray(arguments).slice(2).concat({ at: index }),
          removed = this.models.slice(index, index + howMany);
      this.remove(removed).add.apply(this, args);

      return removed;
    }

    // normally, you'd get these from the server with .fetch()
    function attr(attr) {
      // this lets us remember `attr` for when when it is get/set
      return {
        data: function data(car, value) {
          if (_.isUndefined(value)) {
            return car.get(attr);
          }
          car.set(attr, value);
        }
      };
    }

    expect(countRows()).toBe(3);
  });

  it('should load Backbone Collection as data source when columns is a function', function () {
    // code borrowed from demo/backbone.js

    var CarModel = Backbone.Model.extend({});

    var CarCollection = Backbone.Collection.extend({
      model: CarModel,
      // Backbone.Collection doesn't support `splice`, yet! Easy to add.
      splice: hackedSplice
    });
    var cars = new CarCollection();

    cars.add([{ make: 'Dodge', model: 'Ram', year: 2012, weight: 6811 }, { make: 'Toyota', model: 'Camry', year: 2012, weight: 3190 }, { make: 'Smart', model: 'Fortwo', year: 2012, weight: 1808 }]);

    handsontable({
      data: cars,
      columns: function columns(column) {
        var colMeta = null;

        if (column === 0) {
          colMeta = attr('make');
        } else if (column === 1) {
          colMeta = attr('model');
        } else if (column === 2) {
          colMeta = attr('year');
        }

        return colMeta;
      }
    });

    // use the "good" Collection methods to emulate Array.splice
    function hackedSplice(index, howMany /* model1, ... modelN */) {
      var args = _.toArray(arguments).slice(2).concat({ at: index }),
          removed = this.models.slice(index, index + howMany);
      this.remove(removed).add.apply(this, args);

      return removed;
    }

    // normally, you'd get these from the server with .fetch()
    function attr(attr) {
      // this lets us remember `attr` for when when it is get/set
      return {
        data: function data(car, value) {
          if (_.isUndefined(value)) {
            return car.get(attr);
          }

          car.set(attr, value);
        }
      };
    }

    expect(countRows()).toBe(3);
  });

  it('should clear cell properties after loadData', function () {
    handsontable();
    loadData(arrayOfArrays());

    getCellMeta(0, 0).foo = 'bar';

    expect(getCellMeta(0, 0).foo).toEqual('bar');

    loadData(arrayOfArrays());

    expect(getCellMeta(0, 0).foo).toBeUndefined();
  });

  it('should clear cell properties after loadData, but before rendering new data', function () {
    handsontable();
    loadData(arrayOfArrays());

    getCellMeta(0, 0).valid = false;
    render();

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').hasClass('htInvalid')).toEqual(true);

    loadData(arrayOfArrays());

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').hasClass('htInvalid')).toEqual(false);
  });

  // https://github.com/handsontable/handsontable/issues/1700
  // can't edit anything after starting editing cell with no nested object
  it('should correct behave with cell with no nested object data source corresponding to column mapping', function () {

    var objectData = [{ id: 1, user: { name: { first: 'Ted', last: 'Right' } } }, { id: 2, user: { name: {} } }, { id: 3 }];

    handsontable({
      data: objectData,
      columns: [{ data: 'id' }, { data: 'user.name.first' }, { data: 'user.name.last' }]
    });

    mouseDoubleClick(getCell(1, 1));
    document.activeElement.value = 'Harry';
    deselectCell();
    expect(objectData[1].user.name.first).toEqual('Harry');

    mouseDoubleClick(getCell(2, 1));
    document.activeElement.value = 'Barry';
    deselectCell();
    expect(objectData[2].user.name.first).toEqual('Barry');
  });

  it('should correct behave with cell with no nested object data source corresponding to column mapping when columns is a function', function () {

    var objectData = [{ id: 1, user: { name: { first: 'Ted', last: 'Right' } } }, { id: 2, user: { name: {} } }, { id: 3 }];

    handsontable({
      data: objectData,
      columns: function columns(column) {
        var colMeta = null;

        if (column === 0) {
          colMeta = { data: 'id' };
        } else if (column === 1) {
          colMeta = { data: 'user.name.first' };
        } else if (column === 2) {
          colMeta = { data: 'user.name.last' };
        }

        return colMeta;
      }
    });

    mouseDoubleClick(getCell(1, 1));
    document.activeElement.value = 'Harry';
    deselectCell();
    expect(objectData[1].user.name.first).toEqual('Harry');

    mouseDoubleClick(getCell(2, 1));
    document.activeElement.value = 'Barry';
    deselectCell();
    expect(objectData[2].user.name.first).toEqual('Barry');
  });
});

/***/ }),
/* 169 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_navigation', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should move to the next cell', function () {
    handsontable({
      startRows: 5,
      startCols: 5
    });

    selectCell(0, 0);
    keyDown('arrow_right');

    expect(getSelected()).toEqual([0, 1, 0, 1]);
  });

  it('should move to the previous cell', function () {
    handsontable({
      startRows: 5,
      startCols: 5
    });

    selectCell(1, 2);
    keyDown('arrow_left');

    expect(getSelected()).toEqual([1, 1, 1, 1]);
  });

  it('should move to the cell above', function () {
    handsontable({
      startRows: 5,
      startCols: 5
    });

    selectCell(1, 2);
    keyDown('arrow_up');

    expect(getSelected()).toEqual([0, 2, 0, 2]);
  });

  it('should move to the cell below', function () {
    handsontable({
      startRows: 5,
      startCols: 5
    });

    selectCell(1, 2);
    keyDown('arrow_down');

    expect(getSelected()).toEqual([2, 2, 2, 2]);
  });

  describe('autoWrap disabled', function () {
    it('should NOT move to the next cell, if already at the last cell in row', function () {
      handsontable({
        startRows: 5,
        startCols: 5,
        autoWrapRow: false
      });

      selectCell(0, 4);
      keyDown('arrow_right');

      expect(getSelected()).toEqual([0, 4, 0, 4]);
    });

    it('should NOT move to the previous cell, if already at the first cell in row', function () {
      handsontable({
        startRows: 5,
        startCols: 5,
        autoWrapRow: false
      });

      selectCell(1, 0);
      keyDown('arrow_left');

      expect(getSelected()).toEqual([1, 0, 1, 0]);
    });

    it('should NOT move to the cell below, if already at the last cell in column', function () {
      handsontable({
        startRows: 5,
        startCols: 5,
        autoWrapCol: false
      });

      selectCell(4, 0);
      keyDown('arrow_down');

      expect(getSelected()).toEqual([4, 0, 4, 0]);
    });

    it('should NOT move to the cell above, if already at the first cell in column', function () {
      handsontable({
        startRows: 5,
        startCols: 5,
        autoWrapCol: false
      });

      selectCell(0, 1);
      keyDown('arrow_up');

      expect(getSelected()).toEqual([0, 1, 0, 1]);
    });
  });

  describe('autoWrap enabled', function () {
    it('should move to the first cell of the next row, if already at the last cell in row', function () {
      handsontable({
        startRows: 5,
        startCols: 5,
        autoWrapRow: true
      });

      selectCell(0, 4);
      keyDown('arrow_right');

      expect(getSelected()).toEqual([1, 0, 1, 0]);
    });

    it('should move to the first cell of the previous row, if already at the first cell in row', function () {
      handsontable({
        startRows: 5,
        startCols: 5,
        autoWrapRow: true
      });

      selectCell(1, 0);
      keyDown('arrow_left');

      expect(getSelected()).toEqual([0, 4, 0, 4]);
    });

    it('should move to the first cell of the next column, if already at the last cell in column', function () {
      handsontable({
        startRows: 5,
        startCols: 5,
        autoWrapCol: true
      });

      selectCell(4, 1);
      keyDown('arrow_down');

      expect(getSelected()).toEqual([0, 2, 0, 2]);
    });

    it('should move to the last cell of the previous column, if already at the first cell in column', function () {
      handsontable({
        startRows: 5,
        startCols: 5,
        autoWrapCol: true
      });

      selectCell(0, 1);
      keyDown('arrow_up');

      expect(getSelected()).toEqual([4, 0, 4, 0]);
    });

    it('should move to the first cell of the first row, after trying to get to the next cell in row, being already at the last cell in table', function () {
      handsontable({
        startRows: 5,
        startCols: 5,
        autoWrapRow: true
      });

      selectCell(4, 4);
      keyDown('arrow_right');

      expect(getSelected()).toEqual([0, 0, 0, 0]);
    });

    it('should move to the first cell of the first row, after trying to get to the next cell in column, being already at the last cell in table', function () {
      handsontable({
        startRows: 5,
        startCols: 5,
        autoWrapCol: true
      });

      selectCell(4, 4);
      keyDown('arrow_down');

      expect(getSelected()).toEqual([0, 0, 0, 0]);
    });

    it('should move to the last cell of the last row, after trying to get to the previous cell in row, being already at the first cell in table', function () {
      handsontable({
        startRows: 5,
        startCols: 5,
        autoWrapRow: true
      });

      selectCell(0, 0);
      keyDown('arrow_left');

      expect(getSelected()).toEqual([4, 4, 4, 4]);
    });

    it('should move to the last cell of the last row, after trying to get to the previous cell in column, being already at the first cell in table', function () {
      handsontable({
        startRows: 5,
        startCols: 5,
        autoWrapCol: true
      });

      selectCell(0, 0);
      keyDown('arrow_up');

      expect(getSelected()).toEqual([4, 4, 4, 4]);
    });

    it('should traverse whole table by constantly selecting next cell in row', function () {
      handsontable({
        startRows: 5,
        startCols: 5,
        autoWrapRow: true
      });

      selectCell(0, 0);

      for (var row = 0, rlen = countRows(); row < rlen; row++) {
        for (var col = 0, clen = countCols(); col < clen; col++) {
          expect(getSelected()).toEqual([row, col, row, col]);
          keyDown('arrow_right');
        }
      }

      expect(getSelected()).toEqual([0, 0, 0, 0]);
    });

    it('should traverse whole table by constantly selecting previous cell in row', function () {
      handsontable({
        startRows: 5,
        startCols: 5,
        autoWrapRow: true
      });

      selectCell(4, 4);

      for (var row = countRows() - 1; row >= 0; row--) {
        for (var col = countCols() - 1; col >= 0; col--) {
          expect(getSelected()).toEqual([row, col, row, col]);
          keyDown('arrow_left');
        }
      }

      expect(getSelected()).toEqual([4, 4, 4, 4]);
    });

    it('should traverse whole table by constantly selecting next cell in column', function () {
      handsontable({
        startRows: 5,
        startCols: 5,
        autoWrapCol: true
      });

      selectCell(0, 0);

      for (var col = 0, clen = countCols(); col < clen; col++) {
        for (var row = 0, rlen = countRows(); row < rlen; row++) {
          expect(getSelected()).toEqual([row, col, row, col]);
          keyDown('arrow_down');
        }
      }

      expect(getSelected()).toEqual([0, 0, 0, 0]);
    });

    it('should traverse whole table by constantly selecting previous cell in column', function () {
      handsontable({
        startRows: 5,
        startCols: 5,
        autoWrapCol: true
      });

      selectCell(4, 4);

      for (var col = countCols() - 1; col >= 0; col--) {
        for (var row = countRows() - 1; row >= 0; row--) {
          expect(getSelected()).toEqual([row, col, row, col]);
          keyDown('arrow_up');
        }
      }

      expect(getSelected()).toEqual([4, 4, 4, 4]);
    });
  });
});

/***/ }),
/* 170 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_onKeyDown', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should advance to next cell when TAB is pressed', function () {
    // https://github.com/handsontable/handsontable/issues/151
    handsontable();
    selectCell(0, 0);
    keyDownUp('tab');
    expect(getSelected()).toEqual([0, 1, 0, 1]);
  });

  it('should advance to previous cell when shift+TAB is pressed', function () {
    handsontable();
    selectCell(1, 1);
    keyDownUp('shift+tab');
    expect(getSelected()).toEqual([1, 0, 1, 0]);
  });

  describe('while editing (quick edit mode)', function () {
    it('should finish editing and advance to next cell when TAB is pressed', function () {
      // https://github.com/handsontable/handsontable/issues/215
      handsontable();
      selectCell(1, 1);

      keyDownUp('x'); // value to cell trigger quick edit mode
      keyProxy().val('Ted');
      keyDownUp('tab');
      expect(getData()[1][1]).toEqual('Ted');
      expect(getSelected()).toEqual([1, 2, 1, 2]);
    });

    it('should finish editing and advance to lower cell when enter is pressed', function () {
      // https://github.com/handsontable/handsontable/issues/215
      handsontable();
      selectCell(1, 1);

      keyDownUp('x'); // value to cell trigger quick edit mode
      keyProxy().val('Ted');
      keyDownUp('enter');
      expect(getData()[1][1]).toEqual('Ted');
      expect(getSelected()).toEqual([2, 1, 2, 1]);
    });

    it('should finish editing and advance to higher cell when shift+enter is pressed', function () {
      // https://github.com/handsontable/handsontable/issues/215
      handsontable();
      selectCell(1, 1);

      keyDownUp('x'); // trigger quick edit mode
      keyProxy().val('Ted');
      keyDownUp('shift+enter');
      expect(getData()[1][1]).toEqual('Ted');
      expect(getSelected()).toEqual([0, 1, 0, 1]);
    });

    it('should finish editing and advance to lower cell when down arrow is pressed', function () {
      handsontable();
      selectCell(1, 1);

      keyDownUp('x');
      keyProxy().val('Ted');
      keyDownUp('arrow_down');
      expect(getData()[1][1]).toEqual('Ted');
      expect(getSelected()).toEqual([2, 1, 2, 1]);
    });

    it('should finish editing and advance to higher cell when up arrow is pressed', function () {
      handsontable();
      selectCell(1, 1);

      keyDownUp('x');
      keyProxy().val('Ted');
      keyDownUp('arrow_up');
      expect(getData()[1][1]).toEqual('Ted');
      expect(getSelected()).toEqual([0, 1, 0, 1]);
    });

    it('should finish editing and advance to right cell when right arrow is pressed', function () {
      handsontable();
      selectCell(1, 1);

      keyDownUp('x');
      keyProxy().val('Ted');
      keyDownUp('arrow_right');
      keyDownUp('arrow_right');
      keyDownUp('arrow_right');
      keyDownUp('arrow_right');
      expect(getData()[1][1]).toEqual('Ted');
      expect(getSelected()).toEqual([1, 4, 1, 4]);
    });

    it('should finish editing and advance to left cell when left arrow is pressed', function () {
      handsontable();
      selectCell(1, 1);

      keyDownUp('x');
      keyProxy().val('Ted');
      Handsontable.dom.setCaretPosition(keyProxy()[0], 0, 0);
      keyDownUp('arrow_left');
      keyDownUp('arrow_left');
      keyDownUp('arrow_left');
      keyDownUp('arrow_left');
      keyDownUp('arrow_left');
      expect(getData()[1][1]).toEqual('Ted');
      expect(getSelected()).toEqual([1, 0, 1, 0]);
    });

    it('should finish editing and advance to lower cell when enter is pressed (with sync validator)', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        validator: function validator(val, cb) {
          cb(true);
        },

        afterValidate: onAfterValidate
      });

      selectCell(1, 1);

      keyDownUp('x');
      keyProxy().val('Ted');

      onAfterValidate.calls.reset();
      keyDownUp('enter');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalled();
        expect(getData()[1][1]).toEqual('Ted');
        expect(getSelected()).toEqual([2, 1, 2, 1]);
        done();
      }, 200);
    });

    it('should finish editing and advance to lower cell when enter is pressed (with async validator)', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        validator: function validator(val, cb) {
          setTimeout(function () {
            cb(true);
          }, 10);
        },

        afterValidate: onAfterValidate
      });
      selectCell(1, 1);

      keyDownUp('x');
      keyProxy().val('Ted');

      onAfterValidate.calls.reset();
      keyDownUp('enter');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalled();
        expect(getData()[1][1]).toEqual('Ted');
        expect(getSelected()).toEqual([2, 1, 2, 1]);
        done();
      }, 200);
    });
  });

  describe('while editing (full edit mode)', function () {
    it('should finish editing and advance to next cell when TAB is pressed', function () {
      // https://github.com/handsontable/handsontable/issues/215
      handsontable();
      selectCell(1, 1);

      keyDownUp('enter');
      keyProxy().val('Ted');
      keyDownUp('tab');
      expect(getData()[1][1]).toEqual('Ted');
      expect(getSelected()).toEqual([1, 2, 1, 2]);
    });

    it('should finish editing and advance to lower cell when enter is pressed', function () {
      // https://github.com/handsontable/handsontable/issues/215
      handsontable();
      selectCell(1, 1);

      keyDownUp('enter');
      keyProxy().val('Ted');
      keyDownUp('enter');
      expect(getData()[1][1]).toEqual('Ted');
      expect(getSelected()).toEqual([2, 1, 2, 1]);
    });

    it('should finish editing and advance to higher cell when shift+enter is pressed', function () {
      // https://github.com/handsontable/handsontable/issues/215
      handsontable();
      selectCell(1, 1);

      keyDownUp('enter');
      keyProxy().val('Ted');
      keyDownUp('shift+enter');
      expect(getData()[1][1]).toEqual('Ted');
      expect(getSelected()).toEqual([0, 1, 0, 1]);
    });

    it('shouldn\'t finish editing and advance to lower cell when down arrow is pressed', function () {
      handsontable();
      selectCell(1, 1);

      keyDownUp('enter');
      keyProxy().val('Ted');
      keyDownUp('arrow_down');
      expect(getData()[1][1]).toEqual(null);
      expect(getSelected()).toEqual([1, 1, 1, 1]);
    });

    it('shouldn\'t finish editing and advance to higher cell when up arrow is pressed', function () {
      handsontable();
      selectCell(1, 1);

      keyDownUp('enter');
      keyProxy().val('Ted');
      keyDownUp('arrow_up');
      expect(getData()[1][1]).toEqual(null);
      expect(getSelected()).toEqual([1, 1, 1, 1]);
    });

    it('shouldn\'t finish editing and advance to right cell when right arrow is pressed', function () {
      handsontable();
      selectCell(1, 1);

      keyDownUp('enter');
      keyProxy().val('Ted');
      keyDownUp('arrow_right');
      keyDownUp('arrow_right');
      keyDownUp('arrow_right');
      keyDownUp('arrow_right');
      expect(getData()[1][1]).toEqual(null);
      expect(getSelected()).toEqual([1, 1, 1, 1]);
    });

    it('shouldn\'t finish editing and advance to left cell when left arrow is pressed', function () {
      handsontable();
      selectCell(1, 1);

      keyDownUp('enter');
      keyProxy().val('Ted');
      keyDownUp('arrow_left');
      keyDownUp('arrow_left');
      keyDownUp('arrow_left');
      keyDownUp('arrow_left');
      expect(getData()[1][1]).toEqual(null);
      expect(getSelected()).toEqual([1, 1, 1, 1]);
    });

    it('should finish editing and advance to lower cell when enter is pressed (with sync validator)', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        validator: function validator(val, cb) {
          cb(true);
        },

        afterValidate: onAfterValidate
      });

      selectCell(1, 1);

      keyDownUp('enter');
      keyProxy().val('Ted');

      onAfterValidate.calls.reset();
      keyDownUp('enter');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalled();
        expect(getData()[1][1]).toEqual('Ted');
        expect(getSelected()).toEqual([2, 1, 2, 1]);
        done();
      }, 200);
    });

    it('should finish editing and advance to lower cell when enter is pressed (with async validator)', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        validator: function validator(val, cb) {
          setTimeout(function () {
            cb(true);
          }, 10);
        },

        afterValidate: onAfterValidate
      });
      selectCell(1, 1);

      keyDownUp('enter');
      keyProxy().val('Ted');

      onAfterValidate.calls.reset();
      keyDownUp('enter');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalled();
        expect(getData()[1][1]).toEqual('Ted');
        expect(getSelected()).toEqual([2, 1, 2, 1]);
        done();
      }, 200);
    });
  });
});

/***/ }),
/* 171 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_paste', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  var arrayOfArrays = function arrayOfArrays() {
    return [['', 'Kia', 'Nissan', 'Toyota', 'Honda'], ['2008', 10, 11, 12, 13], ['2009', 20, 11, 14, 13], ['2010', 30, 15, 12, 13]];
  };

  it('should not create new rows or columns when allowInsertRow and allowInsertColumn equal false', function (done) {
    handsontable({
      data: arrayOfArrays(),
      pasteMode: 'shift_down',
      allowInsertRow: false,
      allowInsertColumn: false
    });

    selectCell(3, 4); // selectAll
    triggerPaste('Kia\tNissan\tToyota');

    setTimeout(function () {
      var expected = arrayOfArrays();
      expected[3][4] = 'Kia';
      expect(getData()).toEqual(expected);
      done();
    }, 60);
  });

  it('should shift data down instead of overwrite when paste (when allowInsertRow = false)', function (done) {
    handsontable({
      data: arrayOfArrays(),
      pasteMode: 'shift_down',
      allowInsertRow: false
    });

    selectCell(1, 0); // selectAll
    triggerPaste('Kia\tNissan\tToyota');

    setTimeout(function () {
      expect(getData().length).toEqual(4);
      expect(getData(0, 0, 2, 4)).toEqual([['', 'Kia', 'Nissan', 'Toyota', 'Honda'], ['Kia', 'Nissan', 'Toyota', 12, 13], ['2008', 10, 11, 14, 13]]);
      done();
    }, 60);
  });

  it('should shift data down instead of overwrite when paste (minSpareRows > 0)', function (done) {
    handsontable({
      data: arrayOfArrays(),
      pasteMode: 'shift_down',
      minSpareRows: 1
    });

    selectCell(1, 0); // selectAll
    triggerPaste('Kia\tNissan\tToyota');

    setTimeout(function () {
      expect(getData().length).toEqual(6);
      expect(getData(0, 0, 2, 4)).toEqual([['', 'Kia', 'Nissan', 'Toyota', 'Honda'], ['Kia', 'Nissan', 'Toyota', 12, 13], ['2008', 10, 11, 14, 13]]);
      done();
    }, 60);
  });

  it('should shift right insert instead of overwrite when paste', function (done) {
    handsontable({
      data: arrayOfArrays(),
      pasteMode: 'shift_right',
      allowInsertColumn: false
    });

    selectCell(1, 0); // selectAll
    triggerPaste('Kia\tNissan\tToyota');

    setTimeout(function () {
      expect(getData()[0].length).toEqual(5);
      expect(getDataAtRow(1)).toEqual(['Kia', 'Nissan', 'Toyota', '2008', 10]);
      done();
    }, 60);
  });

  it('should shift right insert instead of overwrite when paste (minSpareCols > 0)', function (done) {
    handsontable({
      data: arrayOfArrays(),
      pasteMode: 'shift_right',
      minSpareCols: 1
    });

    selectCell(1, 0); // selectAll
    triggerPaste('Kia\tNissan\tToyota');

    setTimeout(function () {
      expect(getData()[0].length).toEqual(9);
      expect(getDataAtRow(1)).toEqual(['Kia', 'Nissan', 'Toyota', '2008', 10, 11, 12, 13, null]);
      done();
    }, 60);
  });

  it('should not throw an error when changes are null in `once` hook', function (done) {
    var errors = 0;

    try {
      handsontable({
        data: arrayOfArrays(),
        afterChange: function afterChange(changes, source) {
          if (source === 'loadData') {
            return;
          }

          loadData(arrayOfArrays());
        }
      });

      selectCell(1, 0); // selectAll
      triggerPaste('Kia\tNissan\tToyota');
    } catch (e) {
      errors++;
    }

    setTimeout(function () {
      expect(errors).toEqual(0);
      done();
    }, 60);
  });

  it('should not paste any data, if no cell is selected', function (done) {

    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(3, 1)
    });

    var copiedData1 = 'foo';
    var copiedData2 = 'bar';

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('A1');
    expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('A2');
    expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('A3');

    expect(getSelected()).toBeUndefined();

    hot.copyPaste.triggerPaste($.Event(), copiedData1);

    setTimeout(function () {
      expect(spec().$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('A1');
      expect(spec().$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('A2');
      expect(spec().$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('A3');
    }, 100);

    setTimeout(function () {
      selectCell(1, 0, 2, 0);

      hot.copyPaste.triggerPaste($.Event(), copiedData2);
    }, 200);

    setTimeout(function () {
      expect(spec().$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('A1');
      expect(spec().$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual(copiedData2);
      expect(spec().$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual(copiedData2);
      done();
    }, 300);
  });

  it('should not paste any data, if no cell is selected (select/deselect cell using mouse)', function (done) {

    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(3, 1)
    });

    var copiedData = 'foo';

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('A1');
    expect(this.$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('A2');
    expect(this.$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('A3');

    this.$container.find('tbody tr:eq(1) td:eq(0)').simulate('mousedown');
    this.$container.find('tbody tr:eq(1) td:eq(0)').simulate('mouseup');

    expect(getSelected()).toEqual([1, 0, 1, 0]);

    $('html').simulate('mousedown');

    expect(getSelected()).toBeUndefined();

    hot.copyPaste.triggerPaste($.Event(), copiedData);

    setTimeout(function () {
      expect(spec().$container.find('tbody tr:eq(0) td:eq(0)').text()).toEqual('A1');
      expect(spec().$container.find('tbody tr:eq(1) td:eq(0)').text()).toEqual('A2');
      expect(spec().$container.find('tbody tr:eq(2) td:eq(0)').text()).toEqual('A3');
      done();
    }, 100);
  });
});

/***/ }),
/* 172 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_populateFromArray', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  var arrayOfArrays = function arrayOfArrays() {
    return [['', 'Kia', 'Nissan', 'Toyota', 'Honda', 'Mix'], ['2008', 10, 11, 12, 13, { a: 1, b: 2 }], ['2009', 20, 11, 14, 13, { a: 1, b: 2 }], ['2010', 30, 15, 12, 13, { a: 1, b: 2 }]];
  };

  it('should call onChange callback', function () {
    var output = null;

    handsontable({
      data: arrayOfArrays(),
      afterChange: function afterChange(changes) {
        output = changes;
      }
    });
    populateFromArray(0, 0, [['test', 'test'], ['test', 'test']], 1, 1);

    expect(output).toEqual([[0, 0, '', 'test'], [0, 1, 'Kia', 'test'], [1, 0, '2008', 'test'], [1, 1, 10, 'test']]);
  });

  it('should populate single value for whole selection', function () {
    var output = null;

    handsontable({
      data: arrayOfArrays(),
      afterChange: function afterChange(changes) {
        output = changes;
      }
    });
    populateFromArray(0, 0, [['test']], 3, 0);

    expect(output).toEqual([[0, 0, '', 'test'], [1, 0, '2008', 'test'], [2, 0, '2009', 'test'], [3, 0, '2010', 'test']]);
  });

  it('should populate value for whole selection only if populated data isn\'t an array', function () {
    var output = null;

    handsontable({
      data: arrayOfArrays(),
      afterChange: function afterChange(changes) {
        output = changes;
      }
    });
    populateFromArray(0, 0, [['test'], [[1, 2, 3]]], 3, 0);

    expect(output).toEqual([[0, 0, '', 'test'], [2, 0, '2009', 'test']]);
  });

  it('should populate value for whole selection only if populated data isn\'t an object', function () {
    var output = null;

    handsontable({
      data: arrayOfArrays(),
      afterChange: function afterChange(changes) {
        output = changes;
      }
    });
    populateFromArray(0, 0, [['test'], [{ test: 1 }]], 3, 0);

    expect(output).toEqual([[0, 0, '', 'test'], [2, 0, '2009', 'test']]);
  });

  it('shouldn\'t populate value if original value doesn\'t have the same data structure', function () {
    var output = null;

    handsontable({
      data: arrayOfArrays(),
      afterChange: function afterChange(changes) {
        output = changes;
      }
    });
    populateFromArray(1, 3, [['test']], 1, 5);

    expect(output).toEqual([[1, 3, 12, 'test'], [1, 4, 13, 'test']]);
  });

  it('should shift values down', function () {
    var output = null;

    handsontable({
      data: arrayOfArrays(),
      afterChange: function afterChange(changes) {
        output = changes;
      },

      minSpareRows: 1
    });
    populateFromArray(0, 0, [['test', 'test2'], ['test3', 'test4']], 2, 2, null, 'shift_down');

    expect(getData()).toEqual([['test', 'test2', 'test', 'Toyota', 'Honda', 'Mix'], ['test3', 'test4', 'test3', 12, 13, { a: 1, b: 2 }], ['test', 'test2', 'test', 14, 13, { a: 1, b: 2 }], ['', 'Kia', 'Nissan', 12, 13, { a: 1, b: 2 }], ['2008', 10, 11, null, null, null], ['2009', 20, 11, null, null, null], ['2010', 30, 15, null, null, null], [null, null, null, null, null, null]]);
  });

  it('should shift values right', function () {
    var output = null;

    handsontable({
      data: arrayOfArrays(),
      afterChange: function afterChange(changes) {
        output = changes;
      },

      minSpareCols: 1
    });
    populateFromArray(0, 0, [['test', 'test2'], ['test3', 'test4']], 2, 2, null, 'shift_right');

    expect(getData()).toEqual([['test', 'test2', 'test', '', 'Kia', 'Nissan', 'Toyota', 'Honda', 'Mix', null], ['test3', 'test4', 'test3', '2008', 10, { a: 1, b: 2 }, 12, 13, null, null], ['test', 'test2', 'test', '2009', 20, { a: 1, b: 2 }, 14, 13, null, null], ['2010', 30, 15, 12, 13, { a: 1, b: 2 }, null, null, null, null]]);
  });

  it('should run beforeAutofillInsidePopulate hook for each inserted value', function () {
    var called = 0;

    var hot = handsontable({
      data: arrayOfArrays()
    });

    hot.addHook('beforeAutofillInsidePopulate', function (index) {
      called++;
    });

    populateFromArray(0, 0, [['test', 'test2'], ['test3', 'test4']], 1, 1, 'Autofill.fill', 'overwrite');

    expect(called).toEqual(4);
  });

  it('should run beforeAutofillInsidePopulate hook and could change cell data before insert if returned object with value property', function () {

    var hot = handsontable({
      data: arrayOfArrays()
    });

    hot.addHook('beforeAutofillInsidePopulate', function (index) {
      return {
        value: 'my_test'
      };
    });

    populateFromArray(0, 0, [['test', 'test2'], ['test3', 'test4']], 1, 1, 'Autofill.fill', 'overwrite');

    expect(getDataAtCell(0, 0)).toEqual('my_test');
  });

  it('should populate 1 row from 2 selected rows', function () {
    var hot = handsontable({
      data: arrayOfArrays()
    });

    populateFromArray(2, 0, [['A1'], ['A2']], 2, 0, 'autofill', null, 'down', [[0]]);

    expect(getDataAtCell(2, 0)).toEqual('A1');
    expect(getDataAtCell(3, 0)).toEqual('2010');
  });

  it('should populate 1 column from 2 selected columns`', function () {
    var hot = handsontable({
      data: arrayOfArrays()
    });

    populateFromArray(0, 2, [['A1', 'A2']], 0, 2, 'autofill', null, 'right', [[0]]);

    expect(getDataAtCell(0, 2)).toEqual('A1');
    expect(getDataAtCell(0, 3)).toEqual('Toyota');
  });
});

/***/ }),
/* 173 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_reCreate', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should correctly re-render corner header when there is multiline content', function () {
    var settings = {
      rowHeaders: true,
      colHeaders: function colHeaders(col) {
        return 'Column<br>' + col;
      }
    };
    handsontable(settings);
    destroy();
    handsontable(settings);

    expect(getTopLeftClone().width()).toBe(54);
    expect(getTopLeftClone().height()).toBe(51);
  });
});

/***/ }),
/* 174 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_removeCellMeta', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should remove meta for cell', function () {
    handsontable({
      data: [[1, 2, 3, 4], [5, 6, 7, 8], [0, 9, 8, 7]]
    });
    var border = {
      top: {},
      left: {}
    };

    setCellMeta(0, 0, 'borders', border);
    expect(getCellMeta(0, 0).borders).toEqual(border);

    removeCellMeta(0, 0, 'borders');
    expect(getCellMeta(0, 0).borders).toBeUndefined();
  });
});

/***/ }),
/* 175 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_render', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('all cells should get green background', function () {
    function greenCell(instance, td, row, col, prop, value, cellProperties) {
      Handsontable.renderers.TextRenderer.apply(this, arguments);
      td.style.backgroundColor = 'green';
    }

    handsontable({
      data: [['a', 'b'], ['c', 'd']],
      minRows: 4,
      minCols: 4,
      minSpareRows: 4,
      minSpareCols: 4,
      cells: function cells() {
        return {
          renderer: greenCell
        };
      }
    });

    var $tds = this.$container.find('.htCore tbody td');
    $tds.each(function () {
      expect(this.style.backgroundColor).toEqual('green');
    });
  });

  it('render should update border dimensions', function () {
    var data = [['a', 'b'], ['c', 'd']];

    handsontable({
      data: data,
      minRows: 4,
      minCols: 4,
      minSpareRows: 4,
      minSpareCols: 4
    });

    selectCell(1, 1);
    data[1][1] = 'dddddddddddddddddddd';
    render();

    var $td = this.$container.find('.htCore tbody tr:eq(1) td:eq(1)');
    expect(this.$container.find('.wtBorder.current').width()).toBeGreaterThan($td.width());
  });

  it('should not render table twice', function () {
    var counter = 0;

    handsontable({
      data: [['Joe Red']],
      afterRender: function afterRender() {
        counter++;
      }
    });
    populateFromArray(0, 0, [['t', 'e', 's', 't']]);

    expect(counter).toEqual(2); // 1 from load and 1 from populateFromArray
  });

  it('should run afterRenderer hook', function () {
    var lastCellProperties;

    handsontable({
      data: [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]],
      afterRenderer: function afterRenderer(td, row, col, prop, value, cellProperties) {
        td.innerHTML = 'Changed by plugin';

        if (!cellProperties) {
          throw new Error();
        }
        lastCellProperties = cellProperties;
      }
    });

    expect(this.$container.find('td:eq(0)')[0].innerHTML).toEqual('Changed by plugin');
    expect(lastCellProperties.row).toEqual(1);
    expect(lastCellProperties.col).toEqual(4);
  });

  it('should run beforeRenderer hook', function () {
    var lastCellProperties;

    handsontable({
      data: [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]],
      beforeRenderer: function beforeRenderer(td, row, col, prop, value, cellProperties) {
        td.innerHTML = 'Changed by plugin';
        lastCellProperties = cellProperties;
      }
    });

    // Value is overwritten by text renderer
    expect(this.$container.find('td:eq(0)')[0].innerHTML).toEqual('1');
    expect(lastCellProperties.row).toEqual(1);
    expect(lastCellProperties.col).toEqual(4);
  });

  it('should reflect changes applied in beforeRenderer into afterRenderer', function () {
    var afterRenderer = jasmine.createSpy();

    handsontable({
      data: [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]],
      beforeRenderer: function beforeRenderer(td, row, col, prop, value, cellProperties) {
        cellProperties.foo = 'bar';
      },

      afterRenderer: afterRenderer
    });

    expect(afterRenderer.calls.count()).toBe(10);
    expect(afterRenderer.calls.argsFor(0)[0] instanceof HTMLTableCellElement).toBe(true);
    expect(afterRenderer.calls.argsFor(0)[1]).toBe(0);
    expect(afterRenderer.calls.argsFor(0)[2]).toBe(0);
    expect(afterRenderer.calls.argsFor(0)[3]).toBe(0);
    expect(afterRenderer.calls.argsFor(0)[4]).toBe(1);
    expect(afterRenderer.calls.argsFor(0)[5].foo).toBe('bar');
  });
});

/***/ }),
/* 176 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_selection', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should call onSelection callback', function () {
    var output = null;

    handsontable({
      afterSelection: function afterSelection(r, c) {
        output = [r, c];
      }
    });
    selectCell(1, 2);

    expect(output[0]).toEqual(1);
    expect(output[1]).toEqual(2);
  });

  it('should trigger selection event', function () {
    var output = null;

    handsontable();
    Handsontable.hooks.add('afterSelection', function (r, c) {
      output = [r, c];
    });
    selectCell(1, 2);

    expect(output[0]).toEqual(1);
    expect(output[1]).toEqual(2);
  });

  it('this.rootElement should point to handsontable rootElement (onSelection)', function () {
    var output = null;

    handsontable({
      afterSelection: function afterSelection() {
        output = this.rootElement;
      }
    });
    selectCell(0, 0);

    expect(output).toEqual(this.$container[0]);
  });

  it('this.rootElement should point to handsontable rootElement (onSelectionByProp)', function () {
    var output = null;

    handsontable({
      afterSelectionByProp: function afterSelectionByProp() {
        output = this.rootElement;
      }
    });
    selectCell(0, 0);

    expect(output).toEqual(this.$container[0]);
  });

  it('should focus external textarea when clicked during editing', function () {
    var textarea = $('<input type="text">').prependTo($('body'));

    handsontable();
    selectCell(0, 0);

    keyDown('enter');
    // $("html").triggerHandler('mouseup');
    $('html').simulate('mouseup');
    textarea.focus();

    expect(document.activeElement).toBe(textarea[0]);
    textarea.remove();
  });

  it('should deselect currently selected cell', function () {
    handsontable();
    selectCell(0, 0);

    $('html').simulate('mousedown');

    expect(getSelected()).toBeUndefined();
  });

  it('should not deselect the currently selected cell after clicking on a scrollbar', function () {
    var hot = handsontable({
      outsideClickDeselects: false,
      minRows: 20,
      minCols: 2,
      width: 400,
      height: 100
    });
    selectCell(0, 0);

    var holderBoundingBox = hot.view.wt.wtTable.holder.getBoundingClientRect(),
        verticalScrollbarCoords = {
      x: holderBoundingBox.left + holderBoundingBox.width - 3,
      y: holderBoundingBox.top + holderBoundingBox.height / 2
    },
        horizontalScrollbarCoords = {
      x: holderBoundingBox.left + holderBoundingBox.width / 2,
      y: holderBoundingBox.top + holderBoundingBox.height - 3
    };

    $(hot.view.wt.wtTable.holder).simulate('mousedown', {
      clientX: verticalScrollbarCoords.x,
      clientY: verticalScrollbarCoords.y
    });

    expect(getSelected()).toEqual([0, 0, 0, 0]);

    $(hot.view.wt.wtTable.holder).simulate('mousedown', {
      clientX: horizontalScrollbarCoords.x,
      clientY: horizontalScrollbarCoords.y
    });

    expect(getSelected()).toEqual([0, 0, 0, 0]);
  });

  it('should not deselect currently selected cell', function () {
    handsontable({
      outsideClickDeselects: false
    });
    selectCell(0, 0);

    $('html').simulate('mousedown');

    expect(getSelected()).toEqual([0, 0, 0, 0]);
  });

  it('should allow to focus on external input and hold current selection informations', function () {
    var textarea = $('<input id="test_textarea" type="text">').prependTo($('body'));

    handsontable({
      outsideClickDeselects: false
    });
    selectCell(0, 0);

    textarea.simulate('mousedown');
    textarea.focus();

    expect(document.activeElement.id).toEqual('test_textarea');
    expect(getSelected()).toEqual([0, 0, 0, 0]);
    textarea.remove();
  });

  it('should allow to type in external input while holding current selection information', function () {
    var textarea = $('<textarea id="test_textarea"></textarea>').prependTo($('body'));
    var keyPressed;
    handsontable({
      outsideClickDeselects: false
    });
    selectCell(0, 0);

    textarea.focus();
    textarea.simulate('mousedown');
    textarea.simulate('mouseup');

    textarea.on('keydown', function (event) {
      keyPressed = event.keyCode;
    });

    var LETTER_A_KEY = 97;

    $(document.activeElement).simulate('keydown', {
      keyCode: LETTER_A_KEY
    });

    // textarea should receive the event and be an active element
    expect(keyPressed).toEqual(LETTER_A_KEY);
    expect(document.activeElement).toBe(document.getElementById('test_textarea'));

    // should preserve selection, close editor and save changes
    expect(getSelected()).toEqual([0, 0, 0, 0]);
    expect(getDataAtCell(0, 0)).toBeNull();

    textarea.remove();
  });

  it('should allow to type in external input after opening cell editor', function () {
    var textarea = $('<textarea id="test_textarea"></textarea>').prependTo($('body'));
    var keyPressed;
    handsontable({
      outsideClickDeselects: false
    });
    selectCell(0, 0);
    keyDown('enter');
    document.activeElement.value = 'Foo';

    textarea.focus();
    textarea.simulate('mousedown');
    textarea.simulate('mouseup');

    textarea.on('keydown', function (event) {
      keyPressed = event.keyCode;
    });

    var LETTER_A_KEY = 97;

    $(document.activeElement).simulate('keydown', {
      keyCode: LETTER_A_KEY
    });

    // textarea should receive the event and be an active element
    expect(keyPressed).toEqual(LETTER_A_KEY);
    expect(document.activeElement).toBe(document.getElementById('test_textarea'));

    // should preserve selection, close editor and save changes
    expect(getSelected()).toEqual([0, 0, 0, 0]);
    expect(getDataAtCell(0, 0)).toEqual('Foo');

    textarea.remove();
  });

  it('should deselect on outside click if outsideClickDeselects is a function that returns true', function () {
    var textarea = $('<textarea id="test_textarea"></textarea>').prependTo($('body'));
    var keyPressed;
    handsontable({
      outsideClickDeselects: function outsideClickDeselects() {
        return true;
      }
    });
    selectCell(0, 0);
    keyDown('enter');
    document.activeElement.value = 'Foo';

    textarea.focus();
    textarea.simulate('mousedown');
    textarea.simulate('mouseup');

    textarea.on('keydown', function (event) {
      keyPressed = event.keyCode;
    });

    var LETTER_A_KEY = 97;

    $(document.activeElement).simulate('keydown', {
      keyCode: LETTER_A_KEY
    });

    // textarea should receive the event and be an active element
    expect(keyPressed).toEqual(LETTER_A_KEY);
    expect(document.activeElement).toBe(document.getElementById('test_textarea'));

    // should NOT preserve selection
    expect(getSelected()).toEqual(undefined);
    expect(getDataAtCell(0, 0)).toEqual('Foo');

    textarea.remove();
  });

  it('should not deselect on outside click if outsideClickDeselects is a function that returns false', function () {
    var textarea = $('<textarea id="test_textarea"></textarea>').prependTo($('body'));
    var keyPressed;
    handsontable({
      outsideClickDeselects: function outsideClickDeselects() {
        return false;
      }
    });
    selectCell(0, 0);
    keyDown('enter');
    document.activeElement.value = 'Foo';

    textarea.focus();
    textarea.simulate('mousedown');
    textarea.simulate('mouseup');

    textarea.on('keydown', function (event) {
      keyPressed = event.keyCode;
    });

    var LETTER_A_KEY = 97;

    $(document.activeElement).simulate('keydown', {
      keyCode: LETTER_A_KEY
    });

    // textarea should receive the event and be an active element
    expect(keyPressed).toEqual(LETTER_A_KEY);
    expect(document.activeElement).toBe(document.getElementById('test_textarea'));

    // should preserve selection, close editor and save changes
    expect(getSelected()).toEqual([0, 0, 0, 0]);
    expect(getDataAtCell(0, 0)).toEqual('Foo');

    textarea.remove();
  });

  it('should fix start range if provided is out of bounds (to the left)', function () {
    handsontable({
      startRows: 5,
      startCols: 5
    });
    selectCell(0, 0);
    keyDownUp('arrow_left');

    expect(getSelected()).toEqual([0, 0, 0, 0]);
  });

  it('should fix start range if provided is out of bounds (to the top)', function () {
    handsontable({
      startRows: 5,
      startCols: 5
    });
    selectCell(0, 0);
    keyDownUp('arrow_up');

    expect(getSelected()).toEqual([0, 0, 0, 0]);
  });

  it('should fix start range if provided is out of bounds (to the right)', function () {
    handsontable({
      startRows: 5,
      startCols: 5
    });
    selectCell(0, 4);
    keyDownUp('arrow_right');

    expect(getSelected()).toEqual([0, 4, 0, 4]);
  });

  it('should fix start range if provided is out of bounds (to the bottom)', function () {
    handsontable({
      startRows: 5,
      startCols: 5
    });
    selectCell(4, 0);
    keyDownUp('arrow_down');

    expect(getSelected()).toEqual([4, 0, 4, 0]);
  });

  it('should fix end range if provided is out of bounds (to the left)', function () {
    handsontable({
      startRows: 5,
      startCols: 5
    });
    selectCell(0, 1);
    keyDownUp('shift+arrow_left');
    keyDownUp('shift+arrow_left');

    expect(getSelected()).toEqual([0, 1, 0, 0]);
  });

  it('should fix end range if provided is out of bounds (to the top)', function () {
    handsontable({
      startRows: 5,
      startCols: 5
    });
    selectCell(1, 0);
    keyDownUp('shift+arrow_up');
    keyDownUp('shift+arrow_up');

    expect(getSelected()).toEqual([1, 0, 0, 0]);
  });

  it('should fix end range if provided is out of bounds (to the right)', function () {
    handsontable({
      startRows: 5,
      startCols: 5
    });
    selectCell(0, 3);
    keyDownUp('shift+arrow_right');
    keyDownUp('shift+arrow_right');

    expect(getSelected()).toEqual([0, 3, 0, 4]);
  });

  it('should fix end range if provided is out of bounds (to the bottom)', function () {
    handsontable({
      startRows: 5,
      startCols: 5
    });
    selectCell(3, 0);
    keyDownUp('shift+arrow_down');
    keyDownUp('shift+arrow_down');
    keyDownUp('shift+arrow_down');

    expect(getSelected()).toEqual([3, 0, 4, 0]);
  });

  it('should select multiple cells', function () {
    handsontable({
      startRows: 5,
      startCols: 5
    });
    selectCell(3, 0, 4, 1);

    expect(getSelected()).toEqual([3, 0, 4, 1]);
  });

  it('should call onSelectionEnd as many times as onSelection when `selectCell` is called', function () {
    var tick = 0,
        tickEnd = 0;

    handsontable({
      startRows: 5,
      startCols: 5,
      afterSelection: function afterSelection() {
        tick++;
      },
      afterSelectionEnd: function afterSelectionEnd() {
        tickEnd++;
      }
    });
    selectCell(3, 0);
    selectCell(1, 1);

    expect(tick).toEqual(2);
    expect(tickEnd).toEqual(2);
  });

  it('should call onSelectionEnd when user finishes selection by releasing SHIFT key (3 times)', function () {
    var tick = 0;
    handsontable({
      startRows: 5,
      startCols: 5,
      afterSelectionEnd: function afterSelectionEnd() {
        tick++;
      }
    });
    selectCell(3, 0); // makes tick++
    keyDownUp('shift+arrow_down'); // makes tick++
    keyDownUp('shift+arrow_down'); // makes tick++
    keyDownUp('shift+arrow_down'); // makes tick++

    expect(getSelected()).toEqual([3, 0, 4, 0]);
    expect(tick).toEqual(4);
  });

  it('should call onSelectionEnd when user finishes selection by releasing SHIFT key (1 time)', function () {
    var tick = 0;
    handsontable({
      startRows: 5,
      startCols: 5,
      afterSelectionEnd: function afterSelectionEnd() {
        tick++;
      }
    });
    selectCell(3, 0); // makes tick++
    keyDown('shift+arrow_down');
    keyDown('shift+arrow_down');
    keyDownUp('shift+arrow_down'); // makes tick++

    expect(getSelected()).toEqual([3, 0, 4, 0]);
    expect(tick).toEqual(2);
  });

  it('should select columns by click on header with SHIFT key', function () {
    handsontable({
      startRows: 5,
      startCols: 5,
      colHeaders: true
    });

    this.$container.find('.ht_clone_top tr:eq(0) th:eq(1)').simulate('mousedown');
    this.$container.find('.ht_clone_top tr:eq(0) th:eq(1)').simulate('mouseup');

    this.$container.find('.ht_clone_top tr:eq(0) th:eq(4)').simulate('mousedown', { shiftKey: true });
    this.$container.find('.ht_clone_top tr:eq(0) th:eq(4)').simulate('mouseup');

    expect(getSelected()).toEqual([0, 1, 4, 4]);
  });

  it('should select rows by click on header with SHIFT key', function () {
    handsontable({
      startRows: 5,
      startCols: 5,
      rowHeaders: true
    });

    this.$container.find('.ht_clone_left tr:eq(1) th:eq(0)').simulate('mousedown');
    this.$container.find('.ht_clone_left tr:eq(1) th:eq(0)').simulate('mouseup');

    this.$container.find('.ht_clone_left tr:eq(4) th:eq(0)').simulate('mousedown', { shiftKey: true });
    this.$container.find('.ht_clone_left tr:eq(4) th:eq(0)').simulate('mouseup');

    expect(getSelected()).toEqual([1, 0, 4, 4]);
  });

  it('should select columns by click on header with SHIFT key', function () {
    handsontable({
      startRows: 5,
      startCols: 5,
      colHeaders: true
    });

    this.$container.find('.ht_clone_top tr:eq(0) th:eq(1)').simulate('mousedown');
    this.$container.find('.ht_clone_top tr:eq(0) th:eq(1)').simulate('mouseup');

    this.$container.find('.ht_clone_top tr:eq(0) th:eq(4)').simulate('mousedown', { shiftKey: true });
    this.$container.find('.ht_clone_top tr:eq(0) th:eq(4)').simulate('mouseup');

    expect(getSelected()).toEqual([0, 1, 4, 4]);
  });

  it('should change selection after click on row header with SHIFT key', function () {
    handsontable({
      startRows: 5,
      startCols: 5,
      rowHeaders: true
    });

    selectCell(1, 1, 3, 3);

    this.$container.find('.ht_clone_left tr:eq(4) th:eq(0)').simulate('mousedown', { shiftKey: true });
    this.$container.find('.ht_clone_left tr:eq(4) th:eq(0)').simulate('mouseup');

    expect(getSelected()).toEqual([1, 0, 4, 4]);
  });

  it('should change selection after click on column header with SHIFT key', function () {
    handsontable({
      startRows: 5,
      startCols: 5,
      colHeaders: true
    });

    selectCell(1, 1, 3, 3);

    this.$container.find('.ht_clone_top tr:eq(0) th:eq(4)').simulate('mousedown', { shiftKey: true });
    this.$container.find('.ht_clone_top tr:eq(0) th:eq(4)').simulate('mouseup');

    expect(getSelected()).toEqual([0, 1, 4, 4]);
  });

  it('should call onSelection while user selects cells with mouse; onSelectionEnd when user finishes selection', function () {
    var tick = 0,
        tickEnd = 0;
    handsontable({
      startRows: 5,
      startCols: 5,
      afterSelection: function afterSelection() {
        tick++;
      },
      afterSelectionEnd: function afterSelectionEnd() {
        tickEnd++;
      }
    });

    this.$container.find('tr:eq(0) td:eq(0)').simulate('mousedown');
    this.$container.find('tr:eq(0) td:eq(1)').simulate('mouseover');
    this.$container.find('tr:eq(1) td:eq(3)').simulate('mouseover');

    this.$container.find('tr:eq(1) td:eq(3)').simulate('mouseup');

    expect(getSelected()).toEqual([0, 0, 1, 3]);
    expect(tick).toEqual(3);
    expect(tickEnd).toEqual(1);
  });

  it('should properly select columns, when the user moves the cursor over column headers across two overlays', function () {
    handsontable({
      startRows: 5,
      startCols: 5,
      colHeaders: true,
      fixedColumnsLeft: 2
    });

    this.$container.find('.ht_clone_left tr:eq(0) th:eq(1)').simulate('mousedown');
    this.$container.find('.ht_clone_left tr:eq(0) th:eq(1)').simulate('mouseover');
    this.$container.find('.ht_clone_top tr:eq(0) th:eq(2)').simulate('mouseover');
    this.$container.find('.ht_clone_left tr:eq(0) th:eq(1)').simulate('mouseover');
    this.$container.find('.ht_clone_left tr:eq(0) th:eq(1)').simulate('mouseup');

    expect(getSelected()).toEqual([0, 1, 4, 1]);
  });

  it('should move focus to selected cell', function () {
    var $input = $('<input>').appendTo(document.body);
    handsontable({
      startRows: 5,
      startCols: 5
    });
    $input[0].focus();
    selectCell(0, 0);

    keyDownUp('enter');
    expect(isEditorVisible()).toEqual(true);
    $input.remove();
  });

  // This test should cover the #893 case, but it always passes. It seems like the keydown event (with CTRL key pressed) isn't delivered.
  it('should not move focus from outside elements on CTRL keydown event, when no cell is selected', function () {
    var $input = $('<input type="text"/>');
    $('body').append($input);

    handsontable();

    selectCell(0, 0);

    expect(document.activeElement.nodeName).toBeInArray(['BODY', 'HTML']);

    $input.focus();

    expect(document.activeElement.nodeName).toBe('INPUT');

    // var keyDownEvent = $.Event('keydown', {ctrlKey: true, metaKey: true});
    // $input.trigger(keyDownEvent);

    $input.simulate('keydown', { ctrlKey: true, metaKey: true });

    expect(document.activeElement.nodeName).toBe('INPUT');

    $input.remove();
  });

  it('should select the entire column after column header is clicked', function () {
    var hot = handsontable({
      width: 200,
      height: 100,
      startRows: 50,
      startCols: 5,
      colHeaders: true
    });

    this.$container.find('thead th:eq(0)').simulate('mousedown');

    expect(getSelected()).toEqual([0, 0, 49, 0]);
    expect(hot.selection.selectedHeader.rows).toBe(false);
    expect(hot.selection.selectedHeader.cols).toBe(true);
    expect(hot.selection.selectedHeader.corner).toBe(false);
  });

  it('should add classname after select column', function () {
    var hot = handsontable({
      width: 200,
      height: 100,
      startRows: 50,
      startCols: 5,
      colHeaders: true
    });

    this.$container.find('thead th:eq(0)').simulate('mousedown');

    expect(this.$container.hasClass('ht__selection--columns')).toBeTruthy();
  });

  it('should select the entire column after column header is clicked (in fixed rows/cols corner)', function () {
    var hot = handsontable({
      width: 200,
      height: 100,
      startRows: 50,
      startCols: 5,
      colHeaders: true,
      rowHeaders: true,
      fixedRowsTop: 2,
      fixedColumnsLeft: 2
    });

    this.$container.find('.ht_master thead th:eq(1)').simulate('mousedown');

    expect(getSelected()).toEqual([0, 0, 49, 0]);
    expect(hot.selection.selectedHeader.rows).toBe(false);
    expect(hot.selection.selectedHeader.cols).toBe(true);
    expect(hot.selection.selectedHeader.corner).toBe(false);
  });

  it('should select the entire fixed column after column header is clicked, after scroll horizontally', function () {
    var hot = handsontable({
      width: 200,
      height: 100,
      startRows: 50,
      startCols: 50,
      colHeaders: true,
      rowHeaders: true,
      fixedColumnsLeft: 2
    });

    hot.render();
    hot.view.wt.scrollHorizontal(20);

    this.$container.find('.ht_master thead th:eq(2)').simulate('mousedown');
    this.$container.find('.ht_master thead th:eq(2)').simulate('mouseup');

    expect(getSelected()).toEqual([0, 1, 49, 1]);
    expect(hot.selection.selectedHeader.rows).toBe(false);
    expect(hot.selection.selectedHeader.cols).toBe(true);
    expect(hot.selection.selectedHeader.corner).toBe(false);
  });

  it('should set the selection end to the first visible row, when dragging the selection from a cell to a column header', function (done) {
    var hot = handsontable({
      width: 200,
      height: 200,
      startRows: 20,
      startCols: 20,
      colHeaders: true,
      rowHeaders: true
    });

    hot.view.wt.scrollVertical(10);
    hot.view.wt.scrollHorizontal(10);

    hot.render();

    setTimeout(function () {
      $(getCell(12, 11)).simulate('mousedown');
      spec().$container.find('.ht_clone_top thead th:eq(2)').simulate('mouseover');
    }, 30);

    setTimeout(function () {
      expect(getSelected()).toEqual([12, 11, 10, 11]);
      done();
    }, 60);
  });

  it('should set the selection end to the first visible column, when dragging the selection from a cell to a row header', function (done) {
    var hot = handsontable({
      width: 200,
      height: 200,
      startRows: 20,
      startCols: 20,
      colHeaders: true,
      rowHeaders: true
    });

    hot.view.wt.scrollVertical(10);
    hot.view.wt.scrollHorizontal(10);

    hot.render();

    setTimeout(function () {
      $(getCell(12, 11)).simulate('mousedown');
      spec().$container.find('.ht_clone_left tbody th:eq(12)').simulate('mouseover');
    }, 30);

    setTimeout(function () {
      expect(getSelected()).toEqual([12, 11, 12, 10]);
      done();
    }, 60);
  });

  it('should allow to scroll the table when a whole column is selected and table is longer than it\'s container', function (done) {
    var errCount = 0;
    $(window).on('error.selectionTest', function () {
      errCount++;
    });

    var onAfterScrollVertically = jasmine.createSpy('onAfterScrollVertically');

    var hot = handsontable({
      height: 100,
      width: 300,
      startRows: 100,
      startCols: 5,
      colHeaders: true,
      rowHeaders: true,
      afterScrollVertically: onAfterScrollVertically
    });

    var mainHolder = hot.view.wt.wtTable.holder;

    mainHolder.scrollTop = 0;

    this.$container.find('thead tr:eq(0) th:eq(2)').simulate('mousedown');
    this.$container.find('thead tr:eq(0) th:eq(2)').simulate('mouseup');

    mainHolder.scrollTop = 120;

    setTimeout(function () {
      expect(errCount).toEqual(0); // expect no errors to be thrown

      $(window).off('error.selectionTest');
      done();
    }, 100);
  });

  it('should scroll to the end of the selection, when selecting cells using the keyboard', function () {
    var hot = handsontable({
      height: 300,
      width: 300,
      startRows: 50,
      startCols: 50,
      colHeaders: true,
      rowHeaders: true,
      fixedRowsTop: 2,
      fixedColumnsLeft: 2
    });

    var mainHolder = hot.view.wt.wtTable.holder;

    mainHolder.scrollTop = 100;
    selectCell(1, 3);
    keyDownUp('arrow_down');
    expect(mainHolder.scrollTop).toEqual(0);
    mainHolder.scrollTop = 100;
    selectCell(1, 3);
    keyDownUp('shift+arrow_down');
    expect(mainHolder.scrollTop).toEqual(0);

    mainHolder.scrollLeft = 100;
    selectCell(3, 1);
    keyDownUp('arrow_right');
    expect(mainHolder.scrollLeft).toEqual(0);
    mainHolder.scrollLeft = 100;
    selectCell(3, 1);
    keyDownUp('shift+arrow_right');
    expect(mainHolder.scrollLeft).toEqual(0);

    var lastVisibleColumn = hot.view.wt.wtTable.getLastVisibleColumn();
    selectCell(3, lastVisibleColumn);
    keyDownUp('arrow_right');
    expect(hot.view.wt.wtTable.getLastVisibleColumn()).toEqual(lastVisibleColumn + 1);
    keyDownUp('arrow_right');
    expect(hot.view.wt.wtTable.getLastVisibleColumn()).toEqual(lastVisibleColumn + 2);
    keyDownUp('shift+arrow_right');
    expect(hot.view.wt.wtTable.getLastVisibleColumn()).toEqual(lastVisibleColumn + 3);

    var lastVisibleRow = hot.view.wt.wtTable.getLastVisibleRow();
    selectCell(lastVisibleRow, 3);
    keyDownUp('arrow_down');
    expect(hot.view.wt.wtTable.getLastVisibleRow()).toEqual(lastVisibleRow + 1);
    keyDownUp('arrow_down');
    expect(hot.view.wt.wtTable.getLastVisibleRow()).toEqual(lastVisibleRow + 2);
    keyDownUp('shift+arrow_down');
    expect(hot.view.wt.wtTable.getLastVisibleRow()).toEqual(lastVisibleRow + 3);
  });

  it('should select the entire row after row header is clicked', function () {
    var hot = handsontable({
      startRows: 5,
      startCols: 5,
      colHeaders: true,
      rowHeaders: true
    });

    this.$container.find('tr:eq(2) th:eq(0)').simulate('mousedown');

    expect(getSelected()).toEqual([1, 0, 1, 4]);
    expect(hot.selection.selectedHeader.rows).toBe(true);
    expect(hot.selection.selectedHeader.cols).toBe(false);
    expect(hot.selection.selectedHeader.corner).toBe(false);
  });

  it('should add classname after select row', function () {
    var hot = handsontable({
      width: 200,
      height: 100,
      startRows: 50,
      startCols: 5,
      rowHeaders: true
    });

    this.$container.find('tbody tr:eq(0) th:eq(0)').simulate('mousedown');

    expect(this.$container.hasClass('ht__selection--rows')).toBeTruthy();
  });

  it('should select the entire row of a partially fixed table after row header is clicked', function () {
    handsontable({
      startRows: 5,
      startCols: 5,
      colHeaders: true,
      rowHeaders: true,
      fixedRowsTop: 2,
      fixedColumnsLeft: 2
    });

    this.$container.find('tr:eq(2) th:eq(0)').simulate('mousedown');
    expect(getSelected()).toEqual([1, 0, 1, 4]);
    this.$container.find('tr:eq(3) th:eq(0)').simulate('mousedown');
    expect(getSelected()).toEqual([2, 0, 2, 4]);
  });

  it('should select a cell in a newly added row after automatic row adding, triggered by editing a cell in the last row with minSpareRows > 0, ' + 'unless editing happened within the fixed bottom rows', function (done) {
    var hot = handsontable({
      startRows: 5,
      startCols: 2,
      minSpareRows: 1
    });

    setTimeout(function () {
      selectCell(4, 0);
      keyDownUp('enter');
    }, 10);

    setTimeout(function () {
      keyDownUp('enter');
    }, 100);

    setTimeout(function () {
      expect(countRows()).toEqual(6);
      expect(getSelected()).toEqual([5, 0, 5, 0]);
    }, 200);

    setTimeout(function () {
      done();
    }, 250);
  });

  it('should change selected coords by modifying coords object via `modifyTransformStart` hook', function () {
    var hot = handsontable({
      startRows: 5,
      startCols: 5
    });
    selectCell(0, 0);

    hot.addHook('modifyTransformStart', function (coords) {
      coords.col += 1;
      coords.row += 1;
    });
    keyDown('arrow_down');

    expect(getSelected()).toEqual([2, 1, 2, 1]);
  });

  it('should change selected coords by modifying coords object via `modifyTransformEnd` hook', function () {
    var hot = handsontable({
      startRows: 5,
      startCols: 5
    });
    selectCell(0, 0);

    hot.addHook('modifyTransformEnd', function (coords) {
      coords.col += 2;
      coords.row += 1;
    });
    keyDown('shift+arrow_down');

    expect(getSelected()).toEqual([0, 0, 2, 2]);
  });

  it('should indicate is coords is out of bounds via `afterModifyTransformStart` hook', function () {
    var spy = jasmine.createSpy();

    var hot = handsontable({
      startRows: 5,
      startCols: 5
    });
    hot.addHook('afterModifyTransformStart', spy);

    selectCell(2, 0);
    keyDownUp('arrow_left');

    expect(spy.calls.mostRecent().args[1]).toBe(0);
    expect(spy.calls.mostRecent().args[2]).toBe(-1);

    spy.calls.reset();
    selectCell(2, 4);
    keyDownUp('arrow_right');

    expect(spy.calls.mostRecent().args[1]).toBe(0);
    expect(spy.calls.mostRecent().args[2]).toBe(1);

    spy.calls.reset();
    selectCell(4, 2);
    keyDownUp('arrow_down');

    expect(spy.calls.mostRecent().args[1]).toBe(1);
    expect(spy.calls.mostRecent().args[2]).toBe(0);

    spy.calls.reset();
    selectCell(0, 2);
    keyDownUp('arrow_up');

    expect(spy.calls.mostRecent().args[1]).toBe(-1);
    expect(spy.calls.mostRecent().args[2]).toBe(0);
  });

  it('should indicate is coords is out of bounds via `afterModifyTransformEnd` hook', function () {
    var spy = jasmine.createSpy();

    var hot = handsontable({
      startRows: 5,
      startCols: 5
    });
    hot.addHook('afterModifyTransformEnd', spy);

    selectCell(2, 0);
    keyDownUp('shift+arrow_left');

    expect(spy.calls.mostRecent().args[1]).toBe(0);
    expect(spy.calls.mostRecent().args[2]).toBe(-1);

    spy.calls.reset();
    selectCell(2, 4);
    keyDownUp('shift+arrow_right');

    expect(spy.calls.mostRecent().args[1]).toBe(0);
    expect(spy.calls.mostRecent().args[2]).toBe(1);

    spy.calls.reset();
    selectCell(4, 2);
    keyDownUp('shift+arrow_down');

    expect(spy.calls.mostRecent().args[1]).toBe(1);
    expect(spy.calls.mostRecent().args[2]).toBe(0);

    spy.calls.reset();
    selectCell(0, 2);
    keyDownUp('shift+arrow_up');

    expect(spy.calls.mostRecent().args[1]).toBe(-1);
    expect(spy.calls.mostRecent().args[2]).toBe(0);
  });

  it('should change selection after left mouse button on one of selected cell', function () {
    var hot = handsontable({
      startRows: 5,
      startCols: 5
    });

    var cells = $('.ht_master.handsontable td');

    cells.eq(6).simulate('mousedown');
    cells.eq(18).simulate('mouseover');
    cells.eq(18).simulate('mouseup');

    expect(hot.getSelected()).toEqual([1, 1, 3, 3]);

    cells.eq(16).simulate('mousedown');
    cells.eq(16).simulate('mouseup');

    expect(hot.getSelected()).toEqual([3, 1, 3, 1]);
  });

  it('should select the first row after corner header is clicked', function () {
    var hot = handsontable({
      startRows: 5,
      startCols: 5,
      colHeaders: true,
      rowHeaders: true
    });

    this.$container.find('thead').find('th').eq(0).simulate('mousedown');

    expect(getSelected()).toEqual([0, 0, 0, 0]);
    expect(hot.selection.selectedHeader.rows).toBe(false);
    expect(hot.selection.selectedHeader.cols).toBe(false);
    expect(hot.selection.selectedHeader.corner).toBe(true);
  });

  it('should redraw selection when option `colHeaders` is set and user scrolled', function (done) {
    var hot = handsontable({
      startRows: 20,
      startCols: 20,
      colHeaders: true,
      rowHeaders: true,
      width: 400,
      height: 200
    });
    var cellVerticalPosition;
    var borderOffsetInPixels = 1;
    var topBorder;

    selectCell(5, 5);
    hot.view.wt.wtOverlays.topOverlay.scrollTo(2);

    setTimeout(function () {
      cellVerticalPosition = hot.getCell(5, 5).offsetTop;
      topBorder = $('.wtBorder.current')[0];
      expect(topBorder.offsetTop).toEqual(cellVerticalPosition - borderOffsetInPixels);
      hot.view.wt.wtOverlays.topOverlay.scrollTo(0);
    }, 100);

    setTimeout(function () {
      cellVerticalPosition = hot.getCell(5, 5).offsetTop;
      topBorder = $('.wtBorder.current')[0];
      expect(topBorder.offsetTop).toEqual(cellVerticalPosition - borderOffsetInPixels);
      done();
    }, 200);
  });

  it('should redraw selection on `leftOverlay` when options `colHeaders` and `fixedColumnsLeft` are set, and user scrolled', function (done) {
    var hot = handsontable({
      fixedColumnsLeft: 2,
      startRows: 20,
      startCols: 20,
      colHeaders: true,
      rowHeaders: true,
      width: 400,
      height: 200
    });
    var cellVerticalPosition;
    var borderOffsetInPixels = 1;
    var topBorder;

    selectCell(1, 0);
    hot.view.wt.wtOverlays.topOverlay.scrollTo(5);

    setTimeout(function () {
      cellVerticalPosition = hot.getCell(1, 0).offsetTop;
      topBorder = $('.wtBorder.current')[0];
      expect(topBorder.offsetTop).toEqual(cellVerticalPosition - borderOffsetInPixels);
      hot.view.wt.wtOverlays.topOverlay.scrollTo(0);
    }, 100);

    setTimeout(function () {
      cellVerticalPosition = hot.getCell(1, 0).offsetTop;
      topBorder = $('.wtBorder.current')[0];
      expect(topBorder.offsetTop).toEqual(cellVerticalPosition - borderOffsetInPixels);
      done();
    }, 200);
  });
});

/***/ }),
/* 177 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_setDataAtCell', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  var arrayOfNestedObjects = function arrayOfNestedObjects() {
    return [{ id: 1,
      name: {
        first: 'Ted',
        last: 'Right'
      } }, { id: 2,
      name: {
        first: 'Frank',
        last: 'Honest'
      } }, { id: 3,
      name: {
        first: 'Joan',
        last: 'Well'
      } }];
  };

  var htmlText = 'Ben & Jerry\'s';

  it('HTML special chars should be preserved in data map but escaped in DOM', function () {
    // https://github.com/handsontable/handsontable/issues/147
    handsontable();
    var td = setDataAtCell(0, 0, htmlText);
    selectCell(0, 0);

    $(td).simulate('dblclick');
    deselectCell();

    expect(getDataAtCell(0, 0)).toEqual(htmlText);
  });

  it('should correctly paste string that contains "quotes"', function (done) {
    // https://github.com/handsontable/handsontable/issues/205
    handsontable({});
    selectCell(0, 0);
    triggerPaste('1\nThis is a "test" and a test\n2');

    setTimeout(function () {
      expect(getDataAtCell(0, 0)).toEqual('1');
      expect(getDataAtCell(1, 0)).toEqual('This is a "test" and a test');
      expect(getDataAtCell(2, 0)).toEqual('2');
      done();
    }, 200);
  });

  it('should correctly paste string when dataSchema is used', function (done) {
    // https://github.com/handsontable/handsontable/issues/237
    handsontable({
      colHeaders: true,
      dataSchema: {
        col1: null,
        col2: null,
        col3: null
      }
    });
    selectCell(0, 0);
    triggerPaste('1\tTest\t2');

    setTimeout(function () {
      expect(getDataAtCell(0, 0)).toEqual('1');
      expect(getDataAtCell(0, 1)).toEqual('Test');
      expect(getDataAtCell(0, 2)).toEqual('2');
      done();
    }, 200);
  });

  it('should paste not more rows than maxRows', function (done) {
    handsontable({
      minSpareRows: 1,
      minRows: 5,
      maxRows: 10
    });
    selectCell(4, 0);
    triggerPaste('1\n2\n3\n4\n5\n6\n7\n8\n9\n10');

    setTimeout(function () {
      expect(countRows()).toEqual(10);
      expect(getDataAtCell(9, 0)).toEqual('6');
      done();
    }, 200);
  });

  it('should paste not more cols than maxCols', function (done) {
    handsontable({
      minSpareCols: 1,
      minCols: 5,
      maxCols: 10
    });
    selectCell(0, 4);
    triggerPaste('1\t2\t3\t4\t5\t6\t7\t8\t9\t10');

    setTimeout(function () {
      expect(countCols()).toEqual(10);
      expect(getDataAtCell(0, 9)).toEqual('6');
      done();
    }, 200);
  });

  it('should paste not more rows & cols than maxRows & maxCols', function (done) {
    handsontable({
      minSpareRows: 1,
      minSpareCols: 1,
      minRows: 5,
      minCols: 5,
      maxRows: 6,
      maxCols: 6
    });
    selectCell(4, 4);
    triggerPaste('1\t2\t3\n4\t5\t6\n7\t8\t9');

    setTimeout(function () {
      expect(countRows()).toEqual(6);
      expect(countCols()).toEqual(6);
      expect(getDataAtCell(5, 5)).toEqual('5');
      done();
    }, 200);
  });

  // https://github.com/handsontable/handsontable/issues/250
  it('should create new rows when pasting into grid with object data source', function (done) {
    handsontable({
      data: arrayOfNestedObjects(),
      colHeaders: true,
      columns: [{ data: 'id' }, { data: 'name.last' }, { data: 'name.first' }],
      minSpareRows: 1
    });
    selectCell(3, 0);
    triggerPaste('a\tb\tc\nd\te\tf\ng\th\ti');

    setTimeout(function () {
      expect(countRows()).toEqual(7);
      expect(getDataAtCell(5, 2)).toEqual('i');
      done();
    }, 200);
  });

  // https://handsontable.com/demo/datasources.html
  it('should work with functional data source', function () {
    handsontable({
      data: [model({ id: 1, name: 'Ted Right', address: '' }), model({ id: 2, name: 'Frank Honest', address: '' }), model({ id: 3, name: 'Joan Well', address: '' })],
      dataSchema: model,
      startRows: 5,
      startCols: 3,
      colHeaders: ['ID', 'Name', 'Address'],
      columns: [{ data: property('id') }, { data: property('name') }, { data: property('address') }],
      minSpareRows: 1
    });

    function model(opts) {
      var _pub = {},
          _priv = $.extend({
        id: undefined,
        name: undefined,
        address: undefined
      }, opts);

      _pub.attr = function (attr, val) {
        if (typeof val === 'undefined') {
          return _priv[attr];
        }
        _priv[attr] = val;

        return _pub;
      };

      return _pub;
    }

    function property(attr) {
      return function (row, value) {
        return row.attr(attr, value);
      };
    }

    expect(getDataAtCell(1, 1)).toEqual('Frank Honest');
    setDataAtCell(1, 1, 'Something Else');
    expect(getDataAtCell(1, 1)).toEqual('Something Else');
  });

  it('should accept changes array as 1st param and source as 2nd param', function () {
    var callCount = 0,
        lastSource = '';

    handsontable({
      afterChange: function afterChange(changes, source) {
        callCount++;
        lastSource = source;
      }
    });

    setDataAtCell([[0, 0, 'new value']], 'customSource');
    expect(getDataAtCell(0, 0)).toEqual('new value');
    expect(lastSource).toEqual('customSource');
  });

  it('should trigger `afterSetDataAtCell` hook with applied changes', function () {
    var _changes;
    var _source;

    handsontable({
      afterSetDataAtCell: function afterSetDataAtCell(changes, source) {
        _changes = changes;
        _source = source;
      }
    });

    setDataAtCell(0, 0, 'foo bar', 'customSource');

    expect(_changes).toEqual([[0, 0, null, 'foo bar']]);
    expect(_source).toBe('customSource');
    expect(getDataAtCell(0, 0)).toEqual('foo bar');
  });

  it('should modify value on the fly using `afterSetDataAtCell` hook', function () {
    handsontable({
      data: [['a', 'b', 'c'], [1, 2, 3]],
      afterSetDataAtCell: function afterSetDataAtCell(changes, source) {
        if (changes[0][3] === 'foo bar') {
          changes[0][3] = 'bar';
        }
        if (changes[0][3] === 22) {
          changes[0][3] = 33;
        }
      }
    });

    setDataAtCell(0, 0, 'foo bar', 'customSource');
    setDataAtCell(1, 2, 22, 'customSource');

    expect(getDataAtCell(0, 0)).toBe('bar');
    expect(getDataAtCell(1, 2)).toBe(33);
    expect(getData()).toEqual([['bar', 'b', 'c'], [1, 2, 33]]);
  });

  it('should trigger `afterSetDataAtRowProp` hook with applied changes', function () {
    var _changes;
    var _source;

    handsontable({
      columns: [{ data: 'name' }, { data: 'id' }],
      afterSetDataAtRowProp: function afterSetDataAtRowProp(changes, source) {
        _changes = changes;
        _source = source;
      }
    });

    setDataAtRowProp(0, 'name', 'foo bar', 'customSource');

    expect(_changes).toEqual([[0, 'name', void 0, 'foo bar']]);
    expect(_source).toBe('customSource');
    expect(getDataAtCell(0, 0)).toBe('foo bar');
  });

  it('should modify value on the fly using `afterSetDataAtRowProp` hook', function () {
    handsontable({
      data: [{ name: 'a', id: 1 }, { name: 'b', id: 2 }, { name: 'c', id: 3 }],
      columns: [{ data: 'name' }, { data: 'id' }],
      afterSetDataAtRowProp: function afterSetDataAtRowProp(changes, source) {
        if (changes[0][3] === 'foo bar') {
          changes[0][3] = 'bar';
        }
        if (changes[0][3] === 22) {
          changes[0][3] = 33;
        }
      }
    });

    setDataAtRowProp(0, 'name', 'foo bar', 'customSource');
    setDataAtRowProp(1, 'id', 22, 'customSource');

    expect(getDataAtRowProp(0, 'name')).toEqual('bar');
    expect(getDataAtRowProp(1, 'id')).toBe(33);
    expect(getData()).toEqual([['bar', 1], ['b', 33], ['c', 3]]);
  });
});

/***/ }),
/* 178 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_splice', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  var arrayOfArrays = function arrayOfArrays() {
    return [['', 'Kia', 'Nissan', 'Toyota', 'Honda'], ['2008', 10, 11, 12, 13], ['2009', 20, 11, 14, 13], ['2010', 30, 15, 12, 13]];
  };

  describe('spliceCol', function () {
    it('should remove data from specified col', function () {
      handsontable({
        data: arrayOfArrays(),
        minSpareRows: 1
      });

      expect(spliceCol(1, 0, 2)).toEqual(['Kia', 10]);
      expect(getData(0, 1, 3, 1)).toEqual([[20], [30], [null], [null]]);
    });

    it('should insert data into specified col', function () {
      handsontable({
        data: arrayOfArrays(),
        minSpareRows: 1
      });

      expect(spliceCol(1, 1, 0, 'test', 'test', 'test')).toEqual([]);
      expect(getData(0, 1, 6, 1)).toEqual([['Kia'], ['test'], ['test'], ['test'], [10], [20], [30]]);
    });

    it('should remove and insert data into specified col', function () {
      handsontable({
        data: arrayOfArrays(),
        minSpareRows: 1
      });

      expect(spliceCol(1, 0, 2, 'test', 'test', 'test')).toEqual(['Kia', 10]);
      expect(getData(0, 1, 4, 1)).toEqual([['test'], ['test'], ['test'], [20], [30]]);
    });
  });

  describe('spliceRow', function () {
    it('should remove data from specified row', function () {
      handsontable({
        data: arrayOfArrays(),
        minSpareCols: 1
      });

      expect(spliceRow(0, 0, 3)).toEqual(['', 'Kia', 'Nissan']);
      expect(getData(0, 0, 0, 4)).toEqual([['Toyota', 'Honda', null, null, null]]);
    });

    it('should insert data into specified row', function () {
      handsontable({
        data: arrayOfArrays(),
        minSpareCols: 1
      });

      expect(spliceRow(0, 0, 0, 'test', 'test', 'test')).toEqual([]);
      expect(getData(0, 0, 0, 7)).toEqual([['test', 'test', 'test', '', 'Kia', 'Nissan', 'Toyota', 'Honda']]);
    });

    it('should remove and insert data into specified row', function () {
      handsontable({
        data: arrayOfArrays(),
        minSpareCols: 1
      });

      expect(spliceRow(0, 0, 2, 'test', 'test', 'test')).toEqual(['', 'Kia']);
      expect(getData(0, 0, 0, 5)).toEqual([['test', 'test', 'test', 'Nissan', 'Toyota', 'Honda']]);
    });
  });
});

/***/ }),
/* 179 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_updateSettings', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should inherit cell type', function () {

    handsontable({
      data: [[1, 2]],
      columns: [{}, { type: 'checkbox' }],
      cells: function cells(row, col, prop) {
        if (row === 0 && col === 0) {
          return {
            type: 'numeric'
          };
        }
      }
    });

    expect(getCellMeta(0, 0).type).toEqual('numeric');
    expect(getCellMeta(0, 1).type).toEqual('checkbox');
  });

  it('should inherit cell type when columns is a function', function () {
    handsontable({
      data: [[1, 2]],
      columns: function columns(column) {
        var colMeta = null;

        if (column === 0) {
          colMeta = {};
        } else if (column === 1) {
          colMeta = { type: 'checkbox' };
        }

        return colMeta;
      },
      cells: function cells(row, col, prop) {
        if (row === 0 && col === 0) {
          return {
            type: 'numeric'
          };
        }
      }
    });

    expect(getCellMeta(0, 0).type).toEqual('numeric');
    expect(getCellMeta(0, 1).type).toEqual('checkbox');
  });

  it('should ignore mixed in properties to the cell array option', function () {
    /* eslint-disable no-array-constructor */
    /* eslint-disable no-extend-native */
    Array.prototype.willFail = 'BOOM';

    handsontable({
      data: [[1, true]],
      columns: [{ type: 'numeric' }, { type: 'checkbox' }]
    });

    expect(function () {
      updateSettings({ cell: new Array() });
    }).not.toThrow();
  });

  it('should ignore mixed in properties to the cell array option when columns is a function', function () {
    /* eslint-disable no-array-constructor */
    /* eslint-disable no-extend-native */
    Array.prototype.willFail = 'BOOM';

    handsontable({
      data: [[1, true]],
      columns: function columns(column) {
        var colMeta = null;

        if (column === 0) {
          colMeta = { type: 'numeric' };
        } else if (column === 1) {
          colMeta = { type: 'checkbox' };
        }

        return colMeta;
      }
    });

    expect(function () {
      updateSettings({ cell: new Array() });
    }).not.toThrow();
  });

  it('should not reset columns types to text', function () {
    handsontable({
      data: [[1, true]],
      columns: [{ type: 'numeric' }, { type: 'checkbox' }]
    });

    var td = this.$container.find('td');

    expect(td.eq(0).text()).toEqual('1');
    expect(td.eq(1).text()).toEqual('');

    updateSettings({});

    expect(td.eq(0).text()).toEqual('1');
    expect(td.eq(1).text()).toEqual('');
  });

  it('should not reset columns types to text when columns is a function', function () {
    handsontable({
      data: [[1, true]],
      columns: function columns(column) {
        var colMeta = null;

        if (column === 0) {
          colMeta = { type: 'numeric' };
        } else if (column === 1) {
          colMeta = { type: 'checkbox' };
        }

        return colMeta;
      }
    });

    var td = this.$container.find('td');

    expect(td.eq(0).text()).toEqual('1');
    expect(td.eq(1).text()).toEqual('');

    updateSettings({});

    expect(td.eq(0).text()).toEqual('1');
    expect(td.eq(1).text()).toEqual('');
  });

  it('should update readOnly global setting', function () {
    handsontable({
      readOnly: true,
      data: [['foo', 'bar']],
      columns: [{}, {}]
    });

    expect(getCellMeta(0, 0).readOnly).toBe(true);
    expect($(getCell(0, 0)).hasClass('htDimmed')).toBe(true);

    expect(getCellMeta(0, 1).readOnly).toBe(true);
    expect($(getCell(0, 1)).hasClass('htDimmed')).toBe(true);

    updateSettings({
      readOnly: false
    });

    expect(getCellMeta(0, 0).readOnly).toBe(false);
    expect($(getCell(0, 0)).hasClass('htDimmed')).toBe(false);

    expect(getCellMeta(0, 1).readOnly).toBe(false);
    expect($(getCell(0, 1)).hasClass('htDimmed')).toBe(false);
  });

  it('should update readOnly global setting when columns is a function', function () {
    handsontable({
      readOnly: true,
      data: [['foo', 'bar']],
      columns: function columns(column) {
        var colMeta = {};

        if ([0, 1].indexOf(column) < 0) {
          colMeta = null;
        }

        return colMeta;
      }
    });

    expect(getCellMeta(0, 0).readOnly).toBe(true);
    expect($(getCell(0, 0)).hasClass('htDimmed')).toBe(true);

    expect(getCellMeta(0, 1).readOnly).toBe(true);
    expect($(getCell(0, 1)).hasClass('htDimmed')).toBe(true);

    updateSettings({
      readOnly: false
    });

    expect(getCellMeta(0, 0).readOnly).toBe(false);
    expect($(getCell(0, 0)).hasClass('htDimmed')).toBe(false);

    expect(getCellMeta(0, 1).readOnly).toBe(false);
    expect($(getCell(0, 1)).hasClass('htDimmed')).toBe(false);
  });

  it('should update readOnly columns setting', function () {
    handsontable({
      data: [['foo', true]],
      columns: [{ type: 'text', readOnly: true }, { type: 'checkbox' }]
    });

    expect(getCellMeta(0, 0).readOnly).toBe(true);
    expect($(getCell(0, 0)).hasClass('htDimmed')).toBe(true);

    expect(getCellMeta(0, 1).readOnly).toBe(false);
    expect($(getCell(0, 1)).hasClass('htDimmed')).toBe(false);

    updateSettings({
      columns: [{ type: 'text', readOnly: false }, { type: 'checkbox' }]
    });

    expect(getCellMeta(0, 0).readOnly).toBe(false);
    expect($(getCell(0, 0)).hasClass('htDimmed')).toBe(false);

    expect(getCellMeta(0, 1).readOnly).toBe(false);
    expect($(getCell(0, 1)).hasClass('htDimmed')).toBe(false);
  });

  it('should update readOnly columns setting when columns is a function', function () {
    handsontable({
      data: [['foo', true]],
      columns: function columns(column) {
        var colMeta = null;

        if (column === 0) {
          colMeta = { type: 'text', readOnly: true };
        } else if (column === 1) {
          colMeta = { type: 'checkbox' };
        }

        return colMeta;
      }
    });

    expect(getCellMeta(0, 0).readOnly).toBe(true);
    expect($(getCell(0, 0)).hasClass('htDimmed')).toBe(true);

    expect(getCellMeta(0, 1).readOnly).toBe(false);
    expect($(getCell(0, 1)).hasClass('htDimmed')).toBe(false);

    updateSettings({
      columns: function columns(column) {
        var colMeta = null;

        if (column === 0) {
          colMeta = { type: 'text', readOnly: false };
        } else if (column === 1) {
          colMeta = { type: 'checkbox' };
        }

        return colMeta;
      }
    });

    expect(getCellMeta(0, 0).readOnly).toBe(false);
    expect($(getCell(0, 0)).hasClass('htDimmed')).toBe(false);

    expect(getCellMeta(0, 1).readOnly).toBe(false);
    expect($(getCell(0, 1)).hasClass('htDimmed')).toBe(false);
  });

  it('should update readOnly columns setting and override global setting', function () {
    handsontable({
      readOnly: true,
      data: [['foo', true]],
      columns: [{ type: 'text' }, { type: 'checkbox' }]
    });

    expect(getCellMeta(0, 0).readOnly).toBe(true);
    expect($(getCell(0, 0)).hasClass('htDimmed')).toBe(true);

    expect(getCellMeta(0, 1).readOnly).toBe(true);
    expect($(getCell(0, 1)).hasClass('htDimmed')).toBe(true);

    updateSettings({
      columns: [{ type: 'text', readOnly: false }, { type: 'checkbox' }]
    });

    expect(getCellMeta(0, 0).readOnly).toBe(false);
    expect($(getCell(0, 0)).hasClass('htDimmed')).toBe(false);

    expect(getCellMeta(0, 1).readOnly).toBe(true);
    expect($(getCell(0, 1)).hasClass('htDimmed')).toBe(true);
  });

  it('should update readOnly columns setting and override global setting when columns is a function', function () {
    handsontable({
      readOnly: true,
      data: [['foo', true]],
      columns: function columns(column) {
        var colMeta = null;

        if (column === 0) {
          colMeta = { type: 'text' };
        } else if (column === 1) {
          colMeta = { type: 'checkbox' };
        }

        return colMeta;
      }
    });

    expect(getCellMeta(0, 0).readOnly).toBe(true);
    expect($(getCell(0, 0)).hasClass('htDimmed')).toBe(true);

    expect(getCellMeta(0, 1).readOnly).toBe(true);
    expect($(getCell(0, 1)).hasClass('htDimmed')).toBe(true);

    updateSettings({
      columns: function columns(column) {
        var colMeta = null;

        if (column === 0) {
          colMeta = { type: 'text', readOnly: false };
        } else if (column === 1) {
          colMeta = { type: 'checkbox' };
        }

        return colMeta;
      }
    });

    expect(getCellMeta(0, 0).readOnly).toBe(false);
    expect($(getCell(0, 0)).hasClass('htDimmed')).toBe(false);

    expect(getCellMeta(0, 1).readOnly).toBe(true);
    expect($(getCell(0, 1)).hasClass('htDimmed')).toBe(true);
  });

  it('should not alter the columns object during init', function () {
    var columns = [{
      type: 'text'
    }];

    var columnsCopy = JSON.parse(JSON.stringify(columns));

    handsontable({
      columns: columns
    });

    expect(columns).toEqual(columnsCopy);
  });

  it('should update column type', function () {
    var columns = [{
      type: 'text'
    }];

    handsontable({
      columns: columns
    });

    expect(getCellMeta(0, 0).type).toEqual('text');
    expect(getCellRenderer(0, 0)).toBe(Handsontable.renderers.TextRenderer);
    expect(getCellEditor(0, 0)).toBe(Handsontable.editors.TextEditor);

    columns[0].type = 'date';

    updateSettings({
      columns: columns
    });

    expect(getCellMeta(0, 0).type).toEqual('date');
    expect(getCellRenderer(0, 0)).toBe(Handsontable.renderers.AutocompleteRenderer);
    expect(getCellEditor(0, 0)).toEqual(Handsontable.editors.DateEditor);
  });

  it('should update cell type functions, even if new type does not implement all of those functions', function () {
    var columns = [{
      type: 'numeric'
    }];

    handsontable({
      columns: columns
    });

    expect(getCellMeta(0, 0).type).toEqual('numeric');
    expect(getCellRenderer(0, 0)).toBe(Handsontable.renderers.NumericRenderer);
    expect(getCellEditor(0, 0)).toBe(Handsontable.editors.NumericEditor);
    expect(getCellValidator(0, 0)).toBe(Handsontable.cellTypes.numeric.validator);

    columns[0].type = 'text';

    updateSettings({
      columns: columns
    });

    expect(getCellMeta(0, 0).type).toEqual('text');
    expect(getCellRenderer(0, 0)).toBe(Handsontable.renderers.TextRenderer);
    expect(getCellEditor(0, 0)).toEqual(Handsontable.editors.TextEditor);
    expect(Handsontable.cellTypes.text.validator).toBeUndefined();
    expect(getCellValidator(0, 0)).toBeUndefined();
  });

  it('should allow updating the table height', function () {
    var hot = handsontable({
      startRows: 22,
      startCols: 5
    });

    var initialHeight = parseInt(this.$container[0].style.height, 10);

    updateSettings({
      height: 300
    });

    expect(parseInt(this.$container[0].style.height, 10)).toEqual(300);
    expect(parseInt(this.$container[0].style.height, 10)).not.toEqual(initialHeight);
  });

  it('should not reset the table height, when the updateSettings config object doesn\'t have any height specified', function () {
    var hot = handsontable({
      startRows: 22,
      startCols: 5,
      height: 300
    });

    var initialHeight = this.$container[0].style.height;

    updateSettings({
      rowHeaders: true
    });

    expect(parseInt(this.$container[0].style.height, 10)).toEqual(parseInt(initialHeight, 10));
  });

  it('should allow resetting the table height', function () {
    var hot = handsontable({
      startRows: 22,
      startCols: 5,
      height: 300
    });

    var initialHeight = this.$container[0].style.height;

    updateSettings({
      height: null
    });

    expect(parseInt(this.$container[0].style.height, 10)).not.toEqual(parseInt(initialHeight, 10));
  });

  it('should allow updating the stretching type', function () {
    var hot = handsontable({
      stretchH: 'last'
    });

    expect(hot.view.wt.getSetting('stretchH')).toEqual('last');

    updateSettings({
      stretchH: 'all'
    });

    expect(hot.view.wt.getSetting('stretchH')).toEqual('all');

    updateSettings({
      stretchH: 'none'
    });

    expect(hot.view.wt.getSetting('stretchH')).toEqual('none');

    updateSettings({
      stretchH: 'last'
    });

    expect(hot.view.wt.getSetting('stretchH')).toEqual('last');
  });

  it('should change colHeader\'s row height if is needed', function () {
    var hot = handsontable({
      colHeaders: true,
      rowHeaders: true
    });

    var rowHeights = [];

    rowHeights.push(this.$container.find('.ht_clone_top_left_corner thead th')[0].clientHeight);
    updateSettings({
      colHeaders: ['A<br/>A']
    });

    rowHeights.push(this.$container.find('.ht_clone_top_left_corner thead th')[0].clientHeight);

    expect(rowHeights[0]).toBeLessThan(rowHeights[1]);
  });

  it('should not overwrite properties (created by columns defined as function) of cells below the viewport by updateSettings #4029', function () {
    var rows = 50;
    var columns = 2;

    handsontable({
      data: Handsontable.helper.createSpreadsheetObjectData(columns, rows),
      columns: function columns(col) {
        var colProp = {
          data: 'prop' + col,
          readOnly: true
        };

        if (col === 1) {
          colProp.type = 'checkbox';
        }

        return colProp;
      }
    });

    updateSettings({});
    expect(getCellMeta(rows, 0).readOnly).toEqual(true);
    expect(getCellMeta(rows, 1).type).toEqual('checkbox');

    rows = 100;

    updateSettings({ data: Handsontable.helper.createSpreadsheetObjectData(columns, rows) });
    expect(getCellMeta(rows, 0).readOnly).toEqual(true);
    expect(getCellMeta(rows, 1).type).toEqual('checkbox');

    updateSettings({
      columns: function columns(col) {
        var colProp = {
          data: 'prop' + col,
          type: 'numeric'
        };

        return colProp;
      }
    });
    expect(getCellMeta(0, 1).type).toEqual('numeric');
    expect(getCellMeta(0, 1).readOnly).toEqual(false);
    expect(getCellMeta(rows, 1).type).toEqual('numeric');
    expect(getCellMeta(rows, 1).readOnly).toEqual(false);
  });

  it('should not overwrite properties (created by columns defined as array) of cells below the viewport by updateSettings #4029', function () {
    var rows = 50;
    var columns = 2;

    handsontable({
      data: Handsontable.helper.createSpreadsheetObjectData(columns, rows),
      columns: [{
        type: 'numeric',
        format: '0,0.00 $'
      }, {
        type: 'text',
        readOnly: true
      }]
    });

    updateSettings({});
    expect(getCellMeta(rows, 0).type).toEqual('numeric');
    expect(getCellMeta(rows, 1).readOnly).toEqual(true);

    rows = 100;

    updateSettings({ data: Handsontable.helper.createSpreadsheetObjectData(columns, rows) });
    expect(getCellMeta(rows, 0).type).toEqual('numeric');
    expect(getCellMeta(rows, 1).readOnly).toEqual(true);

    updateSettings({
      columns: [{
        type: 'text',
        readOnly: true
      }, {
        type: 'numeric',
        format: '0,0.00 $'
      }]
    });
    expect(getCellMeta(0, 0).type).toEqual('text');
    expect(getCellMeta(0, 0).readOnly).toEqual(true);
    expect(getCellMeta(0, 1).type).toEqual('numeric');
    expect(getCellMeta(0, 1).readOnly).toEqual(false);
    expect(getCellMeta(rows, 0).type).toEqual('text');
    expect(getCellMeta(rows, 1).type).toEqual('numeric');
  });
});

/***/ }),
/* 180 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_validate', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  var arrayOfObjects = function arrayOfObjects() {
    return [{ id: 1, name: 'Ted', lastName: 'Right' }, { id: 2, name: 'Frank', lastName: 'Honest' }, { id: 3, name: 'Joan', lastName: 'Well' }, { id: 4, name: 'Sid', lastName: 'Strong' }, { id: 5, name: 'Jane', lastName: 'Neat' }, { id: 6, name: 'Chuck', lastName: 'Jackson' }, { id: 7, name: 'Meg', lastName: 'Jansen' }, { id: 8, name: 'Rob', lastName: 'Norris' }, { id: 9, name: 'Sean', lastName: 'O\'Hara' }, { id: 10, name: 'Eve', lastName: 'Branson' }];
  };

  it('should call beforeValidate', function () {
    var fired = null;

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', type: 'numeric' }, { data: 'name' }, { data: 'lastName' }],
      beforeValidate: function beforeValidate() {
        fired = true;
      }
    });
    setDataAtCell(2, 0, 'test');

    expect(fired).toEqual(true);
  });

  it('should call beforeValidate when columns is a function', function () {
    var fired = null;

    handsontable({
      data: arrayOfObjects(),
      columns: function columns(column) {
        var colMeta = {};

        if (column === 0) {
          colMeta.data = 'id';
          colMeta.type = 'numeric';
        } else if (column === 1) {
          colMeta.data = 'name';
        } else if (column === 2) {
          colMeta.data = 'lastName';
        } else {
          colMeta = null;
        }

        return colMeta;
      },
      beforeValidate: function beforeValidate() {
        fired = true;
      }
    });
    setDataAtCell(2, 0, 'test');

    expect(fired).toBe(true);
  });

  it('should call afterValidate', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', type: 'numeric' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });
    setDataAtCell(2, 0, 'test');

    setTimeout(function () {
      expect(onAfterValidate.calls.count()).toBe(1);
      done();
    }, 200);
  });

  it('should call afterValidate when columns is a function', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: function columns(column) {
        var colMeta = {};

        if (column === 0) {
          colMeta.data = 'id';
          colMeta.type = 'numeric';
        } else if (column === 1) {
          colMeta.data = 'name';
        } else if (column === 2) {
          colMeta.data = 'lastName';
        } else {
          colMeta = null;
        }

        return colMeta;
      },

      afterValidate: onAfterValidate
    });
    setDataAtCell(2, 0, 'test');

    setTimeout(function () {
      expect(onAfterValidate.calls.count()).toBe(1);
      done();
    }, 200);
  });

  it('beforeValidate can manipulate value', function (done) {
    var result = null;
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    onAfterValidate.and.callFake(function (valid, value) {
      result = value;
    });

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', type: 'numeric' }, { data: 'name' }, { data: 'lastName' }],
      beforeValidate: function beforeValidate(value) {
        value = 999;
        return value;
      },

      afterValidate: onAfterValidate
    });
    setDataAtCell(2, 0, 123);

    setTimeout(function () {
      expect(result).toBe(999);
      done();
    }, 200);
  });

  it('beforeValidate can manipulate value when columns is a function', function (done) {
    var result = null;
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    onAfterValidate.and.callFake(function (valid, value) {
      result = value;
    });

    handsontable({
      data: arrayOfObjects(),
      columns: function columns(column) {
        var colMeta = {};

        if (column === 0) {
          colMeta.data = 'id';
          colMeta.type = 'numeric';
        } else if (column === 1) {
          colMeta.data = 'name';
        } else if (column === 2) {
          colMeta.data = 'lastName';
        } else {
          colMeta = null;
        }

        return colMeta;
      },
      beforeValidate: function beforeValidate(value) {
        value = 999;
        return value;
      },

      afterValidate: onAfterValidate
    });
    setDataAtCell(2, 0, 123);

    setTimeout(function () {
      expect(result).toBe(999);
      done();
    }, 200);
  });

  it('should be able to define custom validator function', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id',
        validator: function validator(value, cb) {
          cb(true);
        }
      }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });
    setDataAtCell(2, 0, 123);

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(true, 123, 2, 'id', undefined, undefined);
      done();
    }, 200);
  });

  it('should be able to define custom validator function when columns is a function', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: function columns(column) {
        var colMeta = null;

        if (column === 0) {
          colMeta = {
            data: 'id',
            validator: function validator(value, cb) {
              cb(true);
            }
          };
        } else if (column === 1) {
          colMeta = { data: 'name' };
        } else if (column === 2) {
          colMeta = { data: 'lastName' };
        }

        return colMeta;
      },

      afterValidate: onAfterValidate
    });
    setDataAtCell(2, 0, 123);

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(true, 123, 2, 'id', undefined, undefined);
      done();
    }, 200);
  });

  it('should be able to define custom validator RegExp', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', validator: /^\d+$/ }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(2, 0, 'test');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(false, 'test', 2, 'id', undefined, undefined);
      done();
    }, 200);
  });

  it('should be able to define custom validator RegExp when columns is a function', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: function columns(column) {
        var colMeta = null;

        if (column === 0) {
          colMeta = { data: 'id', validator: /^\d+$/ };
        } else if (column === 1) {
          colMeta = { data: 'name' };
        } else if (column === 2) {
          colMeta = { data: 'lastName' };
        }

        return colMeta;
      },

      afterValidate: onAfterValidate
    });
    setDataAtCell(2, 0, 'test');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(false, 'test', 2, 'id', undefined, undefined);
      done();
    }, 200);
  });

  it('this in validator should point to cellProperties', function (done) {
    var result = null;
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{
        data: 'id',
        validator: function validator(value, cb) {
          result = this;
          cb(true);
        }
      }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });
    setDataAtCell(2, 0, 123);

    setTimeout(function () {
      expect(result.instance).toEqual(getInstance());
      done();
    }, 200);
  });

  it('this in validator should point to cellProperties when columns is a function', function (done) {
    var result = null;
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: function columns(column) {
        var colMeta = null;

        if (column === 0) {
          colMeta = {
            data: 'id',
            validator: function validator(value, cb) {
              result = this;
              cb(true);
            }
          };
        } else if (column === 1) {
          colMeta = { data: 'name' };
        } else if (column === 2) {
          colMeta = { data: 'lastName' };
        }

        return colMeta;
      },

      afterValidate: onAfterValidate
    });
    setDataAtCell(2, 0, 123);

    setTimeout(function () {
      expect(result.instance).toEqual(getInstance());
      done();
    }, 200);
  });

  it('should not throw error after calling validateCells without first argument', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(2, 2),
      validator: function validator(value, callb) {
        if (value == 'B1') {
          callb(false);
        } else {
          callb(true);
        }
      },

      afterValidate: onAfterValidate
    });

    expect(hot.validateCells).not.toThrow();

    setTimeout(function () {
      expect(spec().$container.find('td.htInvalid').length).toEqual(1);
      expect(spec().$container.find('td:not(.htInvalid)').length).toEqual(3);
      done();
    }, 200);
  });

  it('should add class name `htInvalid` to an cell that does not validate - on validateCells', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(2, 2),
      validator: function validator(value, callb) {
        if (value == 'B1') {
          callb(false);
        } else {
          callb(true);
        }
      },

      afterValidate: onAfterValidate
    });

    hot.validateCells(function () {
      hot.render();
    });

    setTimeout(function () {
      expect(spec().$container.find('td.htInvalid').length).toEqual(1);
      expect(spec().$container.find('td:not(.htInvalid)').length).toEqual(3);
      done();
    }, 200);
  });

  it('should add class name `htInvalid` to an cell that does not validate - when we trigger validateCell', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(2, 2),
      validator: function validator(value, cb) {
        cb(false);
      },

      afterValidate: onAfterValidate
    });

    expect(this.$container.find('td:not(.htInvalid)').length).toEqual(4);

    hot.validateCell(hot.getDataAtCell(1, 1), hot.getCellMeta(1, 1), function () {});

    setTimeout(function () {
      expect(spec().$container.find('td.htInvalid').length).toEqual(1);
      expect(spec().$container.find('td:not(.htInvalid)').length).toEqual(3);
      done();
    }, 200);
  });

  it('should remove class name `htInvalid` from an cell that does validate - when we change validator rules', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');
    var isValid = false;
    var _validator = function _validator() {
      return isValid;
    };
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(2, 2),
      validator: function validator(value, cb) {
        cb(_validator());
      },

      afterValidate: onAfterValidate
    });

    hot.validateCells(function () {});

    setTimeout(function () {
      expect(spec().$container.find('td.htInvalid').length).toEqual(4);
      expect(spec().$container.find('td:not(.htInvalid)').length).toEqual(0);

      isValid = true;
      onAfterValidate.calls.reset();
      hot.validateCell(hot.getDataAtCell(1, 1), hot.getCellMeta(1, 1), function () {});
    }, 200);

    setTimeout(function () {
      expect(spec().$container.find('td.htInvalid').length).toEqual(3);
      expect(spec().$container.find('td:not(.htInvalid)').length).toEqual(1);
      done();
    }, 400);
  });

  it('should add class name `htInvalid` to an cell that does not validate - on edit', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(2, 2),
      validator: function validator(value, callb) {
        if (value == 'test') {
          callb(false);
        } else {
          callb(true);
        }
      },

      afterValidate: onAfterValidate
    });

    setDataAtCell(0, 0, 'test');

    setTimeout(function () {
      expect(spec().$container.find('td.htInvalid').length).toEqual(1);
      expect(spec().$container.find('tr:eq(0) td:eq(0)').hasClass('htInvalid')).toEqual(true);
      done();
    }, 200);
  });

  it('should add class name `htInvalid` to a cell without removing other classes', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');
    var validator = jasmine.createSpy('validator');

    validator.and.callFake(function (value, callb) {
      if (value == 123) {
        callb(false);
      } else {
        callb(true);
      }
    });

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(2, 2),
      type: 'numeric',
      validator: validator,
      afterValidate: onAfterValidate
    });
    setDataAtCell(0, 0, 123);

    setTimeout(function () {
      expect(validator.calls.count()).toEqual(1);
      expect(spec().$container.find('tr:eq(0) td:eq(0)').hasClass('htInvalid')).toEqual(true);
      expect(spec().$container.find('tr:eq(0) td:eq(0)').hasClass('htNumeric')).toEqual(true);
      onAfterValidate.calls.reset();
      setDataAtCell(0, 0, 124);
    }, 200);

    setTimeout(function () {
      expect(spec().$container.find('tr:eq(0) td:eq(0)').hasClass('htInvalid')).toEqual(false);
      expect(spec().$container.find('tr:eq(0) td:eq(0)').hasClass('htNumeric')).toEqual(true);
      done();
    }, 400);
  });

  it('should add class name `htInvalid` to an cell that does not validate - after validateCells', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(2, 2),
      afterValidate: onAfterValidate
    });

    setDataAtCell(0, 0, 'test');

    setTimeout(function () {
      expect(spec().$container.find('td.htInvalid').length).toEqual(0);
      updateSettings({
        validator: function validator(value, callb) {
          if (value == 'test') {
            callb(false);
          } else {
            callb(true);
          }
        }
      });

      onAfterValidate.calls.reset();

      hot.validateCells(function () {});
    }, 200);

    setTimeout(function () {
      expect(spec().$container.find('td.htInvalid').length).toEqual(1);
      expect(spec().$container.find('tr:eq(0) td:eq(0)').hasClass('htInvalid')).toEqual(true);
      done();
    }, 400);
  });

  it('should remove class name `htInvalid` when cell is edited to validate', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(2, 2),
      validator: function validator(value, callb) {
        if (value == 'A1') {
          callb(false);
        } else {
          callb(true);
        }
      },

      afterValidate: onAfterValidate
    });

    hot.validateCells(function () {
      hot.render();
    });

    setTimeout(function () {
      expect(spec().$container.find('tr:eq(0) td:eq(0)').hasClass('htInvalid')).toEqual(true);
      onAfterValidate.calls.reset();
      setDataAtCell(0, 0, 'test');
    }, 200);

    setTimeout(function () {
      expect(spec().$container.find('tr:eq(0) td:eq(0)').hasClass('htInvalid')).toEqual(false);
      done();
    }, 400);
  });

  it('should call callback with first argument as `true` if all cells are valid', function (done) {
    var onValidate = jasmine.createSpy('onValidate');
    var onAfterValidate = jasmine.createSpy('onAfterValidate');
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(2, 2),
      validator: function validator(value, callback) {
        callback(true);
      },

      afterValidate: onAfterValidate
    });

    hot.validateCells(onValidate);

    setTimeout(function () {
      expect(onValidate).toHaveBeenCalledWith(true);
      done();
    }, 200);
  });

  it('should call callback with first argument as `false` if one of cells is invalid', function (done) {
    var onValidate = jasmine.createSpy('onValidate');
    var onAfterValidate = jasmine.createSpy('onAfterValidate');
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(2, 2),
      validator: function validator(value, callback) {
        callback(false);
      },

      afterValidate: onAfterValidate
    });

    hot.validateCells(onValidate);

    setTimeout(function () {
      expect(onValidate).toHaveBeenCalledWith(false);
      done();
    }, 200);
  });

  it('should not allow for changes where data is invalid (multiple changes, async)', function (done) {
    var validatedChanges;

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 2),
      allowInvalid: false,
      validator: function validator(value, callb) {
        setTimeout(function () {
          if (value === 'fail') {
            callb(false);
          } else {
            callb(true);
          }
        }, 10);
      },
      afterChange: function afterChange(changes, source) {
        if (source !== 'loadData') {
          validatedChanges = changes;
        }
      }
    });

    populateFromArray(0, 0, [['A1-new'], ['fail'], ['A3-new']]);

    setTimeout(function () {
      expect(validatedChanges.length).toEqual(2);
      expect(validatedChanges[0]).toEqual([0, 0, 'A1', 'A1-new']);
      expect(validatedChanges[1]).toEqual([2, 0, 'A3', 'A3-new']);
      expect(getDataAtCell(0, 0)).toEqual('A1-new');
      expect(getDataAtCell(1, 0)).toEqual('A2');
      expect(getDataAtCell(2, 0)).toEqual('A3-new');
      expect(getCellMeta(0, 0).valid).toBe(true);
      expect(getCellMeta(1, 0).valid).toBe(true);
      expect(getCellMeta(2, 0).valid).toBe(true);
      done();
    }, 200);
  });

  it('should call beforeChange exactly once after cell value edit and validator is synchronous', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');
    var onBeforeChange = jasmine.createSpy('onBeforeChange');
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 2),
      allowInvalid: false,
      validator: function validator(value, callback) {
        callback(true);
      },

      beforeChange: onBeforeChange,
      afterValidate: onAfterValidate
    });

    expect(onBeforeChange.calls.count()).toEqual(0);

    hot.setDataAtCell(0, 0, 10);

    setTimeout(function () {
      expect(onBeforeChange.calls.count()).toEqual(1);
      done();
    }, 200);
  });

  it('should call beforeChange exactly once after cell value edit and validator is asynchronous', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');
    var onBeforeChange = jasmine.createSpy('onBeforeChange');
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 2),
      allowInvalid: false,
      validator: function validator(value, callback) {
        setTimeout(function () {
          callback(true);
        }, 10);
      },

      beforeChange: onBeforeChange,
      afterValidate: onAfterValidate
    });

    expect(onBeforeChange.calls.count()).toEqual(0);

    hot.setDataAtCell(0, 0, 10);

    setTimeout(function () {
      expect(onBeforeChange.calls.count()).toEqual(1);
      done();
    }, 200);
  });

  it('should call afterChange exactly once after cell value edit and validator is synchronous', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');
    var onAfterChange = jasmine.createSpy('onAfterChange');
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 2),
      allowInvalid: false,
      validator: function validator(value, callback) {
        callback(true);
      },

      afterChange: onAfterChange,
      afterValidate: onAfterValidate
    });

    expect(onAfterChange.calls.count()).toEqual(1); // loadData

    hot.setDataAtCell(0, 0, 10);

    setTimeout(function () {
      expect(onAfterChange.calls.count()).toEqual(2);
      done();
    }, 200);
  });

  it('should call afterChange exactly once after cell value edit and validator is asynchronous', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');
    var onAfterChange = jasmine.createSpy('onAfterChange');
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 2),
      allowInvalid: false,
      validator: function validator(value, callback) {
        setTimeout(function () {
          callback(true);
        }, 10);
      },

      afterChange: onAfterChange,
      afterValidate: onAfterValidate
    });

    expect(onAfterChange.calls.count()).toEqual(1); // loadData

    hot.setDataAtCell(0, 0, 10);

    setTimeout(function () {
      expect(onAfterChange.calls.count()).toEqual(2);
      done();
    }, 200);
  });

  it('edited cell should stay on screen until value is validated', function (done) {
    var isEditorVisibleBeforeChange;
    var isEditorVisibleAfterChange;
    var onAfterValidate = jasmine.createSpy('onAfterValidate');
    var onAfterChange = jasmine.createSpy('onAfterChange');

    onAfterValidate.and.callFake(function () {
      isEditorVisibleBeforeChange = isEditorVisible();
    });
    onAfterChange.and.callFake(function () {
      isEditorVisibleAfterChange = isEditorVisible();
    });

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 2),
      allowInvalid: false,
      afterValidate: onAfterValidate,
      afterChange: onAfterChange,
      validator: function validator(value, callback) {
        setTimeout(function () {
          callback(true);
        }, 100);
      }
    });

    selectCell(0, 0);
    keyDown('enter');
    document.activeElement.value = 'Ted';

    onAfterValidate.calls.reset();
    onAfterChange.calls.reset();

    keyDown('enter');

    expect(document.activeElement.nodeName).toEqual('TEXTAREA');

    setTimeout(function () {
      expect(isEditorVisibleBeforeChange).toBe(true);
      expect(isEditorVisibleAfterChange).toBe(true);
      expect(isEditorVisible()).toBe(false);
      done();
    }, 200);
  });

  it('should validate edited cell after selecting another cell', function (done) {
    var validated = false;
    var validatedValue;

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 2),
      allowInvalid: false,
      validator: function validator(value, callback) {
        setTimeout(function () {
          validated = true;
          validatedValue = value;
          callback(true);
        }, 100);
      }
    });

    selectCell(0, 0);
    keyDown('enter');

    document.activeElement.value = 'Ted';

    selectCell(0, 1);

    setTimeout(function () {
      expect(validatedValue).toEqual('Ted');
      done();
    }, 200);
  });

  it('should leave the new value in editor if it does not validate (async validation), after hitting ENTER', function (done) {
    var validated = false;
    var validationResult;

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 2),
      allowInvalid: false,
      validator: function validator(value, callback) {
        setTimeout(function () {
          validated = true;
          validationResult = value.length == 2;
          callback(validationResult);
        }, 100);
      }
    });

    selectCell(0, 0);
    keyDown('enter');

    document.activeElement.value = 'Ted';

    keyDown('enter');

    setTimeout(function () {
      expect(validationResult).toBe(false);
      expect(document.activeElement.value).toEqual('Ted');
      done();
    }, 200);
  });

  it('should leave the new value in editor if it does not validate (sync validation), after hitting ENTER', function (done) {
    var validated = false;
    var validationResult;

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 2),
      allowInvalid: false,
      validator: function validator(value, callback) {
        validated = true;
        validationResult = value.length == 2;
        callback(validationResult);
      }
    });

    selectCell(0, 0);
    keyDown('enter');

    document.activeElement.value = 'Ted';

    keyDown('enter');

    setTimeout(function () {
      expect(validationResult).toBe(false);
      expect(document.activeElement.value).toEqual('Ted');
      done();
    }, 200);
  });

  it('should leave the new value in editor if it does not validate (async validation), after selecting another cell', function (done) {
    var validated = false;
    var validationResult;

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 2),
      allowInvalid: false,
      validator: function validator(value, callback) {
        setTimeout(function () {
          setTimeout(function () {
            validated = true;
          }, 0);

          validationResult = value.length == 2;
          callback(validationResult);
        }, 100);
      }
    });
    selectCell(0, 0);
    keyDown('enter');

    document.activeElement.value = 'Ted';

    selectCell(1, 0);

    setTimeout(function () {
      expect(validationResult).toBe(false);
      expect(document.activeElement.value).toEqual('Ted');
      done();
    }, 200);
  });

  it('should leave the new value in editor if it does not validate (sync validation), after selecting another cell', function (done) {
    var validated = false;
    var validationResult;

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 2),
      allowInvalid: false,
      validator: function validator(value, callback) {
        validationResult = value.length == 2;
        callback(validationResult);

        /* Setting this variable has to be async, because we are not interested in when the validation happens, but when
         the callback is being called. Since internally all the callbacks are processed asynchronously (even if they are
         synchronous) end of validator function is not the equivalent of whole validation routine end.
         If it still sounds weird, take a look at HandsontableTextEditorClass.prototype.finishEditing method.
         */

        setTimeout(function () {
          validated = true;
        }, 0);
      }
    });
    selectCell(0, 0);
    keyDown('enter');

    document.activeElement.value = 'Ted';

    selectCell(1, 0);

    setTimeout(function () {
      expect(validationResult).toBe(false);
      expect(document.activeElement.value).toEqual('Ted');
      done();
    }, 200);
  });

  it('should close the editor and save the new value if validation fails and allowInvalid is set to "true"', function (done) {
    var validated = false;
    var validationResult;

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 2),
      allowInvalid: true,
      validator: function validator(value, callback) {
        setTimeout(function () {

          validated = true;
          validationResult = value.length == 2;
          callback(validationResult);
        }, 100);
      }
    });
    selectCell(0, 0);
    keyDown('enter');

    document.activeElement.value = 'Ted';

    selectCell(1, 0);

    setTimeout(function () {
      expect(validationResult).toBe(false);
      expect(getDataAtCell(0, 0)).toEqual('Ted');
      expect(getCell(0, 0).className).toMatch(/htInvalid/);
      done();
    }, 200);
  });

  it('should close the editor and save the new value after double clicking on a cell, if the previously edited cell validated correctly', function (done) {
    var validated = false;
    var validationResult;

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 2),
      allowInvalid: false,
      validator: function validator(value, callback) {
        setTimeout(function () {

          validated = true;
          validationResult = value.length == 2;
          callback(validationResult);
        }, 100);
      }
    });

    selectCell(0, 0);
    keyDown('enter');

    var editor = $('.handsontableInputHolder');
    expect(editor.is(':visible')).toBe(true);

    document.activeElement.value = 'AA';

    expect(document.activeElement.value).toEqual('AA');

    var cell = $(getCell(1, 0));
    var clicks = 0;

    setTimeout(function () {
      mouseDown(cell);
      mouseUp(cell);
      clicks++;
    }, 0);

    setTimeout(function () {
      mouseDown(cell);
      mouseUp(cell);
      clicks++;
    }, 100);

    setTimeout(function () {
      expect(editor.is(':visible')).toBe(false);
      expect(validationResult).toBe(true);
      expect(getDataAtCell(0, 0)).toEqual('AA');
      done();
    }, 300);
  });

  it('should close the editor and restore the original value after double clicking on a cell, if the previously edited cell have not validated', function (done) {
    var validated = false;
    var validationResult;

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 2),
      allowInvalid: false,
      validator: function validator(value, callback) {
        setTimeout(function () {
          validated = true;
          validationResult = value.length == 2;
          callback(validationResult);
        }, 100);
      }
    });
    selectCell(0, 0);
    keyDown('enter');

    document.activeElement.value = 'AAA';

    expect(document.activeElement.value).toEqual('AAA');

    var cell = $(getCell(1, 0));
    var clicks = 0;

    setTimeout(function () {
      mouseDown(cell);
      mouseUp(cell);
      clicks++;
    }, 0);

    setTimeout(function () {
      mouseDown(cell);
      mouseUp(cell);
      clicks++;
    }, 100);

    setTimeout(function () {
      expect(validationResult).toBe(false);
      expect(getDataAtCell(0, 0)).toEqual('A1');
      done();
    }, 300);
  });

  it('should listen to key changes after cell is corrected (allowInvalid: false)', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      allowInvalid: false,
      columns: [{ data: 'id',
        type: 'numeric',
        validator: function validator(val, cb) {
          cb(parseInt(val, 10) > 100);
        }
      }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });
    selectCell(2, 0);

    keyDownUp('enter');
    document.activeElement.value = '99';

    onAfterValidate.calls.reset();

    keyDownUp('enter'); // should be ignored

    setTimeout(function () {
      expect(isEditorVisible()).toBe(true);
      document.activeElement.value = '999';

      onAfterValidate.calls.reset();
      keyDownUp('enter'); // should be accepted
    }, 200);

    setTimeout(function () {
      expect(isEditorVisible()).toBe(false);
      expect(getSelected()).toEqual([3, 0, 3, 0]);

      keyDownUp('arrow_up');
      expect(getSelected()).toEqual([2, 0, 2, 0]);
      done();
    }, 400);
  });

  it('should allow keyboard movement when cell is being validated (move DOWN)', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      allowInvalid: false,
      columns: [{ data: 'id',
        type: 'numeric',
        validator: function validator(val, cb) {
          setTimeout(function () {
            cb(parseInt(val, 10) > 100);
          }, 100);
        }
      }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });
    selectCell(2, 0);

    keyDownUp('enter');
    document.activeElement.value = '999';
    keyDownUp('enter');

    expect(getSelected()).toEqual([3, 0, 3, 0]);

    keyDownUp('arrow_down');
    keyDownUp('arrow_down');
    expect(isEditorVisible()).toBe(true);
    expect(getSelected()).toEqual([5, 0, 5, 0]);

    setTimeout(function () {
      expect(isEditorVisible()).toBe(false);
      expect(getSelected()).toEqual([5, 0, 5, 0]); // only enterMove and first arrow_down is performed
      done();
    }, 200);
  });

  it('should not allow keyboard movement until cell is validated (move UP)', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      allowInvalid: false,
      columns: [{ data: 'id',
        type: 'numeric',
        validator: function validator(val, cb) {
          setTimeout(function () {
            cb(parseInt(val, 10) > 100);
          }, 100);
        }
      }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    selectCell(2, 0);

    keyDownUp('enter');
    document.activeElement.value = '999';
    keyDownUp('enter');

    expect(getSelected()).toEqual([3, 0, 3, 0]);

    keyDownUp('arrow_up');
    keyDownUp('arrow_up');
    expect(isEditorVisible()).toBe(true);
    expect(getSelected()).toEqual([1, 0, 1, 0]);

    setTimeout(function () {
      expect(isEditorVisible()).toBe(false);
      expect(getSelected()).toEqual([1, 0, 1, 0]);
      done();
    }, 200);
  });

  it('should not allow keyboard movement until cell is validated (move RIGHT)', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      allowInvalid: false,
      columns: [{ data: 'id',
        type: 'numeric',
        validator: function validator(val, cb) {
          setTimeout(function () {
            cb(parseInt(val, 10) > 100);
          }, 100);
        }
      }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    selectCell(2, 0);

    keyDownUp('enter');
    document.activeElement.value = '999';
    keyDownUp('enter'); // should be accepted but only after 100 ms
    expect(getSelected()).toEqual([3, 0, 3, 0]);

    keyDownUp('arrow_right');
    keyDownUp('arrow_right');
    expect(isEditorVisible()).toBe(true);
    expect(getSelected()).toEqual([3, 2, 3, 2]);

    setTimeout(function () {
      expect(isEditorVisible()).toBe(false);
      expect(getSelected()).toEqual([3, 2, 3, 2]);
      done();
    }, 200);
  });

  it('should not allow keyboard movement until cell is validated (move LEFT)', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    hot = handsontable({
      data: arrayOfObjects(),
      allowInvalid: false,
      columns: [{ data: 'name' }, { data: 'lastName' }, { data: 'id',
        type: 'numeric',
        validator: function validator(val, cb) {
          setTimeout(function () {
            cb(parseInt(val, 10) > 100);
          }, 100);
        }
      }],
      afterValidate: onAfterValidate
    });

    selectCell(2, 2);

    keyDownUp('enter');
    document.activeElement.value = '999';
    keyDownUp('enter'); // should be accepted but only after 100 ms
    expect(getSelected()).toEqual([3, 2, 3, 2]);

    this.$container.simulate('keydown', { keyCode: Handsontable.helper.KEY_CODES.ARROW_LEFT });
    this.$container.simulate('keyup', { keyCode: Handsontable.helper.KEY_CODES.ARROW_LEFT });
    this.$container.simulate('keydown', { keyCode: Handsontable.helper.KEY_CODES.ARROW_LEFT });
    this.$container.simulate('keyup', { keyCode: Handsontable.helper.KEY_CODES.ARROW_LEFT });

    expect(isEditorVisible()).toBe(true);
    expect(getSelected()).toEqual([3, 0, 3, 0]);

    setTimeout(function () {
      expect(isEditorVisible()).toBe(false);
      expect(getSelected()).toEqual([3, 0, 3, 0]);
      done();
    }, 200);
  });

  it('should not validate cell if editing has been canceled', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    selectCell(0, 0);
    keyDownUp(Handsontable.helper.KEY_CODES.ENTER); // open editor
    keyDownUp(Handsontable.helper.KEY_CODES.ESCAPE); // cancel editing

    setTimeout(function () {
      expect(onAfterValidate).not.toHaveBeenCalled();
      done();
    }, 100);
  });

  it('should not validate cell if editing has been canceled when columns is a function', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: function columns(column) {
        var colMeta = null;

        if (column === 0) {
          colMeta = { data: 'id' };
        } else if (column === 1) {
          colMeta = { data: 'name' };
        } else if (column === 2) {
          colMeta = { data: 'lastName' };
        }

        return colMeta;
      },

      afterValidate: onAfterValidate
    });

    selectCell(0, 0);
    keyDownUp(Handsontable.helper.KEY_CODES.ENTER); // open editor
    keyDownUp(Handsontable.helper.KEY_CODES.ESCAPE); // cancel editing

    setTimeout(function () {
      expect(onAfterValidate).not.toHaveBeenCalled();
      done();
    }, 100);
  });

  it('should leave cell invalid if editing has been canceled', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id',
        validator: function validator(value, cb) {
          cb(false);
        }
      }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(0, 0, 'foo');

    setTimeout(function () {
      expect(getCellMeta(0, 0).valid).toBe(false);

      selectCell(0, 0);
      keyDownUp(Handsontable.helper.KEY_CODES.ENTER); // open editor
      keyDownUp(Handsontable.helper.KEY_CODES.ESCAPE); // cancel editing

      expect(getCellMeta(0, 0).valid).toBe(false);
      done();
    }, 200);
  });

  it('should leave cell invalid if editing has been canceled when columns is a function', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: function columns(column) {
        var colMeta = null;

        if (column === 0) {
          colMeta = {
            data: 'id',
            validator: function validator(value, cb) {
              cb(false);
            }
          };
        } else if (column === 1) {
          colMeta = { data: 'name' };
        } else if (column === 2) {
          colMeta = { data: 'lastName' };
        }

        return colMeta;
      },

      afterValidate: onAfterValidate
    });

    setDataAtCell(0, 0, 'foo');

    setTimeout(function () {
      expect(getCellMeta(0, 0).valid).toBe(false);

      selectCell(0, 0);
      keyDownUp(Handsontable.helper.KEY_CODES.ENTER); // open editor
      keyDownUp(Handsontable.helper.KEY_CODES.ESCAPE); // cancel editing

      expect(getCellMeta(0, 0).valid).toBe(false);
      done();
    }, 200);
  });

  it('should open an appropriate editor after cell value is valid again', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    var hot = handsontable({
      data: arrayOfObjects(),
      columns: [{
        data: 'id',
        validator: function validator(value, cb) {
          cb(value == parseInt(value, 10));
        },

        allowInvalid: false
      }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    selectCell(0, 0);

    var activeEditor = hot.getActiveEditor();

    expect(activeEditor.row).toEqual(0);
    expect(activeEditor.col).toEqual(0);

    keyDownUp(Handsontable.helper.KEY_CODES.ENTER); // open editor
    activeEditor.setValue('foo');
    keyDownUp(Handsontable.helper.KEY_CODES.ENTER); // save changes, close editor

    setTimeout(function () {
      onAfterValidate.calls.reset();
      activeEditor = hot.getActiveEditor();

      expect(activeEditor.isOpened()).toBe(true); // value is invalid, so editor stays opened
      expect(activeEditor.row).toEqual(0);
      expect(activeEditor.col).toEqual(0);

      activeEditor.setValue(2);

      keyDownUp(Handsontable.helper.KEY_CODES.ENTER); // save changes and move to cell below (row: 1, col: ś0)
    }, 200);

    setTimeout(function () {
      keyDownUp(Handsontable.helper.KEY_CODES.ENTER); // open editor

      activeEditor = hot.getActiveEditor();
      expect(activeEditor.row).toEqual(1);
      expect(activeEditor.col).toEqual(0);
      done();
    }, 400);
  });

  it('should open an appropriate editor after cell value is valid again when columns is a function', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    var hot = handsontable({
      data: arrayOfObjects(),
      columns: function columns(column) {
        var colMeta = null;

        if (column === 0) {
          colMeta = {
            data: 'id',
            validator: function validator(value, cb) {
              cb(value == parseInt(value, 10));
            },

            allowInvalid: false
          };
        } else if (column === 1) {
          colMeta = { data: 'name' };
        } else if (column === 2) {
          colMeta = { data: 'lastName' };
        }

        return colMeta;
      },

      afterValidate: onAfterValidate
    });

    selectCell(0, 0);

    var activeEditor = hot.getActiveEditor();

    expect(activeEditor.row).toEqual(0);
    expect(activeEditor.col).toEqual(0);

    keyDownUp(Handsontable.helper.KEY_CODES.ENTER); // open editor
    activeEditor.setValue('foo');
    keyDownUp(Handsontable.helper.KEY_CODES.ENTER); // save changes, close editor

    setTimeout(function () {
      onAfterValidate.calls.reset();
      activeEditor = hot.getActiveEditor();

      expect(activeEditor.isOpened()).toBe(true); // value is invalid, so editor stays opened
      expect(activeEditor.row).toEqual(0);
      expect(activeEditor.col).toEqual(0);

      activeEditor.setValue(2);

      keyDownUp(Handsontable.helper.KEY_CODES.ENTER); // save changes and move to cell below (row: 1, col: ś0)
    }, 200);

    setTimeout(function () {
      keyDownUp(Handsontable.helper.KEY_CODES.ENTER); // open editor

      activeEditor = hot.getActiveEditor();
      expect(activeEditor.row).toEqual(1);
      expect(activeEditor.col).toEqual(0);
      done();
    }, 400);
  });

  it('should call the validation callback only once, when using the validateCells method on a mixed set of data', function (done) {
    var onValidate = jasmine.createSpy('onValidate');
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    var hot = handsontable({
      data: [{ id: 'sth', name: 'Steve' }, { id: 'sth else', name: 'Bob' }],
      columns: [{
        data: 'id',
        validator: function validator(value, cb) {
          cb(value == parseInt(value, 10));
        }
      }, { data: 'name' }],
      afterValidate: onAfterValidate
    });

    hot.validateCells(onValidate);

    setTimeout(function () {
      expect(onValidate).toHaveBeenCalledWith(false);
      expect(onValidate.calls.count()).toEqual(1);
      done();
    }, 200);
  });

  it('should call the validation callback only once, when using the validateCells method on a mixed set of data and when columns is a function', function (done) {
    var onValidate = jasmine.createSpy('onValidate');
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    var hot = handsontable({
      data: [{ id: 'sth', name: 'Steve' }, { id: 'sth else', name: 'Bob' }],
      columns: function columns(column) {
        var colMeta = null;

        if (column === 0) {
          colMeta = {
            data: 'id',
            validator: function validator(value, cb) {
              cb(value == parseInt(value, 10));
            }
          };
        } else if (column === 1) {
          colMeta = { data: 'name' };
        }

        return colMeta;
      },

      afterValidate: onAfterValidate
    });

    hot.validateCells(onValidate);

    setTimeout(function () {
      expect(onValidate).toHaveBeenCalledWith(false);
      expect(onValidate.calls.count()).toEqual(1);
      done();
    }, 200);
  });
});

/***/ }),
/* 181 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core_view', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should focus cell after viewport is scrolled using down arrow', function () {
    this.$container[0].style.width = '400px';
    this.$container[0].style.height = '60px';

    handsontable({
      startRows: 20
    });
    selectCell(0, 0);

    keyDown('arrow_down');
    keyDown('arrow_down');
    keyDown('arrow_down');
    keyDown('arrow_down');

    expect(getSelected()).toEqual([4, 0, 4, 0]);

    keyDown('enter');

    expect(isEditorVisible()).toEqual(true);
  });

  it('should not render "undefined" class name', function () {
    this.$container[0].style.width = '501px';
    this.$container[0].style.height = '100px';
    this.$container[0].style.overflow = 'hidden';

    var hot = handsontable({
      startRows: 10,
      startCols: 5,
      colWidths: [47, 47, 47, 47, 47],
      rowHeaders: true,
      colHeaders: true,
      stretchH: 'all'
    });

    selectCell(0, 0);

    expect(this.$container.find('.undefined').length).toBe(0);
  });

  it('should scroll viewport when partially visible cell is clicked', function () {
    this.$container[0].style.width = '400px';
    this.$container[0].style.height = '60px';

    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(10, 3),
      height: 60
    });

    var htCore = getHtCore();
    var scrollTop = hot.rootElement.querySelector('.wtHolder').scrollTop;

    expect(scrollTop).toBe(0);
    expect(this.$container.height()).toEqual(60);
    expect(this.$container.find('.wtHolder .wtHider').height()).toBeGreaterThan(60);

    expect(htCore.find('tr:eq(0) td:eq(0)').html()).toEqual('A1');
    expect(htCore.find('tr:eq(1) td:eq(0)').html()).toEqual('A2');
    expect(htCore.find('tr:eq(2) td:eq(0)').html()).toEqual('A3');

    htCore.find('tr:eq(3) td:eq(0)').simulate('mousedown');

    expect(hot.rootElement.querySelector('.wtHolder').scrollTop).toBeGreaterThan(scrollTop);
    expect(getSelected()).toEqual([3, 0, 3, 0]);
  });

  it('should scroll viewport without cell selection', function () {
    this.$container[0].style.width = '400px';

    var hot1 = handsontable({
      data: Handsontable.helper.createSpreadsheetData(20, 20),
      height: 100
    });

    hot1.scrollViewportTo(10, 10);

    var wtHolder = this.$container.find('.ht_master .wtHolder');

    expect(wtHolder[0].scrollTop).toEqual(230);
    expect(wtHolder[0].scrollLeft).toEqual(500);
  });

  it('should not throw error while scrolling viewport to 0, 0 (empty data)', function () {
    this.$container[0].style.width = '400px';

    var hot1 = handsontable({
      data: [],
      height: 100
    });

    expect(function () {
      hot1.view.scrollViewport({ row: 0, col: 0 });
    }).not.toThrow();
  });

  it('should throw error while scrolling viewport below 0 (empty data)', function () {
    this.$container[0].style.width = '400px';

    var hot1 = handsontable({
      data: [],
      height: 100
    });

    expect(function () {
      hot1.view.scrollViewport({ row: -1, col: 0 });
    }).toThrow();
    expect(function () {
      hot1.view.scrollViewport({ row: 0, col: -1 });
    }).toThrow();
    expect(function () {
      hot1.view.scrollViewport({ row: -1, col: -1 });
    }).toThrow();
  });

  it('should scroll viewport, respecting fixed rows', function () {
    this.$container[0].style.width = '400px';
    this.$container[0].style.height = '60px';

    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(10, 9),
      fixedRowsTop: 1,
      height: 60
    });

    var htCore = getHtCore();
    var scrollTop = hot.rootElement.querySelector('.wtHolder').scrollTop;

    expect(scrollTop).toBe(0);
    expect(htCore.find('tr:eq(0) td:eq(0)').html()).toEqual('A1');
    expect(htCore.find('tr:eq(0) td:eq(1)').html()).toEqual('B1');
    expect(htCore.find('tr:eq(0) td:eq(2)').html()).toEqual('C1');

    selectCell(0, 0);

    keyDown('arrow_down');
    keyDown('arrow_down');
    keyDown('arrow_down');
    keyDown('arrow_down');

    expect(hot.rootElement.querySelector('.wtHolder').scrollTop).toBeGreaterThan(scrollTop);
  });

  it('should enable to change fixedRowsTop with updateSettings', function () {
    this.$container[0].style.width = '400px';
    this.$container[0].style.height = '60px';

    var HOT = handsontable({
      data: Handsontable.helper.createSpreadsheetData(10, 9),
      fixedRowsTop: 1,
      width: 200,
      height: 100
    });

    selectCell(0, 0);

    var htCore = getHtCore();
    var topClone = getTopClone();

    expect(topClone.find('tr').length).toEqual(1);
    expect(topClone.find('tr:eq(0) td:eq(0)').html()).toEqual('A1');

    expect(htCore.find('tr:eq(0) td:eq(0)').html()).toEqual('A1');
    expect(htCore.find('tr:eq(1) td:eq(0)').html()).toEqual('A2');
    expect(htCore.find('tr:eq(2) td:eq(0)').html()).toEqual('A3');
    expect(htCore.find('tr:eq(3) td:eq(0)').html()).toEqual('A4');

    keyDown('arrow_down');
    keyDown('arrow_down');
    keyDown('arrow_down');
    keyDown('arrow_down');

    expect(topClone.find('tr').length).toEqual(1);
    expect(topClone.find('tr:eq(0) td:eq(0)').html()).toEqual('A1');

    HOT.updateSettings({
      fixedRowsTop: 2
    });

    expect(topClone.find('tr').length).toEqual(2);
    expect(topClone.find('tr:eq(0) td:eq(0)').html()).toEqual('A1');
    expect(topClone.find('tr:eq(1) td:eq(0)').html()).toEqual('A2');

    expect(htCore.find('tr:eq(0) td:eq(0)').html()).toEqual('A1');
    expect(htCore.find('tr:eq(1) td:eq(0)').html()).toEqual('A2');
    expect(htCore.find('tr:eq(2) td:eq(0)').html()).toEqual('A3');
    expect(htCore.find('tr:eq(3) td:eq(0)').html()).toEqual('A4');
  });

  it('should scroll viewport, respecting fixed columns', function () {
    this.$container[0].style.width = '200px';
    this.$container[0].style.height = '100px';

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(10, 9),
      fixedColumnsLeft: 1
    });

    var htCore = getHtCore();
    var leftClone = this.$container.find('.ht_clone_left');

    expect(leftClone.find('tr:eq(0) td').length).toEqual(1);
    expect(leftClone.find('tr:eq(0) td:eq(0)').html()).toEqual('A1');
    expect(leftClone.find('tr:eq(1) td:eq(0)').html()).toEqual('A2');
    expect(leftClone.find('tr:eq(2) td:eq(0)').html()).toEqual('A3');

    expect(htCore.find('tr:eq(0) td:eq(0)').html()).toEqual('A1');
    expect(htCore.find('tr:eq(1) td:eq(0)').html()).toEqual('A2');
    expect(htCore.find('tr:eq(2) td:eq(0)').html()).toEqual('A3');

    selectCell(0, 3);

    keyDown('arrow_right');
    keyDown('arrow_right');
    keyDown('arrow_right');
    keyDown('arrow_right');

    expect(leftClone.find('tr:eq(0) td:eq(0)').html()).toEqual('A1');
    expect(leftClone.find('tr:eq(1) td:eq(0)').html()).toEqual('A2');
    expect(leftClone.find('tr:eq(2) td:eq(0)').html()).toEqual('A3');
  });

  it('should enable to change fixedColumnsLeft with updateSettings', function () {
    this.$container[0].style.width = '200px';
    this.$container[0].style.height = '100px';

    var HOT = handsontable({
      data: Handsontable.helper.createSpreadsheetData(10, 9),
      fixedColumnsLeft: 1
    });

    selectCell(0, 0);

    var leftClone = this.$container.find('.ht_clone_left');

    expect(leftClone.find('tr:eq(0) td').length).toEqual(1);
    expect(leftClone.find('tr:eq(0) td:eq(0)').html()).toEqual('A1');
    expect(leftClone.find('tr:eq(1) td:eq(0)').html()).toEqual('A2');
    expect(leftClone.find('tr:eq(2) td:eq(0)').html()).toEqual('A3');

    keyDown('arrow_right');
    keyDown('arrow_right');
    keyDown('arrow_right');
    keyDown('arrow_right');

    expect(leftClone.find('tr:eq(0) td:eq(0)').html()).toEqual('A1');
    expect(leftClone.find('tr:eq(1) td:eq(0)').html()).toEqual('A2');
    expect(leftClone.find('tr:eq(2) td:eq(0)').html()).toEqual('A3');

    selectCell(0, 0);

    HOT.updateSettings({
      fixedColumnsLeft: 2
    });

    expect(leftClone.find('tr:eq(0) td').length).toEqual(2);
    expect(leftClone.find('tr:eq(0) td:eq(0)').html()).toEqual('A1');
    expect(leftClone.find('tr:eq(0) td:eq(1)').html()).toEqual('B1');
    expect(leftClone.find('tr:eq(1) td:eq(0)').html()).toEqual('A2');
    expect(leftClone.find('tr:eq(1) td:eq(1)').html()).toEqual('B2');
    expect(leftClone.find('tr:eq(2) td:eq(0)').html()).toEqual('A3');
    expect(leftClone.find('tr:eq(2) td:eq(1)').html()).toEqual('B3');
  });

  it('should not scroll viewport when last cell is clicked', function () {
    handsontable({
      startRows: 40
    });

    var lastScroll;

    $(window).scrollTop(10000);
    lastScroll = $(window).scrollTop();
    render(); // renders synchronously so we don't have to put stuff in waits/runs
    selectCell(39, 0);

    expect($(window).scrollTop()).toEqual(lastScroll);

    keyDown('arrow_right');

    expect(getSelected()).toEqual([39, 1, 39, 1]);
    expect($(window).scrollTop()).toEqual(lastScroll);
  });

  it('should not shrink table when width and height is not specified for container', function (done) {
    var initHeight;

    this.$container[0].style.overflow = 'hidden';
    this.$container.wrap('<div style="width: 50px;"></div>');
    handsontable({
      startRows: 10,
      startCols: 10
    });

    setTimeout(function () {
      initHeight = spec().$container.height();
    }, 250);

    setTimeout(function () {
      expect(spec().$container.height()).toEqual(initHeight);
      done();
    }, 500);
  });

  it('should allow height to be a number', function () {
    handsontable({
      startRows: 10,
      startCols: 10,
      height: 107
    });

    expect(this.$container.height()).toEqual(107);
  });

  it('should allow height to be a function', function () {
    handsontable({
      startRows: 10,
      startCols: 10,
      height: function height() {
        return 107;
      }
    });

    expect(this.$container.height()).toEqual(107);
  });

  it('should allow width to be a number', function () {
    handsontable({
      startRows: 10,
      startCols: 10,
      width: 107
    });

    expect(this.$container.width()).toEqual(107); // rootElement is full width but this should do the trick
  });

  it('should allow width to be a function', function () {
    handsontable({
      startRows: 10,
      startCols: 10,
      width: function width() {
        return 107;
      }
    });

    expect(this.$container.width()).toEqual(107); // rootElement is full width but this should do the trick
  });

  it('should fire beforeRender event after table has been scrolled', function (done) {
    this.$container[0].style.width = '400px';
    this.$container[0].style.height = '60px';
    this.$container[0].style.overflow = 'hidden';

    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(100, 3)
    });

    var beforeRenderCallback = jasmine.createSpy('beforeRenderCallback');

    hot.addHook('beforeRender', beforeRenderCallback);
    this.$container.find('.ht_master .wtHolder').scrollTop(1000);

    setTimeout(function () {
      expect(beforeRenderCallback.calls.count()).toBe(1);
      done();
    }, 200);
  });

  it('should fire afterRender event after table has been scrolled', function (done) {
    this.$container[0].style.width = '400px';
    this.$container[0].style.height = '60px';
    this.$container[0].style.overflow = 'hidden';

    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(20, 3)
    });

    var afterRenderCallback = jasmine.createSpy('afterRenderCallback');
    hot.addHook('afterRender', afterRenderCallback);
    this.$container.find('.ht_master .wtHolder').first().scrollTop(1000);

    setTimeout(function () {
      expect(afterRenderCallback.calls.count()).toBe(1);
      done();
    }, 200);
  });

  it('should fire afterRender event after table physically rendered', function (done) {
    this.$container[0].style.width = '400px';
    this.$container[0].style.height = '60px';
    this.$container[0].style.overflow = 'hidden';

    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(20, 3)
    });

    hot.addHook('afterRender', function () {
      hot.view.wt.wtTable.holder.style.overflow = 'scroll';
      hot.view.wt.wtTable.holder.style.width = '220px';
    });
    this.$container.find('.ht_master .wtHolder').first().scrollTop(1000);

    setTimeout(function () {
      // after afterRender hook triggered element style shouldn't changed
      expect(hot.view.wt.wtTable.holder.style.overflow).toBe('scroll');
      expect(hot.view.wt.wtTable.holder.style.width).toBe('220px');
      done();
    }, 100);
  });

  // TODO fix these tests - https://github.com/handsontable/handsontable/issues/1559
  describe('maximumVisibleElementWidth', function () {
    it('should return maximum width until right edge of the viewport', function () {
      var hot = handsontable({
        startRows: 2,
        startCols: 10,
        width: 100,
        height: 100
      });

      expect(hot.view.maximumVisibleElementWidth(0)).toEqual(100);
    });

    it('should return maximum width until right edge of the viewport (excluding the scrollbar)', function () {
      var hot = handsontable({
        startRows: 10,
        startCols: 10,
        width: 100,
        height: 100
      });

      expect(hot.view.maximumVisibleElementWidth(200)).toBeLessThan(100);
    });
  });

  describe('maximumVisibleElementHeight', function () {
    it('should return maximum height until bottom edge of the viewport', function () {
      var hot = handsontable({
        startRows: 10,
        startCols: 2,
        width: 120,
        height: 100
      });

      expect(hot.view.maximumVisibleElementHeight(0)).toEqual(100);
    });

    it('should return maximum height until bottom edge of the viewport (excluding the scrollbar)', function () {
      var hot = handsontable({
        startRows: 10,
        startCols: 10,
        width: 120,
        height: 100
      });

      expect(hot.view.maximumVisibleElementHeight()).toBeLessThan(100);
    });
  });

  describe('fixed column row heights', function () {
    it('should be the same as the row heights in the main table', function () {
      var hot = handsontable({
        data: [['A', 'B', 'C', 'D'], ['a', 'b', 'c\nc', 'd'], ['aa', 'bb', 'cc', 'dd']],
        startRows: 3,
        startCols: 4,
        fixedColumnsLeft: 2
      });

      expect(hot.getCell(1, 2).clientHeight).toEqual(hot.getCell(1, 1).clientHeight);

      hot.setDataAtCell(1, 2, 'c');

      expect(hot.getCell(1, 2).clientHeight).toEqual(hot.getCell(1, 1).clientHeight);
    });

    it('should be the same as the row heights in the main table (after scroll)', function () {
      var myData = Handsontable.helper.createSpreadsheetData(20, 4);
      myData[1][3] = 'very\nlong\ntext';
      myData[5][3] = 'very\nlong\ntext';
      myData[10][3] = 'very\nlong\ntext';
      myData[15][3] = 'very\nlong\ntext';

      var hot = handsontable({
        data: myData,
        startRows: 3,
        startCols: 4,
        fixedRowsTop: 2,
        fixedColumnsLeft: 2,
        width: 200,
        height: 200
      });

      var mainHolder = hot.view.wt.wtTable.holder;

      $(mainHolder).scrollTop(200);
      hot.render();

      var masterTD = this.$container.find('.ht_master tbody tr:eq(5) td:eq(1)')[0];
      var cloneTD = this.$container.find('.ht_clone_left tbody tr:eq(5) td:eq(1)')[0];

      expect(cloneTD.clientHeight).toEqual(masterTD.clientHeight);
    });

    it('should be the same as the row heights in the main table (after scroll, in corner)', function () {
      var myData = Handsontable.helper.createSpreadsheetData(20, 4);
      myData[1][3] = 'very\nlong\ntext';
      myData[5][3] = 'very\nlong\ntext';
      myData[10][3] = 'very\nlong\ntext';
      myData[15][3] = 'very\nlong\ntext';

      var hot = handsontable({
        data: myData,
        startRows: 3,
        startCols: 4,
        fixedRowsTop: 2,
        fixedColumnsLeft: 2,
        width: 200,
        height: 200
      });

      var rowHeight = hot.getCell(1, 3).clientHeight;
      var mainHolder = hot.view.wt.wtTable.holder;

      expect(this.$container.find('.ht_clone_top_left_corner tbody tr:eq(1) td:eq(1)')[0].clientHeight).toEqual(rowHeight);

      $(mainHolder).scrollTop(200);
      hot.render();

      expect(this.$container.find('.ht_clone_top_left_corner tbody tr:eq(1) td:eq(1)')[0].clientHeight).toEqual(rowHeight);
    });
  });

  describe('fixed column widths', function () {
    it('should set the columns width correctly after changes made during updateSettings', function () {
      var hot = handsontable({
        startRows: 2,
        fixedColumnsLeft: 2,
        columns: [{
          width: 50
        }, {
          width: 80
        }, {
          width: 110
        }, {
          width: 140
        }, {
          width: 30
        }, {
          width: 30
        }, {
          width: 30
        }]
      });

      var leftClone = this.$container.find('.ht_clone_left');

      expect(Handsontable.dom.outerWidth(leftClone.find('tbody tr:nth-child(1) td:nth-child(2)')[0])).toEqual(80);

      hot.updateSettings({
        manualColumnMove: [2, 0, 1],
        fixedColumnsLeft: 1
      });

      expect(leftClone.find('tbody tr:nth-child(1) td:nth-child(2)')[0]).toBe(undefined);

      hot.updateSettings({
        manualColumnMove: false,
        fixedColumnsLeft: 2
      });

      expect(Handsontable.dom.outerWidth(leftClone.find('tbody tr:nth-child(1) td:nth-child(2)')[0])).toEqual(80);
    });

    it('should set the columns width correctly after changes made during updateSettings when columns is a function', function () {
      var hot = handsontable({
        startCols: 7,
        startRows: 2,
        fixedColumnsLeft: 2,
        columns: function columns(column) {
          var colMeta = {};

          if (column === 0) {
            colMeta.width = 50;
          } else if (column === 1) {
            colMeta.width = 80;
          } else if (column === 2) {
            colMeta.width = 110;
          } else if (column === 3) {
            colMeta.width = 140;
          } else if ([4, 5, 6].indexOf(column) > -1) {
            colMeta.width = 30;
          } else {
            colMeta = null;
          }

          return colMeta;
        }
      });

      var leftClone = this.$container.find('.ht_clone_left');

      expect(Handsontable.dom.outerWidth(leftClone.find('tbody tr:nth-child(1) td:nth-child(2)')[0])).toEqual(80);

      hot.updateSettings({
        manualColumnMove: [2, 0, 1],
        fixedColumnsLeft: 1
      });

      expect(leftClone.find('tbody tr:nth-child(1) td:nth-child(2)')[0]).toBe(undefined);

      hot.updateSettings({
        manualColumnMove: false,
        fixedColumnsLeft: 2
      });

      expect(Handsontable.dom.outerWidth(leftClone.find('tbody tr:nth-child(1) td:nth-child(2)')[0])).toEqual(80);
    });
  });

  describe('stretchH', function () {
    it('should stretch all visible columns with the ratio appropriate to the container\'s width', function () {
      this.$container[0].style.width = '300px';

      var hot = handsontable({
        startRows: 5,
        startCols: 5,
        rowHeaders: true,
        colHeaders: true,
        stretchH: 'all'
      }),
          rowHeaderWidth = hot.view.wt.wtViewport.getRowHeaderWidth(),
          expectedCellWidth = (parseInt(this.$container[0].style.width, 10) - rowHeaderWidth) / 5;

      expect(getCell(0, 0).offsetWidth).toEqual(expectedCellWidth);
      expect(getCell(0, 1).offsetWidth).toEqual(expectedCellWidth);
      expect(getCell(0, 2).offsetWidth).toEqual(expectedCellWidth);
      expect(getCell(0, 3).offsetWidth).toEqual(expectedCellWidth);
      expect(getCell(0, 4).offsetWidth).toEqual(expectedCellWidth);

      this.$container[0].style.width = '';
      this.$container.wrap('<div class="temp_wrapper" style="width:400px;"></div>');
      hot.render();

      expectedCellWidth = (parseInt($('.temp_wrapper')[0].style.width, 10) - rowHeaderWidth) / 5;

      expect(getCell(0, 0).offsetWidth).toEqual(expectedCellWidth);
      expect(getCell(0, 1).offsetWidth).toEqual(expectedCellWidth);
      expect(getCell(0, 2).offsetWidth).toEqual(expectedCellWidth);
      expect(getCell(0, 3).offsetWidth).toEqual(expectedCellWidth);
      expect(getCell(0, 4).offsetWidth).toEqual(expectedCellWidth);

      this.$container.unwrap();
    });

    it('should stretch all visible columns with overflow hidden', function () {
      this.$container[0].style.width = '501px';
      this.$container[0].style.height = '100px';
      this.$container[0].style.overflow = 'hidden';

      var hot = handsontable({
        startRows: 10,
        startCols: 5,
        colWidths: [47, 47, 47, 47, 47],
        rowHeaders: true,
        colHeaders: true,
        stretchH: 'all'
      });

      var masterTH = this.$container[0].querySelectorAll('.ht_master thead tr th');
      var overlayTH = this.$container[0].querySelectorAll('.ht_clone_top thead tr th');

      expect(masterTH[0].offsetWidth).toEqual(50);
      expect(overlayTH[0].offsetWidth).toEqual(50);

      expect(masterTH[1].offsetWidth).toBeInArray([86, 87, 88, 90]);
      expect(overlayTH[1].offsetWidth).toBeInArray([86, 87, 88, 90]); // if you get 90, it means it is calculated before scrollbars were applied, or show scroll on scrolling is enabled

      expect(masterTH[2].offsetWidth).toEqual(overlayTH[2].offsetWidth);
      expect(masterTH[3].offsetWidth).toEqual(overlayTH[3].offsetWidth);
      expect(masterTH[4].offsetWidth).toEqual(overlayTH[4].offsetWidth);
      expect(masterTH[5].offsetWidth).toEqual(overlayTH[5].offsetWidth);
    });

    it('should respect stretched widths returned in beforeStretchingColumnWidth hook', function () {
      this.$container[0].style.width = '501px';
      this.$container[0].style.height = '100px';
      this.$container[0].style.overflow = 'hidden';

      var callbackSpy = jasmine.createSpy();

      callbackSpy.and.callFake(function (width, column) {
        if (column === 1) {
          return 150;
        }

        return width;
      });

      var hot = handsontable({
        startRows: 2,
        startCols: 5,
        rowHeaders: true,
        colHeaders: true,
        stretchH: 'all',
        beforeStretchingColumnWidth: callbackSpy
      });

      var $columnHeaders = this.$container.find('thead tr:eq(0) th');

      expect($columnHeaders.eq(0).width()).toEqual(48);
      expect($columnHeaders.eq(1).width()).toEqual(73);
      expect($columnHeaders.eq(2).width()).toEqual(149);
      expect($columnHeaders.eq(3).width()).toEqual(74);
      expect($columnHeaders.eq(4).width()).toEqual(74);

      expect(callbackSpy).toHaveBeenCalled();
      // First cycle to check what columns has permanent width
      expect(callbackSpy.calls.argsFor(0)[0]).not.toBeDefined();
      expect(callbackSpy.calls.argsFor(0)[1]).toBe(0);
      expect(callbackSpy.calls.argsFor(1)[0]).not.toBeDefined();
      expect(callbackSpy.calls.argsFor(1)[1]).toBe(1);
      expect(callbackSpy.calls.argsFor(2)[0]).not.toBeDefined();
      expect(callbackSpy.calls.argsFor(2)[1]).toBe(2);
      expect(callbackSpy.calls.argsFor(3)[0]).not.toBeDefined();
      expect(callbackSpy.calls.argsFor(3)[1]).toBe(3);
      expect(callbackSpy.calls.argsFor(4)[0]).not.toBeDefined();
      expect(callbackSpy.calls.argsFor(4)[1]).toBe(4);
      // // Second cycle retrieve stretched width or permanent width
      expect(callbackSpy.calls.argsFor(5)[0]).toBe(75);
      expect(callbackSpy.calls.argsFor(6)[0]).toBe(75);
      expect(callbackSpy.calls.argsFor(7)[0]).toBe(75);
      expect(callbackSpy.calls.argsFor(8)[0]).toBe(75);
      expect(callbackSpy.calls.argsFor(9)[0]).toBe(75);
    });
  });
});

/***/ }),
/* 182 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Handsontable.Dom', function () {

  describe('offset', function () {
    var $window = $(window),
        $forceScrollbar = $('<div id="forceScrollbar"></div>').css({
      position: 'absolute',
      height: '4000px',
      width: '4000px',
      top: 0,
      left: 0
    });

    beforeEach(function () {
      $forceScrollbar.appendTo(document.body);
      this.$div = $('<div id="test"></div>').appendTo($forceScrollbar);
      this.div = this.$div[0];
    });

    afterEach(function () {
      this.$div.remove();
      $forceScrollbar.remove();
    });

    describe('top', function () {
      it('should return offset top with position absolute', function () {
        this.$div.css({ position: 'absolute', top: 200 });

        expect(Handsontable.dom.offset(this.div).top).toEqual(200);
      });

      it('should return offset top with position absolute & scrolled window', function () {
        this.$div.css({ position: 'absolute', top: 200 });
        $window.scrollTop(1900);

        expect(Handsontable.dom.offset(this.div).top).toEqual(200);

        $window.scrollTop(0);
      });

      it('should return offset top with position fixed', function () {
        this.$div.css({ position: 'fixed', top: 200 });

        expect(Handsontable.dom.offset(this.div).top).toEqual(200);
      });

      it('should return offset top with position fixed & scrolled window', function () {
        this.$div.css({ position: 'fixed', top: 200 });
        $window.scrollTop(1900);

        expect(Handsontable.dom.offset(this.div).top).toEqual(2100); // this is the same jQuery offset returns

        $window.scrollTop(0);
      });
    });

    describe('left', function () {
      it('should return offset left with position absolute', function () {
        this.$div.css({ position: 'absolute', left: 200 });

        expect(Handsontable.dom.offset(this.div).left).toEqual(200);
      });

      it('should return offset left with position absolute & scrolled window', function () {
        this.$div.css({ position: 'absolute', left: 200 });
        $window.scrollLeft(1900);

        expect(Handsontable.dom.offset(this.div).left).toEqual(200);

        $window.scrollLeft(0);
      });

      it('should return offset left with position fixed', function () {
        this.$div.css({ position: 'fixed', left: 200 });

        expect(Handsontable.dom.offset(this.div).left).toEqual(200);
      });

      it('should return offset left with position fixed & scrolled window', function () {
        this.$div.css({ position: 'fixed', left: 200 });
        $window.scrollLeft(1900);

        expect(Handsontable.dom.offset(this.div).left).toEqual(2100); // this is the same jQuery offset returns

        $window.scrollLeft(0);
      });
    });
  });

  describe('isVisible', function () {
    it('should return true for appended table', function () {
      var $table = $('<table></table>').appendTo('body');

      expect(Handsontable.dom.isVisible($table[0])).toBe(true);

      $table.remove();
    });

    it('should return false for not appended table', function () {
      var $table = $('<table></table>');

      expect(Handsontable.dom.isVisible($table[0])).toBe(false);

      $table.remove();
    });

    it('should return false for table with `display: none`', function () {
      var $table = $('<table style="display: none"></table>').appendTo('body');

      expect(Handsontable.dom.isVisible($table[0])).toBe(false);

      $table.remove();
    });

    it('should return false for table with parent `display: none`', function () {
      var $div = $('<div style="display: none"></div>').appendTo('body');
      var $table = $('<table></table>').appendTo($div);

      expect(Handsontable.dom.isVisible($table[0])).toBe(false);

      $table.remove();
    });

    it('should return false for something detached from DOM', function () {
      var $table = $('<table><tr><td></td></tr></table>').appendTo('body');

      var TD = $table.find('td')[0];
      var TR = TD.parentNode;
      expect(Handsontable.dom.isVisible(TD)).toBe(true);
      TR.parentNode.removeChild(TR);
      expect(Handsontable.dom.isVisible(TD)).toBe(false);

      $table.remove();
    });
  });

  describe('outerHeight', function () {
    it('should return correct outerHeight for table', function () {
      var $table = $('<table style="border-width: 0;"><tbody><tr><td style="border: 1px solid black"><div style="height: 30px">test</div></td>' + '</tr></tbody></table>').appendTo('body');

      expect(Handsontable.dom.outerHeight($table[0])).toBe(38); // this is according to current stylesheet
      expect($table.outerHeight()).toBe(38); // jQuery check to confirm

      $table.remove();
    });

    it('should return correct outerHeight for table (with caption)', function () {
      var $table = $('<table style="border-width: 0;"><caption style="padding: 0; margin:0"><div style="height: 30px">caption</div></caption><tbody>' + '<tr><td style="border: 1px solid black"><div style="height: 30px">test</div></td></tr></tbody></table>').appendTo('body');

      expect(Handsontable.dom.outerHeight($table[0])).toBe(68); // this is according to current stylesheet

      $table.remove();
    });
  });

  it('should return correct offset for table cell (table with caption)', function () {
    var $table = $('<table style="border-width: 0;"><caption style="padding: 0; margin:0"><div style="height: 30px">caption</div></caption><tbody>' + '<tr><td style="border: 1px solid black"><div style="height: 30px">test</div></td></tr></tbody></table>').appendTo('body');

    var tableOffset = Handsontable.dom.offset($table[0]);
    var tdOffset = Handsontable.dom.offset($table.find('td')[0]);

    expect(parseInt(tdOffset.left - tableOffset.left, 10)).toBeAroundValue(2); // this is according to current stylesheet
    expect(parseInt(tdOffset.top - tableOffset.top, 10)).toBeAroundValue(32); // this is according to current stylesheet

    $table.remove();
  });

  it('should return font size', function () {
    var $html = $('<style>.bigText{font: 12px serif;}</style><div class="bigText"><span id="testable"></span></div>').appendTo('body');

    var span = document.getElementById('testable');
    var compStyle = Handsontable.dom.getComputedStyle(span);

    expect(compStyle.fontSize).toBe('12px');

    $html.remove();
  });

  it('should return top border width', function () {
    var $html = $('<style>.redBorder{border: 10px solid red;}</style><div class="redBorder" id="testable"></div>').appendTo('body');

    var div = document.getElementById('testable');
    var compStyle = Handsontable.dom.getComputedStyle(div);

    expect(compStyle.borderTopWidth).toBe('10px');

    $html.remove();
  });

  it('should insert HTML properly', function () {
    var $html = $('<div id="testable"></div>').appendTo('body');
    var text = '<span>test<br>test</span>';
    var div = document.getElementById('testable');

    Handsontable.dom.fastInnerHTML(div, text);
    Handsontable.dom.fastInnerHTML(div, text);

    expect(div.childNodes[0].childNodes.length).toEqual(3);

    $html.remove();
  });

  it('should set the immediatePropagation properties properly for given event', function () {
    var event = document.createEvent('MouseEvents');
    event.initMouseEvent('mousedown', true, true, window, null, null, null, null, null, null, null, null, null, null, null);

    Handsontable.dom.stopImmediatePropagation(event);

    expect(event.isImmediatePropagationEnabled).toBe(false);

    expect(Handsontable.dom.isImmediatePropagationStopped(event)).toBe(true);
  });

  describe('getScrollableElement', function () {
    it('should return scrollable element with \'scroll\' value of \'overflow\', \'overflowX\' or \'overflowY\' property', function () {
      var $html = $(['<div style="overflow: scroll"><span class="overflow"></span></div>', '<div style="overflow-x: scroll"><span class="overflowX"></span></div>', '<div style="overflow-y: scroll"><span class="overflowY"></span></div>'].join('')).appendTo('body');

      expect(Handsontable.dom.getScrollableElement($html.find('.overflow')[0])).toBe($html[0]);
      expect(Handsontable.dom.getScrollableElement($html.find('.overflowX')[0])).toBe($html[1]);
      expect(Handsontable.dom.getScrollableElement($html.find('.overflowY')[0])).toBe($html[2]);

      $html.remove();
    });

    it('should return scrollable element with \'auto\' value of \'overflow\' or \'overflowY\' property', function () {
      var $html = $(['<div style="overflow: auto; height: 50px;"><div class="knob" style="height: 100px"></div></div>', '<div style="overflow-y: auto; height: 50px;"><div class="knob" style="height: 100px"></div></div>', '<div style="overflow-y: auto; height: 50px;">', '<div>', '<div class="knob" style="height: 100px;"></div>', '</div>', '</div>'].join('')).appendTo('body');

      expect(Handsontable.dom.getScrollableElement($html.find('.knob')[0])).toBe($html[0]);
      expect(Handsontable.dom.getScrollableElement($html.find('.knob')[1])).toBe($html[1]);
      expect(Handsontable.dom.getScrollableElement($html.find('.knob')[2])).toBe($html[2]);

      $html.remove();
    });

    it('should return scrollable element with \'auto\' value of \'overflow\' or \'overflowX\' property', function () {
      var $html = $(['<div style="overflow: auto; width: 50px; height: 10px"><div class="knob" style="width: 100px; height: 5px"></div></div>', '<div style="overflow-x: auto; width: 50px; height: 10px"><div class="knob" style="width: 100px; height: 5px"></div></div>', '<div style="overflow-x: auto; width: 50px; height: 10px">', '<div>', '<div class="knob" style="width: 100px; height: 5px"></div>', '</div>', '</div>'].join('')).appendTo('body');

      expect(Handsontable.dom.getScrollableElement($html.find('.knob')[0])).toBe($html[0]);
      expect(Handsontable.dom.getScrollableElement($html.find('.knob')[1])).toBe($html[1]);
      expect(Handsontable.dom.getScrollableElement($html.find('.knob')[2])).toBe($html[2]);

      $html.remove();
    });

    it('should return window object as scrollable element', function () {
      var $html = $(['<div style="overflow: hidden; width: 50px; height: 10px"><div class="knob" style="width: 100px; height: 5px"></div></div>', '<div style="width: 50px; height: 10px"><div class="knob" style="width: 100px; height: 5px"></div></div>'].join('')).appendTo('body');

      expect(Handsontable.dom.getScrollableElement($html.find('.knob')[0])).toBe(window);
      expect(Handsontable.dom.getScrollableElement($html.find('.knob')[1])).toBe(window);

      $html.remove();
    });
  });

  //
  // Handsontable.dom.isChildOfWebComponentTable
  //
  describe('isChildOfWebComponentTable', function () {
    it('should return correct Boolean value depending on whether an element exists in `hot-table` or not', function () {
      // skip if browser not support Shadow DOM natively
      if (!document.createElement('div').createShadowRoot) {
        // Fix for "no exceptations" warnings
        expect(true).toBe(true);

        return;
      }
      var hotTable = document.createElement('hot-table');
      var outsideDiv = document.createElement('div');

      expect(Handsontable.dom.isChildOfWebComponentTable(hotTable)).toBe(true);
      expect(Handsontable.dom.isChildOfWebComponentTable(outsideDiv)).toBe(false);

      var hotTableDiv = document.createElement('div');
      hotTable.appendChild(hotTableDiv);

      expect(Handsontable.dom.isChildOfWebComponentTable(hotTableDiv)).toBe(true);

      var fragment = document.createDocumentFragment();

      expect(Handsontable.dom.isChildOfWebComponentTable(fragment)).toBe(false);

      var myElement = document.createElement('my-element');

      expect(Handsontable.dom.isChildOfWebComponentTable(myElement)).toBe(false);

      var shadowRoot = myElement.createShadowRoot();
      var insideDiv = shadowRoot.appendChild(document.createElement('div'));
      hotTable.createShadowRoot().appendChild(myElement);

      expect(Handsontable.dom.isChildOfWebComponentTable(myElement)).toBe(true);
      expect(Handsontable.dom.isChildOfWebComponentTable(insideDiv)).toBe(true);
    });
  });

  //
  // Handsontable.dom.polymerWrap
  //
  describe('polymerWrap', function () {
    it('should wrap element into polymer wrapper if exists', function () {
      expect(Handsontable.dom.polymerWrap(1)).toBe(1);

      window.wrap = function () {
        return 'wrapped';
      };
      window.Polymer = {};

      expect(Handsontable.dom.polymerWrap(1)).toBe('wrapped');

      // Test https://github.com/handsontable/handsontable/issues/2283
      window.wrap = document.createElement('div');

      expect(Handsontable.dom.polymerWrap(1)).toBe(1);

      delete window.wrap;
      delete window.Polymer;
    });
  });

  //
  // Handsontable.dom.polymerUnwrap
  //
  describe('polymerUnwrap', function () {
    it('should unwrap element from polymer wrapper if exists', function () {
      expect(Handsontable.dom.polymerUnwrap('wrapped')).toBe('wrapped');

      window.unwrap = function () {
        return 1;
      };
      window.Polymer = {};

      expect(Handsontable.dom.polymerUnwrap('wrapped')).toBe(1);

      window.unwrap = document.createElement('div');

      expect(Handsontable.dom.polymerUnwrap('wrapped')).toBe('wrapped');

      delete window.unwrap;
      delete window.Polymer;
    });
  });

  //
  // Handsontable.dom.addClass
  //
  describe('addClass', function () {
    it('should add class names as string to an element', function () {
      var element = document.createElement('div');

      expect(element.className).toBe('');

      Handsontable.dom.addClass(element, 'test');

      expect(element.className).toBe('test');

      Handsontable.dom.addClass(element, 'test test1 test2');

      expect(element.className).toBe('test test1 test2');

      Handsontable.dom.addClass(element, 'test3');

      expect(element.className).toBe('test test1 test2 test3');

      Handsontable.dom.addClass(element, '');

      expect(element.className).toBe('test test1 test2 test3');
    });

    it('should add class names as array to an element', function () {
      var element = document.createElement('div');

      expect(element.className).toBe('');

      Handsontable.dom.addClass(element, ['test']);

      expect(element.className).toBe('test');

      Handsontable.dom.addClass(element, ['test1', 'test2', 'test3']);

      expect(element.className).toBe('test test1 test2 test3');

      Handsontable.dom.addClass(element, 'test4');

      expect(element.className).toBe('test test1 test2 test3 test4');

      Handsontable.dom.addClass(element, '');

      expect(element.className).toBe('test test1 test2 test3 test4');
    });
  });

  //
  // Handsontable.dom.removeClass
  //
  describe('removeClass', function () {
    it('should remove class names as string from an element', function () {
      var element = document.createElement('div');

      element.className = 'test test1 test2 test3 test4';

      Handsontable.dom.removeClass(element, 'not-exists');

      expect(element.className).toBe('test test1 test2 test3 test4');

      Handsontable.dom.removeClass(element, 'test');

      expect(element.className).toBe('test1 test2 test3 test4');

      Handsontable.dom.removeClass(element, 'test test1 test4');

      expect(element.className).toBe('test2 test3');

      Handsontable.dom.removeClass(element, '');

      expect(element.className).toBe('test2 test3');
    });

    it('should remove class names as array from an element', function () {
      var element = document.createElement('div');

      element.className = 'test test1 test2 test3 test4';

      Handsontable.dom.removeClass(element, ['not-exists']);

      expect(element.className).toBe('test test1 test2 test3 test4');

      Handsontable.dom.removeClass(element, ['test']);

      expect(element.className).toBe('test1 test2 test3 test4');

      Handsontable.dom.removeClass(element, ['test', 'test1', 'test4']);

      expect(element.className).toBe('test2 test3');

      Handsontable.dom.removeClass(element, ['test', '', '']);

      expect(element.className).toBe('test2 test3');
    });
  });

  //
  // Handsontable.dom.hasClass
  //
  describe('hasClass', function () {
    it('should checks if an element has passed class name', function () {
      var element = document.createElement('div');

      element.className = 'test test1 test2 test3 test4';

      expect(Handsontable.dom.hasClass(element, 'not-exists')).toBe(false);
      expect(Handsontable.dom.hasClass(element, 'test3')).toBe(true);
      expect(Handsontable.dom.hasClass(element, 'test')).toBe(true);
      expect(Handsontable.dom.hasClass(element, '')).toBe(false);
    });
  });
});

/***/ }),
/* 183 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('FillHandle', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should appear when fillHandle equals true', function () {
    handsontable({
      fillHandle: true
    });

    selectCell(2, 2);

    expect(isFillHandleVisible()).toBe(true);
  });

  it('should appear when fillHandle is enabled as `string` value', function () {
    handsontable({
      fillHandle: 'horizontal'
    });

    selectCell(2, 2);

    expect(isFillHandleVisible()).toBe(true);
  });

  it('should not change cell value (drag vertically when fillHandle option is set to `horizontal`)', function () {
    handsontable({
      data: [[1, 2, 3, 4, 5, 6], [7, 8, 9, 1, 2, 3], [4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6]],
      fillHandle: 'horizontal'
    });

    selectCell(0, 0);
    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    this.$container.find('tbody tr:eq(1) td:eq(0)').simulate('mouseover').simulate('mouseup');

    expect(getDataAtCell(1, 0)).toEqual(7);
  });

  it('should not change cell value (drag horizontally when fillHandle option is set to `vertical`)', function () {
    handsontable({
      data: [[1, 2, 3, 4, 5, 6], [7, 8, 9, 1, 2, 3], [4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6]],
      fillHandle: 'vertical'
    });

    selectCell(0, 0);
    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    this.$container.find('tbody tr:eq(0) td:eq(1)').simulate('mouseover').simulate('mouseup');

    expect(getDataAtCell(0, 1)).toEqual(2);
  });

  it('should work properly when fillHandle option is set to object with property `direction` set to `vertical`)', function () {
    handsontable({
      data: [[1, 2, 3, 4, 5, 6], [7, 8, 9, 1, 2, 3], [4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6]],
      fillHandle: {
        direction: 'vertical'
      }
    });

    selectCell(0, 0);
    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    this.$container.find('tbody tr:eq(0) td:eq(1)').simulate('mouseover').simulate('mouseup');

    expect(getDataAtCell(0, 1)).toEqual(2);

    selectCell(0, 0);
    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    this.$container.find('tbody tr:eq(1) td:eq(0)').simulate('mouseover').simulate('mouseup');

    expect(getDataAtCell(1, 0)).toEqual(1);
  });

  it('should work properly when fillHandle option is set to object with property `direction` set to `horizontal`)', function () {
    handsontable({
      data: [[1, 2, 3, 4, 5, 6], [7, 8, 9, 1, 2, 3], [4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6]],
      fillHandle: {
        direction: 'horizontal'
      }
    });

    selectCell(0, 0);
    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    this.$container.find('tbody tr:eq(0) td:eq(1)').simulate('mouseover').simulate('mouseup');

    expect(getDataAtCell(0, 1)).toEqual(1);

    selectCell(0, 0);
    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    this.$container.find('tbody tr:eq(1) td:eq(0)').simulate('mouseover').simulate('mouseup');

    expect(getDataAtCell(1, 0)).toEqual(7);
  });

  it('should not change cell value (drag when fillHandle is set to `false`)', function () {
    handsontable({
      data: [[1, 2, 3, 4, 5, 6], [7, 8, 9, 1, 2, 3], [4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6]],
      fillHandle: false
    });

    // checking drag vertically - should not change cell value

    selectCell(0, 0);
    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    this.$container.find('tbody tr:eq(0) td:eq(1)').simulate('mouseover').simulate('mouseup');

    expect(getDataAtCell(0, 1)).toEqual(2);

    // checking drag horizontally - should not change cell value

    selectCell(0, 0);
    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    this.$container.find('tbody tr:eq(0) td:eq(1)').simulate('mouseover').simulate('mouseup');

    expect(getDataAtCell(0, 1)).toEqual(2);
  });

  it('should work properly when using updateSettings', function () {
    var hot = handsontable({
      data: [[1, 2, 3, 4, 5, 6], [7, 8, 9, 1, 2, 3], [4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6]],
      fillHandle: 'horizontal'
    });

    updateSettings({ fillHandle: 'vertical' });

    // checking drag vertically - should change cell value

    selectCell(0, 0);
    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    this.$container.find('tbody tr:eq(0) td:eq(1)').simulate('mouseover').simulate('mouseup');

    expect(getDataAtCell(0, 1)).toEqual(2);

    updateSettings({ fillHandle: false });

    // checking drag vertically - should not change cell value

    selectCell(0, 1);
    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    this.$container.find('tbody tr:eq(1) td:eq(1)').simulate('mouseover').simulate('mouseup');

    expect(getDataAtCell(1, 1)).toEqual(8);

    // checking drag horizontally - should not change cell value

    selectCell(0, 1);
    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    this.$container.find('tbody tr:eq(0) td:eq(2)').simulate('mouseover').simulate('mouseup');

    expect(getDataAtCell(0, 2)).toEqual(3);
  });

  it('should appear when fillHandle is enabled as `object` value', function () {
    handsontable({
      fillHandle: {
        allowInsertRow: true
      }
    });

    selectCell(2, 2);

    expect(isFillHandleVisible()).toBe(true);
  });

  it('should not appear when fillHandle equals false', function () {
    handsontable({
      fillHandle: false
    });
    selectCell(2, 2);

    expect(isFillHandleVisible()).toBe(false);
  });

  it('should disappear when beginediting is triggered', function () {
    handsontable({
      fillHandle: true
    });
    selectCell(2, 2);

    keyDown('enter');

    expect(isFillHandleVisible()).toBe(false);
  });

  it('should appear when finishediting is triggered', function () {
    handsontable({
      fillHandle: true
    });
    selectCell(2, 2);

    keyDown('enter');
    keyDown('enter');

    expect(isFillHandleVisible()).toBe(true);
  });

  it('should not appear when fillHandle equals false and finishediting is triggered', function () {
    handsontable({
      fillHandle: false
    });
    selectCell(2, 2);

    keyDown('enter');
    keyDown('enter');

    expect(isFillHandleVisible()).toBe(false);
  });

  it('should appear when editor is discarded using the ESC key', function () {
    handsontable({
      fillHandle: true
    });
    selectCell(2, 2);

    keyDown('enter');
    keyDown('esc');

    expect(isFillHandleVisible()).toBe(true);
  });

  it('should add custom value after autofill', function () {
    handsontable({
      data: [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]],
      beforeAutofill: function beforeAutofill(start, end, data) {
        data[0][0] = 'test';
      }
    });
    selectCell(0, 0);

    this.$container.find('.wtBorder.corner').simulate('mousedown');
    this.$container.find('tr:eq(1) td:eq(0)').simulate('mouseover');
    this.$container.find('tr:eq(2) td:eq(0)').simulate('mouseover');
    this.$container.find('.wtBorder.corner').simulate('mouseup');

    expect(getSelected()).toEqual([0, 0, 2, 0]);
    expect(getDataAtCell(1, 0)).toEqual('test');
  });

  it('should use correct cell coordinates also when Handsontable is used inside a TABLE (#355)', function () {
    var $table = $('<table><tr><td></td></tr></table>').appendTo('body');
    this.$container.appendTo($table.find('td'));

    var ev;

    handsontable({
      data: [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]],
      beforeAutofill: function beforeAutofill(start, end, data) {
        data[0][0] = 'test';
      }
    });
    selectCell(1, 1);

    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    this.$container.find('tr:eq(1) td:eq(0)').simulate('mouseover');
    this.$container.find('tr:eq(2) td:eq(0)').simulate('mouseover');
    this.$container.find('tr:eq(2) td:eq(0)').simulate('mouseup');

    expect(getSelected()).toEqual([1, 1, 2, 1]);
    expect(getDataAtCell(2, 1)).toEqual('test');

    document.body.removeChild($table[0]);
  });
  it('should fill cells below until the end of content in the neighbouring column with current cell\'s data', function () {
    var hot = handsontable({
      data: [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, null, null, null, null], [1, 2, null, null, null, null]]
    });

    selectCell(1, 3);
    var fillHandle = this.$container.find('.wtBorder.current.corner')[0];
    mouseDoubleClick(fillHandle);

    expect(getDataAtCell(2, 3)).toEqual(null);
    expect(getDataAtCell(3, 3)).toEqual(null);

    selectCell(1, 2);
    mouseDoubleClick(fillHandle);

    expect(getDataAtCell(2, 2)).toEqual(3);
    expect(getDataAtCell(3, 2)).toEqual(3);
  });

  it('should fill cells below until the end of content in the neighbouring column with the currently selected area\'s data', function () {
    var hot = handsontable({
      data: [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, null, null, null, null], [1, 2, null, null, null, null]]
    });

    selectCell(1, 3, 1, 4);
    var fillHandle = this.$container.find('.wtBorder.area.corner')[0];
    mouseDoubleClick(fillHandle);

    expect(getDataAtCell(2, 3)).toEqual(null);
    expect(getDataAtCell(3, 3)).toEqual(null);
    expect(getDataAtCell(2, 4)).toEqual(null);
    expect(getDataAtCell(3, 4)).toEqual(null);

    selectCell(1, 2, 1, 3);
    mouseDoubleClick(fillHandle);

    expect(getDataAtCell(2, 2)).toEqual(3);
    expect(getDataAtCell(3, 2)).toEqual(3);
    expect(getDataAtCell(2, 3)).toEqual(4);
    expect(getDataAtCell(3, 3)).toEqual(4);
  });

  it('should add new row after dragging the handle to the last table row', function (done) {
    var hot = handsontable({
      data: [[1, 2, 'test', 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]]
    });

    selectCell(0, 2);

    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    this.$container.find('tr:last-child td:eq(2)').simulate('mouseover');

    expect(hot.countRows()).toBe(4);

    setTimeout(function () {
      expect(hot.countRows()).toBe(5);

      spec().$container.find('tr:last-child td:eq(2)').simulate('mouseover');
    }, 300);

    setTimeout(function () {
      expect(hot.countRows()).toBe(6);
      done();
    }, 600);
  });

  it('should add new row after dragging the handle to the last table row (autoInsertRow as true)', function (done) {
    var hot = handsontable({
      data: [[1, 2, 'test', 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]],
      fillHandle: {
        autoInsertRow: true
      }
    });

    selectCell(0, 2);

    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    this.$container.find('tr:last-child td:eq(2)').simulate('mouseover');

    expect(hot.countRows()).toBe(4);

    setTimeout(function () {
      expect(hot.countRows()).toBe(5);

      spec().$container.find('tr:last-child td:eq(2)').simulate('mouseover');
    }, 300);

    setTimeout(function () {
      expect(hot.countRows()).toBe(6);
      done();
    }, 600);
  });

  it('should add new row after dragging the handle to the last table row (autoInsertRow as true, vertical)', function (done) {
    var hot = handsontable({
      data: [[1, 2, 'test', 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]],
      fillHandle: {
        direction: 'vertical',
        autoInsertRow: true
      }
    });

    selectCell(0, 2);

    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    this.$container.find('tr:last-child td:eq(2)').simulate('mouseover');

    expect(hot.countRows()).toBe(4);

    setTimeout(function () {
      expect(hot.countRows()).toBe(5);

      spec().$container.find('tr:last-child td:eq(2)').simulate('mouseover');
    }, 300);

    setTimeout(function () {
      expect(hot.countRows()).toBe(6);
      done();
    }, 600);
  });

  it('should not add new row after dragging the handle to the last table row (autoInsertRow as true, horizontal)', function (done) {
    var hot = handsontable({
      data: [[1, 2, 'test', 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]],
      fillHandle: {
        direction: 'horizontal',
        autoInsertRow: true
      }
    });

    selectCell(0, 2);

    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    this.$container.find('tr:last-child td:eq(2)').simulate('mouseover');

    expect(hot.countRows()).toBe(4);

    setTimeout(function () {
      expect(hot.countRows()).toBe(4);

      spec().$container.find('tr:last-child td:eq(2)').simulate('mouseover');
    }, 300);

    setTimeout(function () {
      expect(hot.countRows()).toBe(4);
      done();
    }, 600);
  });

  it('should not add new row after dragging the handle below the viewport when `autoInsertRow` is disabled', function (done) {
    var hot = handsontable({
      data: [[1, 2, 'test', 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]],
      fillHandle: {
        autoInsertRow: false
      }
    });

    selectCell(0, 2);

    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    var ev = {};
    var $lastRow = this.$container.find('tr:last-child td:eq(2)');

    expect(hot.countRows()).toBe(4);

    ev.clientX = $lastRow.offset().left / 2;
    ev.clientY = $lastRow.offset().top + 50;

    $(document.documentElement).simulate('mousemove', ev);

    setTimeout(function () {
      expect(hot.countRows()).toBe(4);

      ev.clientY = $lastRow.offset().top + 150;
      $(document.documentElement).simulate('mousemove', ev);
    }, 300);

    setTimeout(function () {
      expect(hot.countRows()).toBe(4);
      done();
    }, 600);
  });

  it('should not add new rows if the current number of rows reaches the maxRows setting', function (done) {
    var hot = handsontable({
      data: [[1, 2, 'test', 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]],
      maxRows: 5
    });

    selectCell(0, 2);

    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    this.$container.find('tr:last-child td:eq(2)').simulate('mouseover');

    expect(hot.countRows()).toBe(4);

    setTimeout(function () {
      expect(hot.countRows()).toBe(5);

      spec().$container.find('tr:last-child td:eq(2)').simulate('mouseover');
    }, 200);

    setTimeout(function () {
      expect(hot.countRows()).toBe(5);
      done();
    }, 400);
  });

  it('should add new row after dragging the handle below the viewport', function (done) {
    var hot = handsontable({
      data: [[1, 2, 'test', 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]]
    });

    selectCell(0, 2);

    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    var ev = {};
    var $lastRow = this.$container.find('tr:last-child td:eq(2)');

    expect(hot.countRows()).toBe(4);

    ev.clientX = $lastRow.offset().left / 2;
    ev.clientY = $lastRow.offset().top + 50;

    $(document.documentElement).simulate('mousemove', ev);

    setTimeout(function () {
      expect(hot.countRows()).toBe(5);

      ev.clientY = $lastRow.offset().top + 150;
      $(document.documentElement).simulate('mousemove', ev);
    }, 300);

    setTimeout(function () {
      expect(hot.countRows()).toBe(6);
      done();
    }, 600);
  });

  it('should fill cells when dragging the handle to the headers', function () {
    var hot = handsontable({
      data: [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 7, 4, 5, 6], [1, 2, 3, 4, 5, 6]],
      colHeaders: true,
      rowHeaders: true
    });

    // col headers:

    selectCell(2, 2);

    this.$container.find('.wtBorder.current.corner').simulate('mousedown');

    var errors = 0;

    try {
      this.$container.find('thead tr:first-child th:eq(2)').simulate('mouseover').simulate('mouseup');
    } catch (err) {
      errors++;
    }

    expect(errors).toEqual(0);
    expect(getDataAtCell(1, 2)).toEqual(7);
    expect(getDataAtCell(0, 2)).toEqual(7);

    expect($('.fill').filter(function () {
      return $(this).css('display') !== 'none';
    }).length).toEqual(0); // check if fill selection is refreshed

    // row headers:
    selectCell(2, 2);

    this.$container.find('.wtBorder.current.corner').simulate('mousedown');

    errors = 0;

    try {
      this.$container.find('tbody tr:nth(2) th:first-child').simulate('mouseover').simulate('mouseup');
    } catch (err) {
      errors++;
    }

    expect(errors).toEqual(0);
    expect(getDataAtCell(2, 1)).toEqual(7);
    expect(getDataAtCell(2, 0)).toEqual(7);
    expect($('.fill').filter(function () {
      return $(this).css('display') !== 'none';
    }).length).toEqual(0); // check if fill selection is refreshed
  });

  it('should not add a new row if dragging from the last row upwards or sideways', function (done) {
    var mouseOverSpy = jasmine.createSpy('mouseOverSpy');
    var hot = handsontable({
      data: [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 'test', 4, 5, 6], [1, 2, 3, 4, 5, 6]],
      afterOnCellMouseOver: mouseOverSpy
    });

    selectCell(3, 2);

    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    this.$container.find('tr:nth-child(3) td:eq(2)').simulate('mouseover');

    setTimeout(function () {
      expect(hot.countRows()).toBe(4);

      selectCell(3, 2);
      spec().$container.find('.wtBorder.current.corner').simulate('mousedown');
      spec().$container.find('tr:nth-child(4) td:eq(3)').simulate('mouseover');
    }, 300);

    setTimeout(function () {
      expect(hot.countRows()).toBe(4);

      selectCell(3, 2);
      spec().$container.find('.wtBorder.current.corner').simulate('mousedown');
      spec().$container.find('tr:nth-child(4) td:eq(1)').simulate('mouseover');
    }, 500);

    setTimeout(function () {
      expect(hot.countRows()).toBe(4);
      done();
    }, 700);
  });

  it('should add new row after dragging the handle below the viewport', function (done) {
    var hot = handsontable({
      data: [[1, 2, 'test', 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]]
    });

    selectCell(0, 2);

    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    var ev = {};
    var $lastRow = this.$container.find('tr:last-child td:eq(2)');

    expect(hot.countRows()).toBe(4);

    ev.clientX = $lastRow.offset().left / 2;
    ev.clientY = $lastRow.offset().top + 50;

    $(document.documentElement).simulate('mousemove', ev);

    setTimeout(function () {
      expect(hot.countRows()).toBe(5);

      ev.clientY = $lastRow.offset().top + 150;
      $(document.documentElement).simulate('mousemove', ev);
    }, 300);

    setTimeout(function () {
      expect(hot.countRows()).toBe(6);
      done();
    }, 600);
  });

  it('should not add new row after dragging the handle below the viewport (direction is set to horizontal)', function (done) {
    var hot = handsontable({
      data: [[1, 2, 'test', 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]],
      fillHandle: {
        direction: 'horizontal',
        autoInsertRow: true
      }
    });

    selectCell(0, 2);

    this.$container.find('.wtBorder.current.corner').simulate('mousedown');
    var ev = {};
    var $lastRow = this.$container.find('tr:last-child td:eq(2)');

    expect(hot.countRows()).toBe(4);

    ev.clientX = $lastRow.offset().left / 2;
    ev.clientY = $lastRow.offset().top + 50;

    $(document.documentElement).simulate('mousemove', ev);

    setTimeout(function () {
      expect(hot.countRows()).toBe(4);
      done();
    }, 300);
  });

  describe('should works properly when two or more instances of Handsontable was initialized with other settings (#3257)', function () {
    var getData;
    var $container1;
    var $container2;

    beforeAll(function () {
      getData = function getData() {
        return [[1, 2, 3, 4, 5, 6], [7, 8, 9, 1, 2, 3], [4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6]];
      };

      $container1 = $('<div id="hot1"></div>').appendTo('body').handsontable({
        data: getData(),
        fillHandle: true
      });

      $container2 = $('<div id="hot2"></div>').appendTo('body').handsontable({
        data: getData(),
        fillHandle: 'horizontal'
      });
    });

    it('checking drag vertically on 1. instance of Handsontable - should change cell value', function () {
      $container1.handsontable('selectCell', 0, 0);
      $container1.find('.wtBorder.current.corner').simulate('mousedown');
      $container1.find('tbody tr:eq(1) td:eq(0)').simulate('mouseover').simulate('mouseup');

      expect($container1.handsontable('getDataAtCell', 1, 0)).toEqual(1);
    });

    describe('-> updating settings on 2. instance of Handsontable', function () {
      beforeAll(function () {
        $container2.handsontable('updateSettings', { fillHandle: 'vertical' });
      });

      it('checking drag vertically on 2. instance of Handsontable - should change cell value', function () {
        $container2.handsontable('selectCell', 0, 2);
        $container2.find('.wtBorder.current.corner').simulate('mousedown');
        $container2.find('tbody tr:eq(1) td:eq(2)').simulate('mouseover').simulate('mouseup');

        expect($container2.handsontable('getDataAtCell', 1, 2)).toEqual(3);
      });
    });

    afterAll(function () {
      // destroing containers

      $container1.handsontable('destroy');
      $container1.remove();

      $container2.handsontable('destroy');
      $container2.remove();
    });
  });
});

/***/ }),
/* 184 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Performance', function () {
  var id = 'testContainer';

  // this is a test suite to test if there are no redundant operations

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should call renderer once for one cell (fixed column width)', function () {
    var count = 0;
    handsontable({
      data: Handsontable.helper.createSpreadsheetData(1, 1),
      colWidths: 100,
      rowHeights: 23,
      renderer: function renderer() {
        Handsontable.renderers.TextRenderer.apply(this, arguments);
        count++;
      }
    });

    expect(count).toEqual(1); // only for master table
  });

  it('should call renderer twice for one cell (auto column width)', function () {
    var count = 0;
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(1, 1),
      rowHeights: 23,
      renderer: function renderer() {
        Handsontable.renderers.TextRenderer.apply(this, arguments);
        count++;
      }
    });

    expect(count).toEqual(2); // 1 for autoColumnSize, 1 for actual cell render
  });

  it('should call renderer twice for one cell (auto row height)', function () {
    var count = 0;
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(1, 1),
      colWidths: 50,
      renderer: function renderer() {
        Handsontable.renderers.TextRenderer.apply(this, arguments);
        count++;
      }
    });

    expect(count).toEqual(1); // 1 for actual cell render (colWidths prevent autoColumnSize to enable)
  });

  it('should call renderer triple times for one cell (auto row height, auto column width)', function () {
    var count = 0;
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(1, 1),
      autoRowSize: true,
      autoColumnSize: true,
      renderer: function renderer() {
        Handsontable.renderers.TextRenderer.apply(this, arguments);
        count++;
      }
    });

    expect(count).toEqual(3); // 1 for autoColumnSize, 1 for autoRowSize, 1 for actual cell render
  });

  it('should call getCellMeta minimum number of times for one cell (auto column width, without overlays)', function () {
    var count = 0;

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(1, 1),
      rowHeights: 23,
      beforeGetCellMeta: function beforeGetCellMeta() {
        count++;
      }
    });

    expect(count).toEqual(7);
  });

  it('should call getCellMeta minimum number of times for one cell (auto row height, without overlays)', function () {
    var count = 0;

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(1, 1),
      colWidths: 50,
      beforeGetCellMeta: function beforeGetCellMeta() {
        count++;
      }
    });

    expect(count).toEqual(5);
  });

  it('should call getCellMeta minimum number of times for one cell (auto column width, with left overlay)', function () {
    var count = 0;

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(1, 1),
      colHeaders: true,
      rowHeights: 23,
      beforeGetCellMeta: function beforeGetCellMeta() {
        count++;
      }
    });

    expect(count).toEqual(8);
  });

  it('should call getCellMeta minimum number of times for one cell (auto row height, with left overlay)', function () {
    var count = 0;

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(1, 1),
      colHeaders: true,
      colWidths: 50,
      beforeGetCellMeta: function beforeGetCellMeta() {
        count++;
      }
    });

    expect(count).toEqual(6);
  });

  it('should call getCellMeta minimum number of times for one cell (auto column width, with top overlay)', function () {
    var count = 0;

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(1, 1),
      rowHeaders: true,
      rowHeights: 23,
      beforeGetCellMeta: function beforeGetCellMeta() {
        count++;
      }
    });

    expect(count).toEqual(7);
  });

  it('should call getCellMeta minimum number of times for one cell (auto row height, with top overlay)', function () {
    var count = 0;

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(1, 1),
      rowHeaders: true,
      colWidths: 50,
      beforeGetCellMeta: function beforeGetCellMeta() {
        count++;
      }
    });

    expect(count).toEqual(5);
  });

  it('should call getCellMeta minimum number of times for one cell (auto column width, with all overlays)', function () {
    var count = 0;

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(1, 1),
      colHeaders: true,
      rowHeaders: true,
      rowHeights: 23,
      beforeGetCellMeta: function beforeGetCellMeta() {
        count++;
      }
    });

    expect(count).toEqual(8);
  });

  it('should call getCellMeta minimum number of times for one cell (auto row height, with all overlays)', function () {
    var count = 0;

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(1, 1),
      colHeaders: true,
      rowHeaders: true,
      colWidths: 50,
      beforeGetCellMeta: function beforeGetCellMeta() {
        count++;
      }
    });

    expect(count).toEqual(6);
  });

  it('should call renderer twice for each cell (auto column width)', function () {
    var count = 0;
    handsontable({
      data: Handsontable.helper.createSpreadsheetData(4, 4),
      rowHeights: 23,
      autoColumnSize: true,
      renderer: function renderer() {
        Handsontable.renderers.TextRenderer.apply(this, arguments);
        count++;
      }
    });

    expect(count).toEqual(28);
  });

  it('should call renderer twice for each cell (auto row height)', function () {
    var count = 0;
    handsontable({
      data: Handsontable.helper.createSpreadsheetData(4, 4),
      colWidths: 50,
      autoRowSize: true,
      renderer: function renderer() {
        Handsontable.renderers.TextRenderer.apply(this, arguments);
        count++;
      }
    });

    expect(count).toEqual(28); // 16 in main table and 4 rows for autoRowSize
  });

  it('should call renderer twice for each cell (auto row height, auto column width)', function () {
    var count = 0;
    handsontable({
      data: Handsontable.helper.createSpreadsheetData(4, 4),
      autoRowSize: true,
      autoColumnSize: true,
      renderer: function renderer() {
        Handsontable.renderers.TextRenderer.apply(this, arguments);
        count++;
      }
    });

    expect(count).toEqual(40); // 16x2 in main table, 4 rows for autoRowSize and 4 cols for autoColumnSize
  });
});

/***/ }),
/* 185 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('PluginHooks', function () {

  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should add a many local hooks at init (as array)', function () {
    var handler1 = jasmine.createSpy('handler1');
    var handler2 = jasmine.createSpy('handler2');
    var handler3 = jasmine.createSpy('handler3');

    handsontable({
      afterInit: [handler1, handler2, handler3]
    });

    expect(handler1).toHaveBeenCalled();
    expect(handler2).toHaveBeenCalled();
    expect(handler3).toHaveBeenCalled();
  });

  it('should remove a global hook', function () {
    var test = 0,
        hook = function hook() {
      test = 5;
    };

    Handsontable.hooks.add('afterInit', hook);
    Handsontable.hooks.remove('afterInit', hook);

    handsontable();

    expect(test).toEqual(0);
  });

  it('should remove a local hook', function () {
    var test = 0,
        hook = function hook() {
      test = 5;
    };

    handsontable();

    getInstance().addHook('afterInit', hook);
    getInstance().removeHook('afterInit', hook);

    expect(test).toEqual(0);
  });

  it('should run global hook', function () {
    var test = 0;

    Handsontable.hooks.add('afterInit', function () {
      test = 5;
    });
    handsontable();
    expect(test).toEqual(5);
  });

  it('should run local hook', function () {
    var test = 0;

    handsontable();

    getInstance().addHook('myHook', function () {
      test += 5;
    });
    getInstance().runHooks('myHook');
    getInstance().runHooks('myHook');

    expect(test).toEqual(10);
  });

  it('should run local hook once', function () {
    var test = 0;

    handsontable();

    getInstance().addHookOnce('myHook', function () {
      test += 5;
    });
    getInstance().runHooks('myHook');
    getInstance().runHooks('myHook');

    expect(test).toEqual(5);
  });

  it('should run all hooks', function () {
    var test = 0;

    Handsontable.hooks.add('afterInit', function () {
      test += 5;
    });

    handsontable({
      afterInit: function afterInit() {
        test += 5;
      }
    });

    expect(test).toEqual(10);
  });

  it('list of all avaliable plugin hooks should be exposed as a public method', function () {
    var hooks = Handsontable.hooks.getRegistered(); // this is used in demo/callbacks.html

    expect(hooks.indexOf('beforeInit')).toBeGreaterThan(-1);
  });

  it('should add a local hook with addHooks method', function () {
    var hot1 = handsontable();

    var test = 0;

    hot1.addHook('myHook', function () {
      test += 5;
    });
    hot1.runHooks('myHook');

    expect(test).toEqual(5);
  });

  it('should remove a local hook with removeHook method', function () {
    var hot1 = handsontable();

    var test = 0;
    var handler = function handler() {
      test += 5;
    };

    hot1.addHook('myHook', handler);

    hot1.runHooks('myHook');
    hot1.runHooks('myHook');
    expect(test).toEqual(10);

    hot1.removeHook('myHook', handler);
    hot1.runHooks('myHook');

    expect(test).toEqual(10);
  });

  it('should add a local hook with addHookOnce method and run it just once', function () {
    var hot1 = handsontable();

    var test = 0;
    var handler = function handler() {
      test += 5;
    };

    hot1.addHookOnce('myHook', handler);

    hot1.runHooks('myHook');
    hot1.runHooks('myHook');
    expect(test).toEqual(5);
  });

  it('should run hook with runHooks and return value', function () {
    var hot = handsontable();

    var handler = function handler() {
      return 5;
    };

    hot.addHook('myHook', handler);

    expect(hot.runHooks('myHook')).toEqual(5);
  });

  it('should run two "once" hooks in desired order', function () {
    var hot = handsontable();
    var arr = [];

    hot.addHookOnce('myHook', function () {
      arr.push(1);
    });

    hot.addHookOnce('myHook', function () {
      arr.push(2);
    });

    hot.runHooks('myHook');

    expect(arr).toEqual([1, 2]);
  });

  it('should execute two "once" hooks in desired order', function () {
    var hot = handsontable();
    var str = 'a';

    hot.addHookOnce('myHook', function (str) {
      return str + 'b';
    });

    hot.addHookOnce('myHook', function (str) {
      return str + 'c';
    });

    expect(hot.runHooks('myHook', str)).toEqual('abc');
  });

  it('adding same hook twice should register it only once (without an error)', function () {
    var i = 0;
    var fn = function fn() {
      i++;
    };

    var hot = handsontable({
      afterOnCellMouseOver: fn
    });

    hot.getInstance().updateSettings({ afterOnCellMouseOver: fn });
    hot.runHooks('afterOnCellMouseOver');

    expect(i).toEqual(1);
  });

  it('should mark the hook callbacks added with Handsontable initialization', function () {
    var fn = function fn() {};
    var fn2 = function fn2() {};

    var hot = handsontable({
      afterChange: fn
    });

    hot.addHook('afterChange', fn2);

    expect(fn.initialHook).toEqual(true);
    expect(fn2.initialHook).toEqual(void 0);
  });

  it('should mark the hook callbacks added using the updateSettings method', function () {
    var fn = function fn() {};
    var fn2 = function fn2() {};

    var hot = handsontable();

    hot.updateSettings({
      afterChange: fn
    });

    hot.addHook('afterChange', fn2);

    expect(fn.initialHook).toEqual(true);
    expect(fn2.initialHook).toEqual(void 0);
  });

  it('should replace the existing hook callbacks, if they\'re updated using the updateSettings method (when there was a hook ' + 'already declared in the initialization)', function () {
    var fn = function fn() {};
    var fn2 = function fn2() {};

    var hot = handsontable({
      afterGetCellMeta: fn
    });

    var initialCallbackCount = hot.pluginHookBucket.afterGetCellMeta.length;

    hot.updateSettings({
      afterGetCellMeta: function afterGetCellMeta() {
        var a = 'another function';
      }
    });

    hot.updateSettings({
      afterGetCellMeta: function afterGetCellMeta() {
        var a = 'yet another function';
      }
    });

    hot.updateSettings({
      afterGetCellMeta: fn2
    });

    expect(hot.pluginHookBucket.afterGetCellMeta.length).toEqual(initialCallbackCount);
  });

  it('should replace the existing hook callbacks, if they\'re updated using the updateSettings method', function () {
    var fn = function fn() {};
    var fn2 = function fn2() {};

    var hot = handsontable();

    hot.addHook('afterGetCellMeta', function () {
      return 'doesn\'t matter 1';
    });
    hot.addHook('afterGetCellMeta', function () {
      return 'doesn\'t matter 2';
    });
    hot.addHook('afterGetCellMeta', function () {
      return 'doesn\'t matter 3';
    });

    hot.updateSettings({
      afterGetCellMeta: fn
    });

    var initialCallbackCount = hot.pluginHookBucket.afterGetCellMeta.length;

    hot.updateSettings({
      afterGetCellMeta: function afterGetCellMeta() {
        var a = 'another function';
      }
    });

    hot.updateSettings({
      afterGetCellMeta: function afterGetCellMeta() {
        var a = 'yet another function';
      }
    });

    hot.updateSettings({
      afterGetCellMeta: fn2
    });

    expect(hot.pluginHookBucket.afterGetCellMeta.length).toEqual(initialCallbackCount);
  });

  it('should NOT replace existing hook callbacks, if the\'re added using the addHook method', function () {
    var fn = function fn() {};
    var fn2 = function fn2() {};

    var hot = handsontable();

    hot.updateSettings({
      afterGetCellMeta: fn
    });

    var initialCallbackCount = hot.pluginHookBucket.afterGetCellMeta.length;

    hot.addHook('afterGetCellMeta', function () {
      var a = 'another function';
    });

    hot.addHook('afterGetCellMeta', function () {
      var a = 'yet another function';
    });

    hot.addHook('afterGetCellMeta', fn2);

    // should not add this one, as it's a duplicate
    hot.addHook('afterGetCellMeta', fn);

    expect(hot.pluginHookBucket.afterGetCellMeta.length).toEqual(initialCallbackCount + 3);
  });

  describe('controlling handler queue execution', function () {
    it('should execute all handlers if none of them hasn\'t skipped', function () {

      var handler1 = jasmine.createSpy('handler1');
      var handler2 = jasmine.createSpy('handler2');
      var handler3 = jasmine.createSpy('handler3');

      var hot = handsontable();

      hot.addHook('fakeEvent', handler1);
      hot.addHook('fakeEvent', handler2);
      hot.addHook('fakeEvent', handler3);

      expect(handler1).not.toHaveBeenCalled();
      expect(handler2).not.toHaveBeenCalled();
      expect(handler3).not.toHaveBeenCalled();

      hot.runHooks('fakeEvent');

      expect(handler1).toHaveBeenCalled();
      expect(handler2).toHaveBeenCalled();
      expect(handler3).toHaveBeenCalled();
    });
  });
});

/***/ }),
/* 186 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('RowHeader', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should not show row headers by default', function () {
    var that = this;
    handsontable();

    expect(that.$container.find('tbody th').length).toEqual(0);
  });

  it('should show row headers if true', function () {
    var that = this;
    handsontable({
      rowHeaders: true
    });

    expect(that.$container.find('tbody th').length).toBeGreaterThan(0);
  });

  it('should show row headers numbered 1-10 by default', function () {
    var that = this;
    var startRows = 5;
    handsontable({
      startRows: startRows,
      rowHeaders: true
    });

    var ths = getLeftClone().find('tbody th');
    expect(ths.length).toEqual(startRows);
    expect($.trim(ths.eq(0).text())).toEqual('1');
    expect($.trim(ths.eq(1).text())).toEqual('2');
    expect($.trim(ths.eq(2).text())).toEqual('3');
    expect($.trim(ths.eq(3).text())).toEqual('4');
    expect($.trim(ths.eq(4).text())).toEqual('5');
  });

  it('should show row headers with custom label', function () {
    var that = this;
    var startRows = 5;
    handsontable({
      startRows: startRows,
      rowHeaders: ['First', 'Second', 'Third']
    });

    var ths = getLeftClone().find('tbody th');
    expect(ths.length).toEqual(startRows);
    expect($.trim(ths.eq(0).text())).toEqual('First');
    expect($.trim(ths.eq(1).text())).toEqual('Second');
    expect($.trim(ths.eq(2).text())).toEqual('Third');
    expect($.trim(ths.eq(3).text())).toEqual('4');
    expect($.trim(ths.eq(4).text())).toEqual('5');
  });

  it('should not show row headers if false', function () {
    var that = this;
    handsontable({
      rowHeaders: false
    });

    expect(getLeftClone().find('tbody th').length).toEqual(0);
  });

  it('should hide rows headers after updateSetting', function () {
    var hot = handsontable({
      startRows: 5,
      rowHeaders: true
    });

    expect(getHtCore().find('tbody th').length).toEqual(5);
    expect(getLeftClone().find('tbody th').length).toEqual(5);

    hot.updateSettings({
      rowHeaders: false
    });

    expect(getHtCore().find('tbody th').length).toEqual(0);
  });

  it('should show rows headers after updateSettings', function () {
    var hot = handsontable({
      startRows: 5,
      rowHeaders: false
    });

    expect(getHtCore().find('tbody th').length).toEqual(0);
    expect(getLeftClone().find('tbody th').length).toEqual(0);

    hot.updateSettings({
      rowHeaders: true
    });

    expect(getHtCore().find('tbody th').length).toEqual(5);
    expect(getLeftClone().find('tbody th').length).toEqual(5);
  });

  it('should show/hide rows headers after multiple updateSettings', function () {
    var hot = handsontable({
      startRows: 5,
      rowHeaders: false
    });

    expect(getHtCore().find('tbody th').length).toEqual(0);
    expect(getLeftClone().find('tbody th').length).toEqual(0);

    hot.updateSettings({
      rowHeaders: true
    });

    expect(getHtCore().find('tbody th').length).toEqual(5);
    expect(getLeftClone().width()).toBeGreaterThan(0);

    hot.updateSettings({
      rowHeaders: false
    });

    expect(getHtCore().find('tbody th').length).toEqual(0);
    expect(getLeftClone().width()).toEqual(0);

    hot.updateSettings({
      rowHeaders: true
    });

    expect(getHtCore().find('tbody th').length).toEqual(5);
    expect(getLeftClone().width()).toBeGreaterThan(0);
  });

  it('should show new rows headers after updateSettings', function () {
    var hot = handsontable({
      startCols: 3,
      rowHeaders: ['A', 'B', 'C']
    });

    var leftClone = getLeftClone();

    expect(leftClone.find('tbody tr:eq(0) th:eq(0)').text()).toEqual('A');
    expect(leftClone.find('tbody tr:eq(1) th:eq(0)').text()).toEqual('B');
    expect(leftClone.find('tbody tr:eq(2) th:eq(0)').text()).toEqual('C');

    hot.updateSettings({
      rowHeaders: ['X', 'Y', 'Z']
    });

    expect(leftClone.find('tbody tr:eq(0) th:eq(0)').text()).toEqual('X');
    expect(leftClone.find('tbody tr:eq(1) th:eq(0)').text()).toEqual('Y');
    expect(leftClone.find('tbody tr:eq(2) th:eq(0)').text()).toEqual('Z');
  });

  it('should allow defining custom row header width using the rowHeaderWidth config option', function () {
    var hot = handsontable({
      startCols: 3,
      rowHeaders: true,
      rowHeaderWidth: 150
    });

    expect(this.$container.find('th').eq(0).outerWidth()).toEqual(150);
    expect(this.$container.find('col').first().css('width')).toEqual('150px');
  });

  it('should allow defining custom column header heights using the columnHeaderHeight config option, when multiple column header levels are defined', function () {
    var hot = handsontable({
      startCols: 3,
      rowHeaders: true,
      rowHeaderWidth: [66, 96],
      afterGetRowHeaderRenderers: function afterGetRowHeaderRenderers(array) {
        array.push(function (index, TH) {
          TH.innerHTML = '';

          var div = document.createElement('div');
          var span = document.createElement('span');

          div.className = 'relative';
          span.className = 'rowHeader';

          span.innerText = index;

          div.appendChild(span);
          TH.appendChild(div);
        });

        return array;
      }
    });
    hot.render();

    expect(this.$container.find('.handsontable.ht_clone_left tr:nth-child(1) th:nth-child(1)').outerWidth()).toEqual(66);
    expect(this.$container.find('.handsontable.ht_clone_left tr:nth-child(1) th:nth-child(2)').outerWidth()).toEqual(96);

    expect(this.$container.find('col').first().css('width')).toEqual('66px');
    expect(this.$container.find('col').eq(1).css('width')).toEqual('96px');
  });
});

/***/ }),
/* 187 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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"); } }

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; }

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

describe('cellTypes', function () {
  var id = 'testContainer';
  var _Handsontable$cellTyp = Handsontable.cellTypes,
      registerCellType = _Handsontable$cellTyp.registerCellType,
      getCellType = _Handsontable$cellTyp.getCellType;
  var _Handsontable$editors = Handsontable.editors,
      registerEditor = _Handsontable$editors.registerEditor,
      getEditor = _Handsontable$editors.getEditor,
      BaseEditor = _Handsontable$editors.BaseEditor;
  var _Handsontable$rendere = Handsontable.renderers,
      registerRenderer = _Handsontable$rendere.registerRenderer,
      getRenderer = _Handsontable$rendere.getRenderer;
  var _Handsontable$validat = Handsontable.validators,
      registerValidator = _Handsontable$validat.registerValidator,
      getValidator = _Handsontable$validat.getValidator;


  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should register custom cell type (with custom editor, renderer and validator)', _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
    var MyEditor, onAfterValidate, hot;
    return regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            MyEditor = function (_BaseEditor) {
              _inherits(MyEditor, _BaseEditor);

              function MyEditor() {
                _classCallCheck(this, MyEditor);

                return _possibleConstructorReturn(this, (MyEditor.__proto__ || Object.getPrototypeOf(MyEditor)).apply(this, arguments));
              }

              _createClass(MyEditor, [{
                key: 'init',
                value: function init() {
                  this.TEXTAREA = document.createElement('TEXTAREA');
                  this.TEXTAREA_PARENT = document.createElement('DIV');

                  this.TEXTAREA_PARENT.appendChild(this.TEXTAREA);
                  this.instance.rootElement.appendChild(this.TEXTAREA_PARENT);
                }
              }, {
                key: 'getValue',
                value: function getValue() {
                  return '**' + this.TEXTAREA.value + '**';
                }
              }, {
                key: 'setValue',
                value: function setValue(value) {
                  this.TEXTAREA.value = value;
                }
              }, {
                key: 'open',
                value: function open() {}
              }, {
                key: 'close',
                value: function close() {}
              }, {
                key: 'focus',
                value: function focus() {
                  this.TEXTAREA.focus();
                }
              }]);

              return MyEditor;
            }(BaseEditor);

            registerCellType('myCellType', {
              editor: MyEditor,
              renderer: function renderer(hot, td, row, col, prop, value, cellProperties) {
                td.innerHTML = '--' + value + '--';
              },
              validator: function validator(value, cb) {
                cb(value === 10);
              }
            });

            onAfterValidate = jasmine.createSpy('onAfterValidate');
            hot = handsontable({
              data: [[1, 6, 10]],
              columns: [{
                type: 'myCellType'
              }],
              afterValidate: onAfterValidate
            });


            hot.setDataAtCell(1, 0, 10);

            _context.next = 7;
            return sleep(100);

          case 7:

            expect(onAfterValidate).toHaveBeenCalledWith(true, 10, 1, 0, undefined, undefined);
            expect(getCell(1, 0).innerHTML).toBe('--10--');

            selectCell(0, 0);
            keyDown('enter');
            document.activeElement.value = 'hello';
            destroyEditor();

            _context.next = 15;
            return sleep(100);

          case 15:

            expect(onAfterValidate).toHaveBeenCalledWith(false, '**hello**', 0, 0, 'edit', undefined);
            expect(getCell(0, 0).innerHTML).toBe('--**hello**--');

          case 17:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, undefined);
  })));

  it('should retrieve predefined cell types by its names', function () {
    var _Handsontable = Handsontable,
        editors = _Handsontable.editors,
        renderers = _Handsontable.renderers,
        validators = _Handsontable.validators;


    expect(getCellType('autocomplete').editor).toBe(editors.AutocompleteEditor);
    expect(getCellType('autocomplete').renderer).toBe(renderers.AutocompleteRenderer);
    expect(getCellType('autocomplete').validator).toBe(validators.AutocompleteValidator);

    expect(getCellType('checkbox').editor).toBe(editors.CheckboxEditor);
    expect(getCellType('checkbox').renderer).toBe(renderers.CheckboxRenderer);
    expect(getCellType('checkbox').validator).not.toBeDefined();

    expect(getCellType('date').editor).toBe(editors.DateEditor);
    expect(getCellType('date').renderer).toBe(renderers.AutocompleteRenderer);
    expect(getCellType('date').validator).toBe(validators.DateValidator);

    expect(getCellType('dropdown').editor).toBe(editors.DropdownEditor);
    expect(getCellType('dropdown').renderer).toBe(renderers.AutocompleteRenderer);
    expect(getCellType('dropdown').validator).toBe(validators.AutocompleteValidator);

    expect(getCellType('handsontable').editor).toBe(editors.HandsontableEditor);
    expect(getCellType('handsontable').renderer).toBe(renderers.AutocompleteRenderer);
    expect(getCellType('handsontable').validator).not.toBeDefined();

    expect(getCellType('numeric').editor).toBe(editors.NumericEditor);
    expect(getCellType('numeric').renderer).toBe(renderers.NumericRenderer);
    expect(getCellType('numeric').validator).toBe(validators.NumericValidator);
    expect(getCellType('numeric').dataType).toBe('number');

    expect(getCellType('password').editor).toBe(editors.PasswordEditor);
    expect(getCellType('password').renderer).toBe(renderers.PasswordRenderer);
    expect(getCellType('password').validator).not.toBeDefined();
    expect(getCellType('password').copyable).toBe(false);

    expect(getCellType('text').editor).toBe(editors.TextEditor);
    expect(getCellType('text').renderer).toBe(renderers.TextRenderer);
    expect(getCellType('text').validator).not.toBeDefined();

    expect(getCellType('time').editor).toBe(editors.TextEditor);
    expect(getCellType('time').renderer).toBe(renderers.TextRenderer);
    expect(getCellType('time').validator).toBe(validators.TimeValidator);
  });

  it('should register custom cell type into renderers, editors and validators', function () {
    var MyEditor = function MyEditor() {
      _classCallCheck(this, MyEditor);
    };

    function myRenderer() {}
    function myValidator() {}

    registerCellType('myCellType', {
      editor: MyEditor,
      renderer: myRenderer,
      validator: myValidator
    });

    expect(getEditor('myCellType')).toBe(MyEditor);
    expect(getRenderer('myCellType')).toBe(myRenderer);
    expect(getValidator('myCellType')).toBe(myValidator);
  });

  it('should overwrite cell types under the same name', function () {
    var MyEditor = function MyEditor() {
      _classCallCheck(this, MyEditor);
    };

    function myRenderer() {}
    function myValidator() {}

    registerCellType('myCellType', {
      editor: MyEditor,
      renderer: myRenderer,
      validator: myValidator
    });

    expect(getEditor('myCellType')).toBe(MyEditor);
    expect(getRenderer('myCellType')).toBe(myRenderer);
    expect(getValidator('myCellType')).toBe(myValidator);

    function myRenderer2() {}
    function myValidator2() {}

    registerCellType('myCellType', {
      renderer: myRenderer2,
      validator: myValidator2
    });

    expect(getEditor('myCellType')).toBe(MyEditor);
    expect(getRenderer('myCellType')).toBe(myRenderer2);
    expect(getValidator('myCellType')).toBe(myValidator2);
  });

  it('should retrieve custom cell type by its names', function () {
    var MyEditor = function MyEditor() {
      _classCallCheck(this, MyEditor);
    };

    function myRenderer() {}
    function myValidator() {}

    registerCellType('myCellType', {
      editor: MyEditor,
      renderer: myRenderer,
      validator: myValidator
    });

    expect(getCellType('myCellType').editor).toBe(MyEditor);
    expect(getCellType('myCellType').renderer).toBe(myRenderer);
    expect(getCellType('myCellType').validator).toBe(myValidator);
  });
});

/***/ }),
/* 188 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.colToProp', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should return the property name for the provided column number', function () {
    var hot = handsontable({
      data: [{
        id: 1,
        firstName: 'Tobias',
        lastName: 'Forge'
      }]
    });

    expect(colToProp(0)).toBe('id');
    expect(colToProp(1)).toBe('firstName');
    expect(colToProp(2)).toBe('lastName');
  });

  it('it should return the provided property name, when the user passes a property name as a column number', function () {
    var hot = handsontable({
      data: [{
        id: 1,
        sort: true,
        length: 2
      }]
    });

    expect(colToProp('id')).toBe('id');
    expect(colToProp('sort')).toBe('sort');
    expect(colToProp('length')).toBe('length');
  });
});

/***/ }),
/* 189 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.countSourceCols', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should return properly index from ', function () {
    var hot = handsontable({
      data: [['', '', '', '', '', '', '', '', '', '', '', '', '', '', '']],
      columns: function columns(column) {
        return [1, 5, 9].indexOf(column) > -1 ? {} : null;
      }
    });

    expect(hot.countSourceCols()).toBe(15);
  });
});

/***/ }),
/* 190 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.getCellMetaAtRow', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should return a row of cell meta in a form of an array', function () {
    handsontable();

    var rowOfMeta = getCellMetaAtRow(0);
    expect(rowOfMeta.length).toBe(5);
    expect(rowOfMeta[0].row).toBe(0);
    expect(rowOfMeta[1].row).toBe(0);
    expect(rowOfMeta[2].row).toBe(0);
    expect(rowOfMeta[3].row).toBe(0);
    expect(rowOfMeta[4].row).toBe(0);
    expect(rowOfMeta[0].col).toBe(0);
    expect(rowOfMeta[1].col).toBe(1);
    expect(rowOfMeta[2].col).toBe(2);
    expect(rowOfMeta[3].col).toBe(3);
    expect(rowOfMeta[4].col).toBe(4);
    expect(rowOfMeta[0].prop).toBe(0);
    expect(rowOfMeta[1].prop).toBe(1);
    expect(rowOfMeta[2].prop).toBe(2);
    expect(rowOfMeta[3].prop).toBe(3);
    expect(rowOfMeta[4].prop).toBe(4);
  });
});

/***/ }),
/* 191 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.getCellsMeta', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should return all initialized cells meta as flatten array', function () {
    handsontable();

    var metas = getCellsMeta();

    expect(metas.length).toBe(25); // default data size
    expect(metas[0].row).toBe(0);
    expect(metas[0].col).toBe(0);
    expect(metas[0].prop).toBe(0);
    expect(metas[19].row).toBe(3);
    expect(metas[19].col).toBe(4);
    expect(metas[19].prop).toBe(4);
  });
});

/***/ }),
/* 192 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.getCopyableData', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should return copyable data when `copyable` option is enabled', function () {
    handsontable({
      data: Handsontable.helper.createSpreadsheetData(10, 10),
      copyable: true
    });

    expect(getCopyableData(0, 0)).toBe('A1');
    expect(getCopyableData(1, 1)).toBe('B2');
    expect(getCopyableData(5, 1)).toBe('B6');
    expect(getCopyableData(8, 9)).toBe('J9');
  });

  it('should return empty string as copyable data when `copyable` option is disabled', function () {
    handsontable({
      data: Handsontable.helper.createSpreadsheetData(10, 10),
      copyable: false
    });

    expect(getCopyableData(0, 0)).toBe('');
    expect(getCopyableData(1, 1)).toBe('');
    expect(getCopyableData(5, 1)).toBe('');
    expect(getCopyableData(8, 9)).toBe('');
  });
});

/***/ }),
/* 193 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.getCopyableText', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should return copyable string when `copyable` option is enabled', function () {
    handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 5),
      copyable: true
    });

    expect(getCopyableText(0, 0)).toBe('A1');
    expect(getCopyableText(0, 0, 1, 2)).toBe('A1\tB1\tC1\nA2\tB2\tC2');
  });

  it('should return empty string as copyable data when `copyable` option is disabled', function () {
    handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 5),
      copyable: false
    });

    expect(getCopyableText(0, 0)).toBe('');
    expect(getCopyableText(0, 0, 1, 2)).toBe('\t\t\n\t\t');
  });
});

/***/ }),
/* 194 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.getSourceDataArray', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should return data as an array when provided data was an array of arrays', function () {
    handsontable({
      data: [[1, 2, 3], ['a', 'b', 'c']],
      copyable: true
    });

    expect(getSourceDataArray()).toEqual([[1, 2, 3], ['a', 'b', 'c']]);
    expect(getSourceDataArray(0, 1, 1, 2)).toEqual([[2, 3], ['b', 'c']]);
  });

  it('should return data as an array when provided data was an array of objects', function () {
    handsontable({
      data: [{ a: 1, b: 2, c: 3 }, { a: 'a', b: 'b', c: 'c' }],
      copyable: true
    });

    expect(getSourceDataArray()).toEqual([[1, 2, 3], ['a', 'b', 'c']]);
    expect(getSourceDataArray(0, 1, 1, 2)).toEqual([[2, 3], ['b', 'c']]);
  });
});

/***/ }),
/* 195 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.getSourceDataAtCell', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should return null when is call without arguments', function () {
    handsontable({
      data: [[1, 2, 3], ['a', 'b', 'c']]
    });

    expect(getSourceDataAtCell()).toBeNull();
  });

  it('should return cell value when provided data was an array of arrays', function () {
    handsontable({
      data: [[1, 2, 3], ['a', 'b', 'c']]
    });

    expect(getSourceDataAtCell(1, 1)).toEqual('b');
  });

  it('should return cell value when provided data was an array of objects', function () {
    handsontable({
      data: [{ a: 1, b: 2, c: 3 }, { a: 'a', b: 'b', c: 'c' }],
      copyable: true
    });

    expect(getSourceDataAtCell(1, 'b')).toEqual('b');
  });

  it('should return cell value when provided data was an array of objects (nested structure)', function () {
    handsontable({
      data: [{ a: 1, b: { a: 21, b: 22 }, c: 3 }, { a: 'a', b: { a: 'ba', b: 'bb' }, c: 'c' }],
      columns: [{ data: 'a' }, { data: 'b.a' }, { data: 'b.b' }, { data: 'c' }]
    });

    expect(getSourceDataAtCell(1, 'b.b')).toEqual('bb');
  });

  it('should return cell value when data is provided by dataSchema', function () {
    handsontable({
      data: [model({ id: 1, name: 'Ted Right', address: '' }), model({ id: 2, name: 'Frank Honest', address: '' }), model({ id: 3, name: 'Joan Well', address: '' }), model({ id: 4, name: 'Gail Polite', address: '' }), model({ id: 5, name: 'Michael Fair', address: '' })],
      dataSchema: model,
      columns: [{ data: property('id') }, { data: property('name') }, { data: property('address') }]
    });

    function model(opts) {
      var _pub = {},
          _priv = {
        id: undefined,
        name: undefined,
        address: undefined
      };

      for (var i in opts) {
        if (Object.prototype.hasOwnProperty.call(opts, i)) {
          _priv[i] = opts[i];
        }
      }

      _pub.attr = function (attr, val) {
        if (typeof val === 'undefined') {
          return _priv[attr];
        }
        _priv[attr] = val;

        return _pub;
      };

      return _pub;
    }

    function property(attr) {
      return function (row, value) {
        return row.attr(attr, value);
      };
    }

    expect(getSourceDataAtCell(1, 1)).toEqual('Frank Honest');
  });

  describe('`modifyRowData` hook', function () {
    it('should be possible to change data for row on the fly ', function () {
      handsontable({
        data: [['', 'Kia', 'Nissan', 'Toyota', 'Honda'], ['2008', 10, 11, 12, 13], ['2009', 20, 11, 14, 13], ['2010', 30, 15, 12, 13]],
        modifyRowData: function modifyRowData(row) {
          var newDataset = [];

          if (row === 1) {
            newDataset.push('2016', 0, 0, 0, 0);
          }

          return newDataset.length ? newDataset : void 0;
        }
      });

      expect(getSourceDataAtCell(1, 0)).toEqual('2016');
    });
  });
});

/***/ }),
/* 196 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.propToCol', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should return valid index for newly added column when manualColumnMove is enabled', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(10, 10),
      manualColumnMove: true
    });

    hot.alter('insert_col', 5);

    expect(propToCol(0)).toBe(0);
    expect(propToCol(10)).toBe(10);
  });
});

/***/ }),
/* 197 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.setCellMeta', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should set correct meta className for cell', function () {

    var className = 'htCenter htMiddle';

    handsontable({
      afterCellMetaReset: function afterCellMetaReset() {
        this.setCellMeta(0, 0, 'className', className);
      }
    });

    var cellMeta = getCellMeta(0, 0);

    expect(cellMeta.className).not.toBeUndefined();
    expect(cellMeta.className).toEqual(className);
  });

  it('should set correct meta className for non existed cell', function () {

    var className = 'htCenter htMiddle';

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 5),
      afterCellMetaReset: function afterCellMetaReset() {
        this.setCellMeta(100, 100, 'className', className);
      }
    });

    var cellMeta = getCellMeta(100, 100);

    expect(cellMeta.className).not.toBeUndefined();
    expect(cellMeta.className).toEqual(className);
  });

  it('should set correct meta classNames for cells using cell in configuration', function () {
    var classNames = ['htCenter htTop', 'htRight htBottom'];

    handsontable({
      cell: [{ row: 0, col: 0, className: classNames[0] }, { row: 1, col: 1, className: classNames[1] }]
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)')[0].className).toEqual(classNames[0]);
    expect(this.$container.find('tbody tr:eq(1) td:eq(1)')[0].className).toEqual(classNames[1]);
  });

  it('should change cell meta data with updateSettings when the cell option is defined', function () {
    var classNames = ['htCenter htTop', 'htRight htBottom'];

    handsontable({
      cell: [{ row: 0, col: 0, className: classNames[0] }, { row: 1, col: 1, className: classNames[1] }]
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)')[0].className).toEqual(classNames[0]);
    expect(this.$container.find('tbody tr:eq(1) td:eq(1)')[0].className).toEqual(classNames[1]);

    updateSettings({
      cell: []
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)')[0].className).toEqual('');
    expect(this.$container.find('tbody tr:eq(1) td:eq(1)')[0].className).toEqual('');

    updateSettings({
      cell: [{ row: 0, col: 0, className: classNames[1] }, { row: 1, col: 1, className: classNames[0] }]
    });

    expect(this.$container.find('tbody tr:eq(0) td:eq(0)')[0].className).toEqual(classNames[1]);
    expect(this.$container.find('tbody tr:eq(1) td:eq(1)')[0].className).toEqual(classNames[0]);
  });

  it('should call afterSetCellMeta plugin hook', function () {
    var className = 'htCenter htMiddle';
    var res = {};

    handsontable({
      afterCellMetaReset: function afterCellMetaReset() {
        this.setCellMeta(0, 1, 'className', className);
      },
      afterSetCellMeta: function afterSetCellMeta(row, col, key, val) {
        res.row = row;
        res.col = col;
        res.key = key;
        res.val = val;
      }
    });

    expect(res.row).toEqual(0);
    expect(res.col).toEqual(1);
    expect(res.key).toEqual('className');
    expect(res.val).toEqual(className);
  });
});

/***/ }),
/* 198 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.spliceCellsMeta', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should splice the cell meta array analogously to the native `splice` method', function () {
    handsontable();

    var allMeta = getCellsMeta();
    expect(allMeta.length).toBe(25);
    spliceCellsMeta(3, 1);
    allMeta = getCellsMeta();
    expect(allMeta.length).toBe(20);

    var metaAtRow = getCellMetaAtRow(2);
    expect(metaAtRow[0].row).toEqual(2);
    metaAtRow = getCellMetaAtRow(3);
    expect(metaAtRow[0].row).toEqual(4);
  });
});

/***/ }),
/* 199 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.spliceCol', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should remove from the second column three rows starting from the beginning', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 5)
    });

    var removedData = hot.spliceCol(1, 0, 3);

    expect(removedData).toEqual(['B1', 'B2', 'B3']);
    expect(hot.getDataAtRow(0)).toEqual(['A1', 'B4', 'C1', 'D1', 'E1']);
    expect(hot.getDataAtRow(1)).toEqual(['A2', 'B5', 'C2', 'D2', 'E2']);
    expect(hot.getDataAtRow(2)).toEqual(['A3', null, 'C3', 'D3', 'E3']);
    expect(hot.getDataAtRow(3)).toEqual(['A4', null, 'C4', 'D4', 'E4']);
    expect(hot.getDataAtRow(4)).toEqual(['A5', null, 'C5', 'D5', 'E5']);
  });

  it('should remove from the third column three rows starting from the second row', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 5)
    });

    var removedData = hot.spliceCol(2, 1, 3);

    expect(removedData).toEqual(['C2', 'C3', 'C4']);
    expect(hot.getDataAtRow(0)).toEqual(['A1', 'B1', 'C1', 'D1', 'E1']);
    expect(hot.getDataAtRow(1)).toEqual(['A2', 'B2', 'C5', 'D2', 'E2']);
    expect(hot.getDataAtRow(2)).toEqual(['A3', 'B3', null, 'D3', 'E3']);
    expect(hot.getDataAtRow(3)).toEqual(['A4', 'B4', null, 'D4', 'E4']);
    expect(hot.getDataAtRow(4)).toEqual(['A5', 'B5', null, 'D5', 'E5']);
  });

  it('should replace and append new rows in the second column starting from the second row', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 5)
    });

    var removedData = hot.spliceCol(1, 1, 3, 'X1', 'X2', 'X3', 'X4', 'X5');

    expect(removedData).toEqual(['B2', 'B3', 'B4']);
    expect(hot.getDataAtRow(0)).toEqual(['A1', 'B1', 'C1', 'D1', 'E1']);
    expect(hot.getDataAtRow(1)).toEqual(['A2', 'X1', 'C2', 'D2', 'E2']);
    expect(hot.getDataAtRow(2)).toEqual(['A3', 'X2', 'C3', 'D3', 'E3']);
    expect(hot.getDataAtRow(3)).toEqual(['A4', 'X3', 'C4', 'D4', 'E4']);
    expect(hot.getDataAtRow(4)).toEqual(['A5', 'X4', 'C5', 'D5', 'E5']);
    expect(hot.getDataAtRow(5)).toEqual([null, 'X5', null, null, null]);
    expect(hot.getDataAtRow(6)).toEqual([null, 'B5', null, null, null]);
  });

  it('should trigger beforeChange and afterChange hook with proper arguments', function () {
    var spyAfter = jasmine.createSpy('after');
    var spyBefore = jasmine.createSpy('before');
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 5),
      beforeChange: spyBefore,
      afterChange: spyAfter
    });

    hot.spliceCol(2, 1, 3, 'X1');

    expect(spyBefore.calls.argsFor(0)[0]).toEqual([[1, 2, 'C2', 'X1'], [2, 2, 'C3', 'C5'], [3, 2, 'C4', null], [4, 2, 'C5', null], [5, 2, null, null]]);
    expect(spyBefore.calls.argsFor(0)[1]).toBe('spliceCol');
    expect(spyAfter.calls.argsFor(1)[0]).toEqual([[1, 2, 'C2', 'X1'], [2, 2, 'C3', 'C5'], [3, 2, 'C4', null], [4, 2, 'C5', null], [5, 2, null, null]]);
    expect(spyAfter.calls.argsFor(1)[1]).toBe('spliceCol');
  });

  it('should trigger beforeCreateRow and afterCreateRow hook with proper arguments', function () {
    var spyAfter = jasmine.createSpy('after');
    var spyBefore = jasmine.createSpy('before');
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 5),
      beforeCreateRow: spyBefore,
      afterCreateRow: spyAfter
    });

    hot.spliceCol(2, 1, 3, 'X1', 'X2', 'X3', 'X4');

    expect(spyBefore).toHaveBeenCalledWith(5, 1, 'spliceCol', undefined, undefined, undefined);
    expect(spyAfter).toHaveBeenCalledWith(5, 1, 'spliceCol', undefined, undefined, undefined);
  });
});

/***/ }),
/* 200 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.spliceRow', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should remove from the second row three columns starting from the beginning', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 5)
    });

    var removedData = hot.spliceRow(1, 0, 3);

    expect(removedData).toEqual(['A2', 'B2', 'C2']);
    expect(hot.getDataAtRow(0)).toEqual(['A1', 'B1', 'C1', 'D1', 'E1']);
    expect(hot.getDataAtRow(1)).toEqual(['D2', 'E2', null, null, null]);
    expect(hot.getDataAtRow(2)).toEqual(['A3', 'B3', 'C3', 'D3', 'E3']);
    expect(hot.getDataAtRow(3)).toEqual(['A4', 'B4', 'C4', 'D4', 'E4']);
    expect(hot.getDataAtRow(4)).toEqual(['A5', 'B5', 'C5', 'D5', 'E5']);
  });

  it('should remove from the third row three columns starting from the second column', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 5)
    });

    var removedData = hot.spliceRow(2, 1, 3);

    expect(removedData).toEqual(['B3', 'C3', 'D3']);
    expect(hot.getDataAtRow(0)).toEqual(['A1', 'B1', 'C1', 'D1', 'E1']);
    expect(hot.getDataAtRow(1)).toEqual(['A2', 'B2', 'C2', 'D2', 'E2']);
    expect(hot.getDataAtRow(2)).toEqual(['A3', 'E3', null, null, null]);
    expect(hot.getDataAtRow(3)).toEqual(['A4', 'B4', 'C4', 'D4', 'E4']);
    expect(hot.getDataAtRow(4)).toEqual(['A5', 'B5', 'C5', 'D5', 'E5']);
  });

  it('should replace and append new columns in the second row starting from the second column', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 5)
    });

    var removedData = hot.spliceRow(1, 1, 3, 'X1', 'X2', 'X3', 'X4', 'X5');

    expect(removedData).toEqual(['B2', 'C2', 'D2']);
    expect(hot.getDataAtRow(0)).toEqual(['A1', 'B1', 'C1', 'D1', 'E1', null, null]);
    expect(hot.getDataAtRow(1)).toEqual(['A2', 'X1', 'X2', 'X3', 'X4', 'X5', 'E2']);
    expect(hot.getDataAtRow(2)).toEqual(['A3', 'B3', 'C3', 'D3', 'E3', null, null]);
    expect(hot.getDataAtRow(3)).toEqual(['A4', 'B4', 'C4', 'D4', 'E4', null, null]);
    expect(hot.getDataAtRow(4)).toEqual(['A5', 'B5', 'C5', 'D5', 'E5', null, null]);
  });

  it('should trigger beforeChange and afterChange hook with proper arguments', function () {
    var spyAfter = jasmine.createSpy('after');
    var spyBefore = jasmine.createSpy('before');
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 5),
      beforeChange: spyBefore,
      afterChange: spyAfter
    });

    hot.spliceRow(2, 1, 3, 'X1');

    expect(spyBefore.calls.argsFor(0)[0]).toEqual([[2, 1, 'B3', 'X1'], [2, 2, 'C3', 'E3'], [2, 3, 'D3', null], [2, 4, 'E3', null], [2, 5, undefined, null]]);
    expect(spyBefore.calls.argsFor(0)[1]).toBe('spliceRow');
    expect(spyAfter.calls.argsFor(1)[0]).toEqual([[2, 1, 'B3', 'X1'], [2, 2, 'C3', 'E3'], [2, 3, 'D3', null], [2, 4, 'E3', null], [2, 5, undefined, null]]);
    expect(spyAfter.calls.argsFor(1)[1]).toBe('spliceRow');
  });

  it('should trigger beforeCreateCol and afterCreateCol hook with proper arguments', function () {
    var spyAfter = jasmine.createSpy('after');
    var spyBefore = jasmine.createSpy('before');
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 5),
      beforeCreateCol: spyBefore,
      afterCreateCol: spyAfter
    });

    hot.spliceRow(2, 1, 3, 'X1', 'X2', 'X3', 'X4');

    expect(spyBefore).toHaveBeenCalledWith(5, 1, 'spliceRow', undefined, undefined, undefined);
    expect(spyAfter).toHaveBeenCalledWith(5, 1, 'spliceRow', undefined, undefined, undefined);
  });
});

/***/ }),
/* 201 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.toPhysicalColumn', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should return valid physical row index', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(10, 10),
      modifyCol: function modifyCol(column) {
        return column + 3;
      }
    });

    expect(hot.toPhysicalColumn(0)).toBe(3);
    expect(hot.toPhysicalColumn(1)).toBe(4);
    expect(hot.toPhysicalColumn(2)).toBe(5);
  });
});

/***/ }),
/* 202 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.toPhysicalRow', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should return valid physical row index', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(10, 10),
      modifyRow: function modifyRow(row) {
        return row + 3;
      }
    });

    expect(hot.toPhysicalRow(0)).toBe(3);
    expect(hot.toPhysicalRow(1)).toBe(4);
    expect(hot.toPhysicalRow(2)).toBe(5);
  });
});

/***/ }),
/* 203 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.toVisualColumn', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should return valid visual row index', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(10, 10),
      unmodifyCol: function unmodifyCol(column) {
        return column + 3;
      }
    });

    expect(hot.toVisualColumn(0)).toBe(3);
    expect(hot.toVisualColumn(1)).toBe(4);
    expect(hot.toVisualColumn(2)).toBe(5);
  });
});

/***/ }),
/* 204 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Core.toVisualRow', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should return valid visual row index', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(10, 10),
      unmodifyRow: function unmodifyRow(row) {
        return row + 3;
      }
    });

    expect(hot.toVisualRow(0)).toBe(3);
    expect(hot.toVisualRow(1)).toBe(4);
    expect(hot.toVisualRow(2)).toBe(5);
  });
});

/***/ }),
/* 205 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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; };

describe('AutocompleteEditor', function () {
  var id = 'testContainer';

  var choices = ['yellow', 'red', 'orange', 'green', 'blue', 'gray', 'black', 'white', 'purple', 'lime', 'olive', 'cyan'];

  var hot;

  beforeEach(function () {
    this.$container = $('<div id="' + id + '" style="width: 300px; height: 200px; overflow: auto"></div>').appendTo('body');
  });

  afterEach(function () {
    if (hot) {
      hot = null;
    }

    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  describe('open editor', function () {
    it('should display editor (after hitting ENTER)', function () {
      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: choices
        }]
      });
      selectCell(0, 0);
      var editor = $('.autocompleteEditor');

      expect(editor.is(':visible')).toBe(false);

      keyDownUp('enter');

      expect(editor.is(':visible')).toBe(true);
    });

    it('should display editor (after hitting F2)', function () {
      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: choices
        }]
      });
      selectCell(0, 0);
      var editor = $('.autocompleteEditor');

      expect(editor.is(':visible')).toBe(false);

      keyDownUp('f2');

      expect(editor.is(':visible')).toBe(true);
    });

    it('should display editor (after doubleclicking)', function () {
      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: choices
        }]
      });
      selectCell(0, 0);
      var editor = $('.autocompleteEditor');

      expect(editor.is(':visible')).toBe(false);

      mouseDoubleClick($(getCell(0, 0)));

      expect(editor.is(':visible')).toBe(true);
    });

    // see https://github.com/handsontable/handsontable/issues/3380
    it('should not throw error while selecting the next cell by hitting enter key', function () {
      var spy = jasmine.createSpyObj('error', ['test']);
      var prevError = window.onerror;

      window.onerror = function (messageOrEvent, source, lineno, colno, error) {
        spy.test();
      };
      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: choices
        }]
      });

      selectCell(0, 0);
      keyDownUp('enter');
      keyDownUp('enter');
      keyDownUp('enter');

      expect(spy.test.calls.count()).toBe(0);

      window.onerror = prevError;
    });
  });

  describe('choices', function () {
    it('should display given choices (array)', function (done) {
      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: choices
        }]
      });
      selectCell(0, 0);
      var editor = $('.autocompleteEditor');

      keyDownUp('enter');

      setTimeout(function () {
        expect(editor.find('tbody td:eq(0)').text()).toEqual(choices[0]);
        expect(editor.find('tbody td:eq(1)').text()).toEqual(choices[1]);
        expect(editor.find('tbody td:eq(2)').text()).toEqual(choices[2]);
        expect(editor.find('tbody td:eq(3)').text()).toEqual(choices[3]);
        expect(editor.find('tbody td:eq(4)').text()).toEqual(choices[4]);
        done();
      }, 100);
    });

    it('should call source function with context set as cellProperties', function (done) {
      var source = jasmine.createSpy('source');
      var context;

      source.and.callFake(function (query, process) {
        process(choices);
        context = this;
      });
      var hot = handsontable({
        columns: [{
          editor: 'autocomplete',
          source: source
        }]
      });
      selectCell(0, 0);
      source.calls.reset();
      keyDownUp('enter');

      setTimeout(function () {
        expect(context.instance).toBe(hot);
        expect(context.row).toBe(0);
        expect(context.col).toBe(0);
        done();
      }, 200);
    });

    it('should display given choices (sync function)', function (done) {
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(choices);
      });
      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources
        }]
      });
      selectCell(0, 0);
      var editor = $('.autocompleteEditor');
      syncSources.calls.reset();
      keyDownUp('enter');

      setTimeout(function () {
        expect(editor.find('tbody td:eq(0)').text()).toEqual(choices[0]);
        expect(editor.find('tbody td:eq(1)').text()).toEqual(choices[1]);
        expect(editor.find('tbody td:eq(2)').text()).toEqual(choices[2]);
        expect(editor.find('tbody td:eq(3)').text()).toEqual(choices[3]);
        expect(editor.find('tbody td:eq(4)').text()).toEqual(choices[4]);
        done();
      }, 200);
    });

    it('should display given choices (async function)', function (done) {
      var asyncSources = jasmine.createSpy('asyncSources');

      asyncSources.and.callFake(function (process) {
        process(choices);
      });
      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: function source(query, process) {
            setTimeout(function () {
              asyncSources(process);
            }, 0);
          }
        }]
      });
      selectCell(0, 0);
      var editor = $('.autocompleteEditor');

      keyDownUp('enter');

      setTimeout(function () {
        expect(asyncSources.calls.count()).toEqual(1);
        expect(editor.find('tbody td:eq(0)').text()).toEqual(choices[0]);
        expect(editor.find('tbody td:eq(1)').text()).toEqual(choices[1]);
        expect(editor.find('tbody td:eq(2)').text()).toEqual(choices[2]);
        expect(editor.find('tbody td:eq(3)').text()).toEqual(choices[3]);
        expect(editor.find('tbody td:eq(4)').text()).toEqual(choices[4]);
        done();
      }, 200);
    });

    it('should NOT update choices list, after cursor leaves and enters the list (#1330)', function (done) {
      spyOn(Handsontable.editors.AutocompleteEditor.prototype, 'updateChoicesList').and.callThrough();
      var updateChoicesList = Handsontable.editors.AutocompleteEditor.prototype.updateChoicesList;

      var hot = handsontable({
        columns: [{
          editor: 'autocomplete',
          source: choices
        }]
      });
      selectCell(0, 0);
      var editor = hot.getActiveEditor();

      keyDownUp('enter');

      setTimeout(function () {
        updateChoicesList.calls.reset();
        $(editor.htContainer).find('.htCore tr:eq(0) td:eq(0)').mouseenter();
        $(editor.htContainer).find('.htCore tr:eq(0) td:eq(0)').mouseleave();
        $(editor.htContainer).find('.htCore tr:eq(0) td:eq(0)').mouseenter();
      }, 200);

      setTimeout(function () {
        expect(updateChoicesList).not.toHaveBeenCalled();
        done();
      }, 300);
    });

    it('should update choices list exactly once after a key is pressed (#1330)', function (done) {
      spyOn(Handsontable.editors.AutocompleteEditor.prototype, 'updateChoicesList').and.callThrough();
      var updateChoicesList = Handsontable.editors.AutocompleteEditor.prototype.updateChoicesList;

      var hot = handsontable({
        columns: [{
          editor: 'autocomplete',
          source: choices
        }]
      });
      selectCell(0, 0);
      var editor = hot.getActiveEditor();
      updateChoicesList.calls.reset();

      keyDownUp('enter');

      setTimeout(function () {
        updateChoicesList.calls.reset();
        editor.TEXTAREA.value = 'red';

        $(editor.TEXTAREA).simulate('keydown', {
          keyCode: 'd'.charCodeAt(0)
        });
      }, 200);

      setTimeout(function () {
        expect(updateChoicesList.calls.count()).toEqual(1);
        done();
      }, 100);
    });

    it('should not initialize the dropdown with unneeded scrollbars (scrollbar causing a scrollbar issue)', function (done) {
      spyOn(Handsontable.editors.AutocompleteEditor.prototype, 'updateChoicesList').and.callThrough();
      var updateChoicesList = Handsontable.editors.AutocompleteEditor.prototype.updateChoicesList;

      var hot = handsontable({
        data: [['blue'], [], [], []],
        columns: [{
          editor: 'autocomplete',
          source: choices
        }]
      });
      selectCell(0, 0);
      var editor = hot.getActiveEditor();
      updateChoicesList.calls.reset();

      keyDownUp('enter');

      setTimeout(function () {
        expect(editor.htContainer.scrollWidth).toEqual(editor.htContainer.clientWidth);
        done();
      }, 200);
    });

    it('autocomplete list should have textarea dimensions', function (done) {
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(choices);
      });

      handsontable({
        colWidths: [200],
        columns: [{
          editor: 'autocomplete',
          source: syncSources
        }]
      });
      selectCell(0, 0);
      var editor = $('.handsontableInputHolder');

      syncSources.calls.reset();
      keyDownUp('enter');

      setTimeout(function () {
        // -2 for transparent borders
        expect(editor.find('.autocompleteEditor .htCore td').width()).toEqual(editor.find('.handsontableInput').width() - 2);
        expect(editor.find('.autocompleteEditor .htCore td').width()).toBeGreaterThan(187);
        done();
      }, 200);
    });

    it('autocomplete list should have the suggestion table dimensions, when trimDropdown option is set to false', function (done) {
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(['long text', 'even longer text', 'extremely long text in the suggestion list', 'short text', 'text', 'another', 'yellow', 'black']);
      });

      var hot = handsontable({
        colWidths: [200],
        columns: [{
          editor: 'autocomplete',
          source: syncSources
        }],
        trimDropdown: false
      });

      selectCell(0, 0);
      var editor = $('.handsontableInputHolder');

      syncSources.calls.reset();
      keyDownUp('enter');

      setTimeout(function () {
        expect(editor.find('.autocompleteEditor .htCore td').eq(0).width()).toBeGreaterThan(editor.find('.handsontableInput').width());
        done();
      }, 200);
    });

    it('autocomplete textarea should have cell dimensions (after render)', function (done) {
      var data = [['a', 'b'], ['c', 'd']];

      hot = handsontable({
        data: data,
        minRows: 4,
        minCols: 4,
        minSpareRows: 4,
        minSpareCols: 4,
        cells: function cells() {
          return {
            type: Handsontable.AutocompleteCell
          };
        }
      });

      selectCell(1, 1);
      keyDownUp('enter');

      data[1][1] = 'dddddddddddddddddddd';
      render();

      setTimeout(function () {
        var $td = spec().$container.find('.htCore tbody tr:eq(1) td:eq(1)');

        expect(autocompleteEditor().width()).toEqual($td.width());
        done();
      }, 10);
    });

    it('should invoke beginEditing only once after dobleclicking on a cell (#1011)', function () {
      var hot = handsontable({
        columns: [{}, {}, {
          type: 'autocomplete',
          source: choices
        }]
      });
      selectCell(0, 2);
      spyOn(hot.getActiveEditor(), 'beginEditing');

      expect(hot.getActiveEditor().beginEditing.calls.count()).toBe(0);

      mouseDoubleClick(getCell(0, 2));

      expect(hot.getActiveEditor().beginEditing.calls.count()).toBe(1);

      mouseDoubleClick(getCell(1, 2));

      expect(hot.getActiveEditor().beginEditing.calls.count()).toBe(2);

      mouseDoubleClick(getCell(2, 2));

      expect(hot.getActiveEditor().beginEditing.calls.count()).toBe(3);
    });

    it('should not display all the choices from a long source list and not leave any unused space in the dropdown (YouTrack: #HOT-32)', function (done) {
      var hot = handsontable({
        columns: [{
          type: 'autocomplete',
          source: ['Acura', 'Audi', 'BMW', 'Buick', 'Cadillac', 'Chevrolet', 'Chrysler', 'Citroen', 'Dodge', 'Eagle', 'Ferrari', 'Ford', 'General Motors', 'GMC', 'Honda', 'Hummer', 'Hyundai', 'Infiniti', 'Isuzu', 'Jaguar', 'Jeep', 'Kia', 'Lamborghini', 'Land Rover', 'Lexus', 'Lincoln', 'Lotus', 'Mazda', 'Mercedes-Benz', 'Mercury', 'Mitsubishi', 'Nissan', 'Oldsmobile', 'Peugeot', 'Pontiac', 'Porsche', 'Regal', 'Renault', 'Saab', 'Saturn', 'Seat', 'Skoda', 'Subaru', 'Suzuki', 'Toyota', 'Volkswagen', 'Volvo']
        }]
      });

      selectCell(0, 0);
      keyDownUp('enter');
      var $autocomplete = autocomplete();
      var $autocompleteHolder = $autocomplete.find('.ht_master .wtHolder').first();

      setTimeout(function () {
        expect($autocomplete.find('td').first().text()).toEqual('Acura');
        $autocompleteHolder.scrollTop($autocompleteHolder[0].scrollHeight);
      }, 100);

      setTimeout(function () {
        expect($autocomplete.find('td').last().text()).toEqual('Volvo');
        done();
      }, 200);
    });

    it('should display the choices, regardless if they\'re declared as string or numeric', function (done) {
      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: ['1', '2', 3, '4', 5, 6]
        }]
      });

      selectCell(0, 0);

      var editor = $('.autocompleteEditor');

      keyDownUp('enter');

      setTimeout(function () {
        expect(editor.find('tbody td:eq(0)').text()).toEqual('1');
        expect(editor.find('tbody td:eq(1)').text()).toEqual('2');
        expect(editor.find('tbody td:eq(2)').text()).toEqual('3');
        expect(editor.find('tbody td:eq(3)').text()).toEqual('4');
        expect(editor.find('tbody td:eq(4)').text()).toEqual('5');
        expect(editor.find('tbody td:eq(5)').text()).toEqual('6');
        done();
      }, 100);
    });

    it('should display the choices, regardless if they\'re declared as string or numeric, when data is present', function (done) {
      handsontable({
        data: Handsontable.helper.createSpreadsheetData(10, 1),
        columns: [{
          editor: 'autocomplete',
          source: ['1', '2', 3, '4', 5, 6]
        }]
      });

      selectCell(0, 0);

      keyDownUp('backspace');

      var editor = $('.autocompleteEditor');

      keyDownUp('enter');

      setTimeout(function () {
        expect(editor.find('tbody td:eq(0)').text()).toEqual('1');
        expect(editor.find('tbody td:eq(1)').text()).toEqual('2');
        expect(editor.find('tbody td:eq(2)').text()).toEqual('3');
        expect(editor.find('tbody td:eq(3)').text()).toEqual('4');
        expect(editor.find('tbody td:eq(4)').text()).toEqual('5');
        expect(editor.find('tbody td:eq(5)').text()).toEqual('6');
        done();
      }, 100);
    });

    it('should display the dropdown above the editor, when there is not enough space below the cell AND there is more space above the cell', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(30, 30),
        columns: [{
          editor: 'autocomplete',
          source: choices
        }, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}],
        width: 400,
        height: 400
      });

      setDataAtCell(29, 0, '');
      selectCell(29, 0);

      mouseDoubleClick($(getCell(29, 0)));

      setTimeout(function () {
        var autocompleteEditor = $('.autocompleteEditor');

        expect(autocompleteEditor.css('position')).toEqual('absolute');
        expect(autocompleteEditor.css('top')).toEqual(-1 * autocompleteEditor.height() + 'px');
        done();
      }, 200);
    });

    it('should flip the dropdown upwards when there is no more room left below the cell after filtering the choice list', function (done) {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(30, 30),
        columns: [{
          editor: 'autocomplete',
          source: choices
        }, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}],
        width: 400,
        height: 400
      });

      setDataAtCell(26, 0, 'b');
      selectCell(26, 0);

      hot.view.wt.wtTable.holder.scrollTop = 999;

      mouseDoubleClick($(getCell(26, 0)));

      var autocompleteEditor = $('.autocompleteEditor');

      setTimeout(function () {
        expect(autocompleteEditor.css('position')).toEqual('relative');

        autocompleteEditor.siblings('textarea').first().val('');
        keyDownUp('backspace');
      }, 20);

      setTimeout(function () {
        expect(autocompleteEditor.css('position')).toEqual('absolute');
        expect(autocompleteEditor.css('top')).toEqual(-1 * autocompleteEditor.height() + 'px');
        done();
      }, 100);
    });
  });

  describe('closing editor', function () {
    it('should destroy editor when value change with mouse click on suggestion', function (done) {
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(choices);
      });

      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources
        }]
      });
      selectCell(0, 0);
      keyDownUp('enter');

      setTimeout(function () {
        autocomplete().find('tbody td:eq(3)').simulate('mousedown');

        expect(getDataAtCell(0, 0)).toEqual('green');
        done();
      }, 200);
    });

    it('should not change value type from `numeric` to `string` after mouse click suggestion - ' + 'test no. 1 #4143', function (done) {

      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: [1, 2, 3, 4, 5, 11, 14]
        }]
      });
      selectCell(0, 0);
      keyDownUp('enter');

      setTimeout(function () {
        autocomplete().find('tbody td:eq(0)').simulate('mousedown');

        expect(_typeof(getDataAtCell(0, 0))).toEqual('number');
        done();
      }, 200);
    });

    it('should not change value type from `numeric` to `string` after mouse click on suggestion - ' + 'test no. 2 #4143', function (done) {
      var syncSources = jasmine.createSpy('syncSources');
      var source = [1, 2, 3, 4, 5, 11, 14];

      syncSources.and.callFake(function (query, process) {
        process(source);
      });

      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources
        }]
      });
      selectCell(0, 0);
      keyDownUp('enter');

      setTimeout(function () {
        autocomplete().find('tbody td:eq(0)').simulate('mousedown');

        expect(_typeof(getDataAtCell(0, 0))).toEqual('number');
        done();
      }, 200);
    });

    it('should call `afterChange` hook with proper value types - test no. 1 #4143', function (done) {
      var changesInside = void 0;
      var sourceInside = void 0;

      var afterChange = function afterChange(changes, source) {
        if (source !== 'loadData') {
          changesInside = changes;
          sourceInside = source;
        }
      };

      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: [1, 2, 3, 4, 5, 11, 14]
        }],
        afterChange: afterChange
      });
      selectCell(0, 0);
      keyDownUp('enter');

      setTimeout(function () {
        autocomplete().find('tbody td:eq(1)').simulate('mousedown');

        expect(changesInside[0]).toEqual([0, 0, null, 2]);
        done();
      }, 200);
    });

    it('should call `afterChange` hook with proper value types - test no. 2 #4143', function (done) {
      var changesInside = void 0;
      var sourceInside = void 0;

      var afterChange = function afterChange(changes, source) {
        if (source !== 'loadData') {
          changesInside = changes;
          sourceInside = source;
        }
      };

      var syncSources = jasmine.createSpy('syncSources');
      var source = [1, 2, 3, 4, 5, 11, 14];

      syncSources.and.callFake(function (query, process) {
        process(source);
      });

      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources
        }],
        afterChange: afterChange
      });
      selectCell(0, 0);
      keyDownUp('enter');

      setTimeout(function () {
        autocomplete().find('tbody td:eq(1)').simulate('mousedown');

        expect(changesInside[0]).toEqual([0, 0, null, 2]);
        done();
      }, 200);
    });

    it('should not change value type from `numeric` to `string` when written down value from set of suggestions #4143', function (done) {
      var syncSources = jasmine.createSpy('syncSources');
      var source = [1, 2, 3, 4, 5, 11, 14];

      syncSources.and.callFake(function (query, process) {
        process(source);
      });

      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources
        }]
      });
      selectCell(0, 0);
      keyDownUp('enter');
      keyDownUp('backspace');
      document.activeElement.value = '1';
      $(document.activeElement).simulate('keyup');

      setTimeout(function () {
        keyDownUp('enter');
        expect(getDataAtCell(0, 0)).toEqual(1);

        done();
      }, 200);
    });

    it('should destroy editor when value change with Enter on suggestion', function (done) {
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(choices);
      });

      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources
        }]
      });

      selectCell(0, 0);
      keyDownUp('enter');

      setTimeout(function () {
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('arrow_down');
        keyDownUp('enter');

        expect(getDataAtCell(0, 0)).toEqual('green');
        done();
      }, 200);
    });

    it('should destroy editor when pressed Enter then Esc', function (done) {
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(choices);
      });

      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources
        }]
      });
      selectCell(0, 0);
      keyDownUp('enter');

      setTimeout(function () {
        expect(autocompleteEditor().is(':visible')).toBe(true);

        keyDownUp('esc');

        expect(autocompleteEditor().is(':visible')).toBe(false);
        done();
      }, 200);
    });

    it('should destroy editor when mouse double clicked then Esc', function (done) {
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(choices);
      });

      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources
        }]
      });
      selectCell(0, 0);
      mouseDoubleClick(getCell(0, 0));

      setTimeout(function () {
        expect(autocompleteEditor().is(':visible')).toBe(true);

        keyDownUp('esc');

        expect(autocompleteEditor().is(':visible')).toBe(false);
        done();
      }, 200);
    });

    it('cancel editing (Esc) should restore the previous value', function (done) {
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(choices);
      });

      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources
        }]
      });

      setDataAtCell(0, 0, 'black');
      selectCell(0, 0);
      keyDownUp('enter');

      setTimeout(function () {
        autocomplete().siblings('.handsontableInput').val('ye');
        keyDownUp(69); // e
        keyDownUp('esc');

        expect(getDataAtCell(0, 0)).toEqual('black');
        done();
      }, 200);
    });

    it('should destroy editor when clicked outside the table', function (done) {
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(choices);
      });
      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources
        }]
      });
      selectCell(0, 0);
      mouseDoubleClick(getCell(0, 0));

      setTimeout(function () {
        expect(autocompleteEditor().is(':visible')).toBe(true);

        $('body').simulate('mousedown');

        expect(autocompleteEditor().is(':visible')).toBe(false);
        done();
      }, 200);
    });

    it('should show fillHandle element again after close editor', function (done) {
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.plan = function (query, process) {
        process(choices.filter(function (choice) {
          return choice.indexOf(query) != -1;
        }));
      };

      var hot = handsontable({
        columns: [{
          type: 'autocomplete',
          source: syncSources,
          strict: false
        }, {}]
      });

      selectCell(1, 0);
      keyDownUp('x'); // Trigger quick edit mode
      keyDownUp('enter');

      setTimeout(function () {
        expect($('#testContainer.handsontable > .handsontable .wtBorder.current.corner:visible').length).toEqual(1);
        done();
      }, 200);
    });
  });

  describe('non strict mode', function () {
    it('should allow any value in non strict mode (close editor with ENTER)', function (done) {
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(choices);
      });

      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources
        }]
      });
      selectCell(0, 0);
      keyDownUp('enter');

      setTimeout(function () {
        var editor = $('.handsontableInput');
        editor.val('foo');
        keyDownUp('enter');

        expect(getDataAtCell(0, 0)).toEqual('foo');
        done();
      }, 200);
    });

    it('should allow any value in non strict mode (close editor by clicking on table)', function (done) {
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(choices);
      });

      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources
        }]
      });
      selectCell(0, 0);
      keyDownUp('enter');

      setTimeout(function () {
        var editor = $('.handsontableInput');
        editor.val('foo');
        spec().$container.find('tbody tr:eq(1) td:eq(0)').simulate('mousedown');

        expect(getDataAtCell(0, 0)).toEqual('foo');
        done();
      }, 200);
    });

    it('should save the value from textarea after hitting ENTER', function (done) {
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(choices.filter(function (choice) {
          return choice.indexOf(query) != -1;
        }));
      });

      hot = handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources
        }]
      });
      selectCell(0, 0);
      var editorInput = $('.handsontableInput');

      expect(getDataAtCell(0, 0)).toBeNull();

      keyDownUp('enter');

      setTimeout(function () {
        syncSources.calls.reset();

        editorInput.val('b');
        keyDownUp('b'.charCodeAt(0));
      }, 200);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual([['blue'], ['black']]);

        var selected = innerHot.getSelected();

        expect(selected).toBeUndefined();

        keyDownUp('enter');

        expect(getDataAtCell(0, 0)).toEqual('b');
        done();
      }, 400);
    });
  });

  describe('strict mode', function () {
    it('strict mode should NOT use value if it DOES NOT match the list (sync reponse is empty)', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');
      var onAfterChange = jasmine.createSpy('onAfterChange');
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process([]); // hardcoded empty result
      });

      handsontable({
        data: [['one', 'two'], ['three', 'four']],
        columns: [{
          type: 'autocomplete',
          source: syncSources,
          allowInvalid: false,
          strict: true
        }, {}],
        afterValidate: onAfterValidate,
        afterChange: onAfterChange
      });

      setDataAtCell(0, 0, 'unexistent');

      setTimeout(function () {
        expect(getData()).toEqual([['one', 'two'], ['three', 'four']]);

        expect(syncSources.calls.count()).toEqual(1);
        expect(onAfterValidate.calls.count()).toEqual(1);
        expect(onAfterChange.calls.count()).toEqual(1); // 1 for loadData (it is not called after failed edit)
        done();
      }, 200);
    });

    it('strict mode should use value if it DOES match the list (sync reponse is not empty)', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');
      var onAfterChange = jasmine.createSpy('onAfterChange');
      var syncSources = jasmine.createSpy('asyncSources');

      syncSources.and.callFake(function (query, process) {
        process(choices); // hardcoded empty result
      });

      handsontable({
        data: [['one', 'two'], ['three', 'four']],
        columns: [{
          type: 'autocomplete',
          source: syncSources,
          allowInvalid: false,
          strict: true
        }, {}],
        afterValidate: onAfterValidate,
        afterChange: onAfterChange
      });

      setDataAtCell(0, 0, 'yellow');

      setTimeout(function () {
        expect(getData()).toEqual([['yellow', 'two'], ['three', 'four']]);

        expect(syncSources.calls.count()).toEqual(1);
        expect(onAfterValidate.calls.count()).toEqual(1);
        expect(onAfterChange.calls.count()).toEqual(2); // 1 for loadData and 1 for setDataAtCell
        done();
      }, 200);
    });

    it('strict mode should NOT use value if it DOES NOT match the list (async reponse is empty)', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');
      var onAfterChange = jasmine.createSpy('onAfterChange');
      var asyncSources = jasmine.createSpy('asyncSources');

      asyncSources.and.callFake(function (query, process) {
        setTimeout(function () {
          process([]); // hardcoded empty result
        });
      });

      handsontable({
        data: [['one', 'two'], ['three', 'four']],
        columns: [{
          type: 'autocomplete',
          source: asyncSources,
          allowInvalid: false,
          strict: true
        }, {}],
        afterValidate: onAfterValidate,
        afterChange: onAfterChange
      });

      setDataAtCell(0, 0, 'unexistent');

      setTimeout(function () {
        expect(getData()).toEqual([['one', 'two'], ['three', 'four']]);

        expect(asyncSources.calls.count()).toEqual(1);
        expect(onAfterValidate.calls.count()).toEqual(1);
        expect(onAfterChange.calls.count()).toEqual(1); // 1 for loadData (it is not called after failed edit)
        done();
      }, 200);
    });

    it('strict mode should use value if it DOES match the list (async reponse is not empty)', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');
      var onAfterChange = jasmine.createSpy('onAfterChange');
      var asyncSources = jasmine.createSpy('asyncSources');

      asyncSources.and.callFake(function (query, process) {
        setTimeout(function () {
          process(choices); // hardcoded empty result
        });
      });

      handsontable({
        data: [['one', 'two'], ['three', 'four']],
        columns: [{
          type: 'autocomplete',
          source: asyncSources,
          allowInvalid: false,
          strict: true
        }, {}],
        afterValidate: onAfterValidate,
        afterChange: onAfterChange
      });

      setDataAtCell(0, 0, 'yellow');

      setTimeout(function () {
        expect(getData()).toEqual([['yellow', 'two'], ['three', 'four']]);

        expect(asyncSources.calls.count()).toEqual(1);
        expect(onAfterValidate.calls.count()).toEqual(1);
        expect(onAfterChange.calls.count()).toEqual(2); // 1 for loadData and 1 for setDataAtCell
        done();
      }, 200);
    });

    it('strict mode mark value as invalid if it DOES NOT match the list (sync reponse is empty)', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');
      var onAfterChange = jasmine.createSpy('onAfterChange');
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process([]); // hardcoded empty result
      });

      handsontable({
        data: [['one', 'two'], ['three', 'four']],
        columns: [{
          type: 'autocomplete',
          source: syncSources,
          allowInvalid: true,
          strict: true
        }, {}],
        afterValidate: onAfterValidate,
        afterChange: onAfterChange
      });

      expect(getCellMeta(0, 0).valid).not.toBe(false);
      expect($(getCell(0, 0)).hasClass('htInvalid')).toBe(false);

      setDataAtCell(0, 0, 'unexistent');

      setTimeout(function () {
        expect(getData()).toEqual([['unexistent', 'two'], ['three', 'four']]);

        expect(getCellMeta(0, 0).valid).toBe(false);
        expect($(getCell(0, 0)).hasClass('htInvalid')).toBe(true);
        done();
      }, 200);
    });

    it('should select the best matching option after hitting ENTER', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(choices.filter(function (choice) {
          return choice.indexOf(query) != -1;
        }));
      });

      hot = handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources,
          strict: true
        }],
        afterValidate: onAfterValidate
      });

      selectCell(0, 0);
      var editorInput = $('.handsontableInput');

      expect(getDataAtCell(0, 0)).toBeNull();

      keyDownUp('enter');

      setTimeout(function () {
        syncSources.calls.reset();

        editorInput.val('b');
        keyDownUp('b'.charCodeAt(0));
      }, 200);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual([['blue'], ['black']]);

        var selected = innerHot.getSelected();
        var selectedData = innerHot.getDataAtCell(selected[0], selected[1]);

        expect(selectedData).toEqual('blue');

        onAfterValidate.calls.reset();

        keyDownUp('enter');
      }, 400);

      setTimeout(function () {
        expect(getDataAtCell(0, 0)).toEqual('blue');
        done();
      }, 600);
    });

    it('should select the best matching option after hitting TAB', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(choices.filter(function (choice) {
          return choice.indexOf(query) != -1;
        }));
      });

      hot = handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources,
          strict: true
        }],
        afterValidate: onAfterValidate
      });

      selectCell(0, 0);
      var editorInput = $('.handsontableInput');

      expect(getDataAtCell(0, 0)).toBeNull();

      keyDownUp('enter');

      setTimeout(function () {
        syncSources.calls.reset();

        editorInput.val('b');
        keyDownUp('b'.charCodeAt(0));
      }, 200);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual([['blue'], ['black']]);

        var selected = innerHot.getSelected();
        var selectedData = innerHot.getDataAtCell(selected[0], selected[1]);

        expect(selectedData).toEqual('blue');

        onAfterValidate.calls.reset();

        keyDownUp('tab');
      }, 400);

      setTimeout(function () {
        expect(getDataAtCell(0, 0)).toEqual('blue');
        done();
      }, 600);
    });

    it('should mark list item corresponding to current cell value as selected', function (done) {
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(['red', 'dark-yellow', 'yellow', 'light-yellow', 'black']);
      });

      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources,
          strict: true
        }],
        data: [['yellow'], ['red'], ['blue']]
      });

      selectCell(0, 0);

      keyDownUp('enter');

      setTimeout(function () {
        expect(autocomplete().find('.current').text()).toEqual(getDataAtCell(0, 0));
        done();
      }, 200);
    });
  });

  describe('filtering', function () {
    it('typing in textarea should filter the lookup list', function (done) {
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(choices.filter(function (choice) {
          return choice.indexOf(query) != -1;
        }));
      });

      hot = handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources
        }]
      });

      selectCell(0, 0);
      var editorInput = $('.handsontableInput');

      expect(getDataAtCell(0, 0)).toBeNull();

      keyDownUp('enter');

      setTimeout(function () {
        syncSources.calls.reset();
        editorInput.val('e');
        keyDownUp(69); // e
      }, 200);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual([['red'], ['yellow'], ['green'], ['blue'], ['lime'], ['white'], ['olive'], ['orange'], ['purple']]);

        syncSources.calls.reset();
        editorInput.val('ed');
        keyDownUp(68); // d
      }, 400);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual([['red']]);
        done();
      }, 600);
    });
    it('default filtering should be case insensitive', function (done) {
      hot = handsontable({
        columns: [{
          editor: 'autocomplete',
          source: choices
        }]
      });

      selectCell(0, 0);
      var editorInput = $('.handsontableInput');

      expect(getDataAtCell(0, 0)).toBeNull();

      keyDownUp('enter');

      editorInput.val('e');
      keyDownUp(69); // e

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual([['red'], ['yellow'], ['green'], ['blue'], ['lime'], ['white'], ['olive'], ['orange'], ['purple']]);

        editorInput.val('e');
        keyDownUp(69); // E (same as 'e')
      }, 50);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual([['red'], ['yellow'], ['green'], ['blue'], ['lime'], ['white'], ['olive'], ['orange'], ['purple']]);
        done();
      }, 100);
    });

    it('default filtering should be case sensitive when filteringCaseSensitive is false', function (done) {
      hot = handsontable({
        columns: [{
          editor: 'autocomplete',
          source: choices,
          filteringCaseSensitive: true
        }]
      });

      selectCell(0, 0);
      var editorInput = $('.handsontableInput');

      expect(getDataAtCell(0, 0)).toBeNull();

      keyDownUp('enter');

      editorInput.val('e');
      keyDownUp(69); // e

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual([['red'], ['yellow'], ['green'], ['blue'], ['lime'], ['white'], ['olive'], ['orange'], ['purple']]);

        editorInput.val('E');
        keyDownUp(69); // E (same as 'e')
      }, 50);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual([]);
        expect(innerHot.getSourceData()).toEqual([]);
        done();
      }, 200);
    });

    it('typing in textarea should NOT filter the lookup list when filtering is disabled', function (done) {
      hot = handsontable({
        columns: [{
          editor: 'autocomplete',
          source: choices,
          filter: false
        }]
      });
      selectCell(0, 0);
      var editorInput = $('.handsontableInput');

      expect(getDataAtCell(0, 0)).toBeNull();

      keyDownUp('enter');

      setTimeout(function () {
        editorInput.val('e');
        keyDownUp('e'.charCodeAt(0)); // e
      }, 20);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual(Handsontable.helper.pivot([choices]));

        editorInput.val('ed');
        keyDownUp('d'.charCodeAt(0)); // d
      }, 40);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual(Handsontable.helper.pivot([choices]));
        done();
      }, 60);
    });

    it('typing in textarea should highlight the matching phrase', function (done) {
      var choices = ['Male', 'Female'];
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(choices.filter(function (choice) {
          return choice.search(new RegExp(query, 'i')) != -1;
        }));
      });

      hot = handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources,
          filter: false
        }]
      });

      selectCell(0, 0);
      var editorInput = $('.handsontableInput');

      expect(getDataAtCell(0, 0)).toBeNull();

      keyDownUp('enter');

      setTimeout(function () {
        syncSources.calls.reset();

        editorInput.val('Male');
        keyDownUp(69); // e
      }, 200);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;
        var autocompleteList = $(innerHot.rootElement);

        expect(autocompleteList.find('td:eq(0)').html()).toMatch(/<(strong|STRONG)>Male<\/(strong|STRONG)>/); // IE8 makes the tag names UPPERCASE
        expect(autocompleteList.find('td:eq(1)').html()).toMatch(/Fe<(strong|STRONG)>male<\/(strong|STRONG)>/);
        done();
      }, 400);
    });

    it('text in textarea should not be interpreted as regexp', function (done) {
      spyOn(Handsontable.editors.AutocompleteEditor.prototype, 'queryChoices').and.callThrough();
      var queryChoices = Handsontable.editors.AutocompleteEditor.prototype.queryChoices;

      hot = handsontable({
        columns: [{
          editor: 'autocomplete',
          source: choices
        }]
      });

      selectCell(0, 0);
      var editorInput = $('.handsontableInput');

      expect(getDataAtCell(0, 0)).toBeNull();

      keyDownUp('enter');

      setTimeout(function () {
        queryChoices.calls.reset();
        editorInput.val('yellow|red');
        keyDownUp('d'.charCodeAt(0));
      }, 200);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData().length).toEqual(0);
        done();
      }, 400);
    });

    it('text in textarea should not be interpreted as regexp when highlighting the matching phrase', function (done) {
      var choices = ['Male', 'Female'];
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(choices.filter(function (choice) {
          return choice.search(new RegExp(query, 'i')) != -1;
        }));
      });

      hot = handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources,
          filter: false
        }]
      });
      selectCell(0, 0);
      var editorInput = $('.handsontableInput');

      expect(getDataAtCell(0, 0)).toBeNull();

      keyDownUp('enter');

      setTimeout(function () {
        syncSources.calls.reset();
        editorInput.val('M|F');
        keyDownUp('F'.charCodeAt(0));
      }, 200);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        var autocompleteList = $(innerHot.rootElement);

        expect(autocompleteList.find('td:eq(0)').html()).toEqual('Male');
        expect(autocompleteList.find('td:eq(1)').html()).toEqual('Female');
        done();
      }, 400);
    });

    it('should allow any value if filter === false and allowInvalid === true', function (done) {
      spyOn(Handsontable.editors.AutocompleteEditor.prototype, 'queryChoices').and.callThrough();
      var queryChoices = Handsontable.editors.AutocompleteEditor.prototype.queryChoices;

      handsontable({
        columns: [{
          editor: 'autocomplete',
          source: choices,
          filter: false,
          strict: true,
          allowInvalid: true
        }]
      });

      selectCell(0, 0);
      var editorInput = $('.handsontableInput');

      expect(getDataAtCell(0, 0)).toBeNull();

      keyDownUp('enter');

      setTimeout(function () {
        queryChoices.calls.reset();
        editorInput.val('foobar');
        keyDownUp(82); // r
      }, 200);

      setTimeout(function () {
        keyDownUp(Handsontable.helper.KEY_CODES.ENTER);

        expect(getDataAtCell(0, 0)).toEqual('foobar');
        done();
      }, 400);
    });

    it('typing in textarea should highlight best choice, if strict === true', function (done) {
      var choices = ['Male', 'Female'];
      var syncSources = jasmine.createSpy('syncSources');

      syncSources.and.callFake(function (query, process) {
        process(choices.filter(function (choice) {
          return choice.search(new RegExp(query, 'i')) != -1;
        }));
      });

      var hot = handsontable({
        columns: [{
          editor: 'autocomplete',
          source: syncSources,
          filter: false,
          strict: true
        }]
      });

      selectCell(0, 0);
      var editorInput = $('.handsontableInput');

      expect(getDataAtCell(0, 0)).toBeNull();

      keyDownUp('enter');

      setTimeout(function () {
        syncSources.calls.reset();
        editorInput.val('e');
        keyDownUp(69); // e
      }, 200);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getSelected()).toEqual([1, 0, 1, 0]);
        done();
      }, 400);
    });
  });

  it('should restore the old value when hovered over a autocomplete menu item and then clicked outside of the table', function (done) {
    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process(choices);
    });

    handsontable({
      columns: [{
        editor: 'autocomplete',
        source: syncSources
      }]
    });

    selectCell(0, 0);

    expect(getDataAtCell(0, 0)).toBeNull();

    keyDownUp('enter');

    setTimeout(function () {
      autocomplete().find('tbody td:eq(1)').simulate('mouseenter');
      autocomplete().find('tbody td:eq(1)').simulate('mouseleave');

      spec().$container.simulate('mousedown');

      expect(getDataAtCell(0, 0)).toBeNull();
      done();
    }, 200);
  });

  it('should be able to use empty value ("")', function (done) {
    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process(['', 'BMW', 'Bentley']);
    });

    handsontable({
      data: [['one', 'two'], ['three', 'four']],
      columns: [{
        editor: 'autocomplete',
        source: syncSources,
        filter: false
      }]
    });

    selectCell(0, 0);
    keyDownUp('enter');

    setTimeout(function () {
      expect(getDataAtCell(0, 0)).toEqual('one');

      autocomplete().find('tbody td:eq(0)').simulate('mousedown');

      expect(getDataAtCell(0, 0)).toEqual('');
      done();
    }, 200);
  });

  describe('allow html mode', function () {
    it('should allow inject html items (async mode)', function (done) {
      hot = handsontable({
        columns: [{
          type: 'autocomplete',
          source: function source(query, cb) {
            cb(['<b>foo <span>zip</span></b>', '<i>bar</i>', '<strong>baz</strong>']);
          },

          allowHtml: true
        }]
      });

      selectCell(0, 0);
      var editorInput = $('.handsontableInput');

      expect(getDataAtCell(0, 0)).toBeNull();

      keyDownUp('enter');

      setTimeout(function () {
        editorInput.val('b');
        keyDownUp('b'.charCodeAt(0));
      }, 200);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual([['<i>bar</i>'], ['<strong>baz</strong>']]);

        editorInput.val('bar');
        keyDownUp('a'.charCodeAt(0));
        keyDownUp('r'.charCodeAt(0));
      }, 400);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual([['<i>bar</i>']]);

        keyDownUp('arrow_down');
        keyDownUp('enter');
      }, 600);

      setTimeout(function () {
        expect(getCell(0, 0).querySelector('i').textContent).toBe('bar');
        done();
      }, 700);
    });

    it('should allow inject html items (sync mode)', function (done) {
      hot = handsontable({
        columns: [{
          type: 'autocomplete',
          source: ['<b>foo <span>zip</span></b>', '<i>bar</i>', '<strong>baz</strong>'],
          allowHtml: true
        }]
      });

      selectCell(0, 0);
      var editorInput = $('.handsontableInput');

      expect(getDataAtCell(0, 0)).toBeNull();

      keyDownUp('enter');

      setTimeout(function () {
        editorInput.val('b');
        keyDownUp('b'.charCodeAt(0));
      }, 200);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual([['<i>bar</i>'], ['<strong>baz</strong>']]);

        editorInput.val('bar');
        keyDownUp('a'.charCodeAt(0));
        keyDownUp('r'.charCodeAt(0));
      }, 400);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual([['<i>bar</i>']]);

        keyDownUp('arrow_down');
        keyDownUp('enter');
      }, 600);

      setTimeout(function () {
        expect(getCell(0, 0).querySelector('i').textContent).toBe('bar');
        done();
      }, 700);
    });
  });

  describe('disallow html mode', function () {
    it('should be disabled by default', function () {
      hot = handsontable({
        columns: [{
          type: 'autocomplete',
          source: function source(query, cb) {
            cb(['<b>foo <span>zip</span></b>', '<i>bar</i>', '<strong>baz</strong>']);
          },

          allowHtml: false
        }]
      });

      expect(hot.getCellMeta(0, 0).allowHtml).toBeFalsy();
    });

    it('should strip html from strings provided in source (async mode)', function (done) {
      hot = handsontable({
        columns: [{
          type: 'autocomplete',
          source: function source(query, cb) {
            cb(['<b>foo <span>zip</span></b>', '<i>bar</i>', '<strong>baz</strong>']);
          },

          allowHtml: false
        }]
      });

      selectCell(0, 0);
      var editorInput = $('.handsontableInput');

      expect(getDataAtCell(0, 0)).toBeNull();

      keyDownUp('enter');

      setTimeout(function () {
        editorInput.val('b');
        keyDownUp('b'.charCodeAt(0));
      }, 200);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual([['bar'], ['baz']]);

        editorInput.val('bar');
        keyDownUp('a'.charCodeAt(0));
        keyDownUp('r'.charCodeAt(0));
      }, 400);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual([['bar']]);

        keyDownUp('arrow_down');
        keyDownUp('enter');
      }, 600);

      setTimeout(function () {
        expect(getCell(0, 0).querySelector('i')).toBeNull();
        expect(getCell(0, 0).textContent).toMatch('bar');
        done();
      }, 700);
    });

    it('should strip html from strings provided in source (sync mode)', function (done) {
      hot = handsontable({
        columns: [{
          type: 'autocomplete',
          source: ['<b>foo <span>zip</span></b>', '<i>bar</i>', '<strong>baz</strong>'],
          allowHtml: false
        }]
      });

      selectCell(0, 0);
      var editorInput = $('.handsontableInput');

      expect(getDataAtCell(0, 0)).toBeNull();

      keyDownUp('enter');

      setTimeout(function () {
        editorInput.val('b');
        keyDownUp('b'.charCodeAt(0));
      }, 200);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual([['bar'], ['baz']]);

        editorInput.val('bar');
        keyDownUp('a'.charCodeAt(0));
        keyDownUp('r'.charCodeAt(0));
      }, 400);

      setTimeout(function () {
        var ac = hot.getActiveEditor();
        var innerHot = ac.htEditor;

        expect(innerHot.getData()).toEqual([['bar']]);

        keyDownUp('arrow_down');
        keyDownUp('enter');
      }, 600);

      setTimeout(function () {
        expect(getCell(0, 0).querySelector('i')).toBeNull();
        expect(getCell(0, 0).textContent).toMatch('bar');
        done();
      }, 700);
    });
  });

  describe('Autocomplete helper functions:', function () {
    describe('sortByRelevance', function () {
      it('should sort the provided array, so items more relevant to the provided value are listed first', function () {
        var choices = ['Wayne', // 0
        'Draven', // 1
        'Banner', // 2
        'Stark', // 3
        'Parker', // 4
        'Kent', // 5
        'Gordon', // 6
        'Kyle', // 7
        'Simmons' // 8
        ];
        var value = 'a';

        var sorted = Handsontable.editors.AutocompleteEditor.sortByRelevance(value, choices);

        expect(sorted).toEqual([0, 2, 4, 3, 1]);

        value = 'o';
        sorted = Handsontable.editors.AutocompleteEditor.sortByRelevance(value, choices);

        expect(sorted).toEqual([6, 8]);

        value = 'er';
        sorted = Handsontable.editors.AutocompleteEditor.sortByRelevance(value, choices);

        expect(sorted).toEqual([2, 4]);
      });
    });
  });

  it('should not modify the suggestion lists\' order, when the sortByRelevance option is set to false', function (done) {
    var choices = ['Wayne', 'Draven', 'Banner', 'Stark', 'Parker', 'Kent', 'Gordon', 'Kyle', 'Simmons'];
    var hot = handsontable({
      columns: [{
        editor: 'autocomplete',
        source: choices,
        sortByRelevance: false
      }]
    });

    selectCell(0, 0);
    keyDownUp('enter');
    var $editorInput = $('.handsontableInput');
    $editorInput.val('a');
    keyDownUp('a'.charCodeAt(0));
    Handsontable.dom.setCaretPosition($editorInput[0], 1);

    setTimeout(function () {
      var dropdownList = $('.autocompleteEditor tbody').first();
      var listLength = dropdownList.find('tr').size();

      expect(listLength).toBe(9);

      for (var i = 1; i <= listLength; i++) {
        expect(dropdownList.find('tr:nth-child(' + i + ') td').text()).toEqual(choices[i - 1]);
      }
      done();
    }, 30);
  });

  it('should fire one afterChange event when value is changed', function (done) {
    var onAfterChange = jasmine.createSpy('onAfterChange');
    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process(choices);
    });

    handsontable({
      columns: [{
        editor: 'autocomplete',
        source: syncSources
      }],
      afterChange: onAfterChange
    });

    selectCell(0, 0);

    keyDownUp('enter');

    setTimeout(function () {
      onAfterChange.calls.reset();
      autocomplete().find('tbody td:eq(1)').simulate('mousedown');

      expect(getDataAtCell(0, 0)).toEqual('red');
      expect(onAfterChange.calls.count()).toEqual(1);
      expect(onAfterChange).toHaveBeenCalledWith([[0, 0, null, 'red']], 'edit', undefined, undefined, undefined, undefined);
      done();
    }, 200);
  });

  it('should not affect other cell values after clicking on autocomplete cell (#1021)', function (done) {
    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process(choices);
    });

    handsontable({
      columns: [{}, {}, {
        editor: 'autocomplete',
        source: syncSources
      }, {}],
      data: [[null, null, 'yellow', null], [null, null, 'red', null], [null, null, 'blue', null]]
    });

    expect($(getCell(0, 2)).text()).toMatch('yellow');

    mouseDoubleClick(getCell(0, 2));

    expect($(getCell(1, 2)).text()).toMatch('red');

    mouseDoubleClick(getCell(1, 2));

    expect($(getCell(2, 2)).text()).toMatch('blue');

    mouseDoubleClick(getCell(2, 2));

    setTimeout(function () {
      expect(getDataAtCol(2)).toEqual(['yellow', 'red', 'blue']);
      done();
    }, 200);
  });

  it('should handle editor if cell data is a function', function (done) {
    spyOn(Handsontable.editors.AutocompleteEditor.prototype, 'updateChoicesList').and.callThrough();
    var updateChoicesList = Handsontable.editors.AutocompleteEditor.prototype.updateChoicesList;
    var afterValidateCallback = jasmine.createSpy('afterValidateCallbak');

    var hot = handsontable({
      data: [new Model({
        id: 1,
        name: 'Ted Right',
        address: ''
      }), new Model({
        id: 2,
        name: 'Frank Honest',
        address: ''
      }), new Model({
        id: 3,
        name: 'Joan Well',
        address: ''
      })],
      dataSchema: Model,
      colHeaders: ['ID', 'Name', 'Address'],
      columns: [{
        data: createAccessorForProperty('id'),
        type: 'autocomplete',
        source: ['1', '2', '3'],
        filter: false,
        strict: true
      }, {
        data: createAccessorForProperty('name')
      }, {
        data: createAccessorForProperty('address')
      }],
      minSpareRows: 1,
      afterValidate: afterValidateCallback
    });
    selectCell(0, 0);
    expect(hot.getActiveEditor().isOpened()).toBe(false);

    keyDownUp('enter');

    setTimeout(function () {
      expect(hot.getActiveEditor().isOpened()).toBe(true);
      afterValidateCallback.calls.reset();
      $(hot.getActiveEditor().htContainer).find('tr:eq(1) td:eq(0)').simulate('mousedown');
    }, 200);

    setTimeout(function () {
      expect(getDataAtCell(0, 0)).toEqual('2');
      done();
    }, 400);
  });

  it('should not call the `source` has been selected', function () {
    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process([]); // hardcoded empty result
    });

    handsontable({
      data: [['one', 'two'], ['three', 'four']],
      columns: [{
        type: 'autocomplete',
        source: syncSources,
        allowInvalid: false,
        strict: true
      }, {}],
      cells: function cells(row, col) {
        var cellProperties = {};

        if (row === 0 && col === 0) {
          cellProperties.readOnly = true;
        }

        return cellProperties;
      }
    });

    expect(getCellMeta(0, 0).readOnly).toBe(true);
    expect(syncSources).not.toHaveBeenCalled();

    selectCell(0, 0);

    expect(syncSources).not.toHaveBeenCalled();

    expect(getCellMeta(1, 0).readOnly).toBeFalsy();

    selectCell(1, 0);

    expect(syncSources).not.toHaveBeenCalled();
  });

  it('should not call the `source` method if cell is read only and the arrow has been clicked', function (done) {
    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process([]); // hardcoded empty result
    });

    handsontable({
      data: [['one', 'two'], ['three', 'four']],
      columns: [{
        type: 'autocomplete',
        source: syncSources,
        allowInvalid: false,
        strict: true
      }, {}],
      cells: function cells(row, col) {
        var cellProperties = {};

        if (row === 0 && col === 0) {
          cellProperties.readOnly = true;
        }

        return cellProperties;
      }
    });

    expect(getCellMeta(0, 0).readOnly).toBe(true);
    expect(syncSources).not.toHaveBeenCalled();

    selectCell(0, 0);
    $(getCell(0, 0)).find('.htAutocompleteArrow').simulate('mousedown');

    setTimeout(function () {
      expect(syncSources).not.toHaveBeenCalled();

      syncSources.calls.reset();
      expect(getCellMeta(1, 0).readOnly).toBeFalsy();

      selectCell(1, 0);
      $(getCell(1, 0)).find('.htAutocompleteArrow').simulate('mousedown');
    }, 100);

    setTimeout(function () {
      expect(syncSources).toHaveBeenCalled();
      expect(syncSources.calls.count()).toEqual(1);
      done();
    }, 200);
  });

  it('should add a scrollbar to the autocomplete dropdown, only if number of displayed choices exceeds 10', function (done) {
    var hot = handsontable({
      data: [['', 'two', 'three'], ['four', 'five', 'six']],
      columns: [{
        type: 'autocomplete',
        source: choices,
        allowInvalid: false,
        strict: false
      }, {}, {}]
    });

    this.$container.css({
      height: 600
    });

    expect(choices.length).toBeGreaterThan(10);

    selectCell(0, 0);
    $(getCell(0, 0)).find('.htAutocompleteArrow').simulate('mousedown');

    var dropdown = hot.getActiveEditor().htContainer;
    var dropdownHolder = hot.getActiveEditor().htEditor.view.wt.wtTable.holder;

    setTimeout(function () {
      expect(dropdownHolder.scrollHeight).toBeGreaterThan(dropdownHolder.clientHeight);

      keyDownUp('esc');

      hot.getSettings().columns[0].source = hot.getSettings().columns[0].source.slice(0).splice(3);
      hot.updateSettings({});

      selectCell(0, 0);
      $(getCell(0, 0)).find('.htAutocompleteArrow').simulate('mousedown');
    }, 30);

    setTimeout(function () {
      expect(dropdownHolder.scrollHeight > dropdownHolder.clientHeight).toBe(false);
      done();
    }, 60);
  });

  it('should not close editor on scrolling', function (done) {
    var hot = handsontable({
      data: [['', 'two', 'three'], ['four', 'five', 'six']],
      columns: [{
        type: 'autocomplete',
        source: choices,
        allowInvalid: false,
        strict: false
      }, {}, {}]
    });

    expect(choices.length).toBeGreaterThan(10);

    selectCell(0, 0);
    $(getCell(0, 0)).find('.htAutocompleteArrow').simulate('mousedown');
    $(getCell(0, 0)).find('.htAutocompleteArrow').simulate('mouseup');

    var dropdown = hot.getActiveEditor().htContainer;

    hot.view.wt.wtOverlays.topOverlay.scrollTo(1);

    setTimeout(function () {
      expect($(dropdown).is(':visible')).toBe(true);
      selectCell(0, 0);
    }, 30);

    setTimeout(function () {
      $(getCell(0, 0)).find('.htAutocompleteArrow').simulate('mousedown');
      $(getCell(0, 0)).find('.htAutocompleteArrow').simulate('mouseup');
      hot.view.wt.wtOverlays.topOverlay.scrollTo(3);
    }, 80);

    setTimeout(function () {
      expect($(dropdown).is(':visible')).toBe(true);
      done();
    }, 120);
  });

  it('should keep textarea caret position, after moving the selection to the suggestion list (pressing down arrow)', function (done) {
    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process(choices.filter(function (choice) {
        return choice.indexOf(query) != -1;
      }));
    });

    handsontable({
      columns: [{
        type: 'autocomplete',
        source: syncSources,
        strict: false
      }]
    });

    selectCell(0, 0);
    keyDownUp('enter');
    var $editorInput = $('.handsontableInput');
    $editorInput.val('an');
    keyDownUp(65); // a
    keyDownUp(78); // n
    Handsontable.dom.setCaretPosition($editorInput[0], 1);

    setTimeout(function () {
      keyDownUp('arrow_down');
      expect(Handsontable.dom.getCaretPosition($editorInput[0])).toEqual(1);
      keyDownUp('arrow_down');
      expect(Handsontable.dom.getCaretPosition($editorInput[0])).toEqual(1);
      done();
    }, 200);
  });

  it('should keep textarea selection, after moving the selection to the suggestion list (pressing down arrow)', function (done) {
    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process(choices.filter(function (choice) {
        return choice.indexOf(query) != -1;
      }));
    });

    handsontable({
      columns: [{
        type: 'autocomplete',
        source: syncSources,
        strict: false
      }]
    });

    selectCell(0, 0);
    keyDownUp('enter');
    var $editorInput = $('.handsontableInput');
    $editorInput.val('an');
    keyDownUp(65); // a
    keyDownUp(78); // n
    Handsontable.dom.setCaretPosition($editorInput[0], 1, 2);

    setTimeout(function () {
      keyDownUp('arrow_down');
      expect(Handsontable.dom.getCaretPosition($editorInput[0])).toEqual(1);
      expect(Handsontable.dom.getSelectionEndPosition($editorInput[0])).toEqual(2);
      keyDownUp('arrow_down');
      expect(Handsontable.dom.getCaretPosition($editorInput[0])).toEqual(1);
      expect(Handsontable.dom.getSelectionEndPosition($editorInput[0])).toEqual(2);
      done();
    }, 200);
  });

  it('should jump to the sibling cell, after pressing up key in quick edit mode', function (done) {
    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process(choices.filter(function (choice) {
        return choice.indexOf(query) != -1;
      }));
    });

    handsontable({
      columns: [{
        type: 'autocomplete',
        source: syncSources,
        strict: false
      }, {}]
    });

    selectCell(1, 0);
    keyDownUp('x'); // trigger quick edit mode
    var $editorInput = $('.handsontableInput');
    $editorInput.val('an');
    keyDownUp(65); // a
    keyDownUp(78); // n

    setTimeout(function () {
      keyDownUp('arrow_up');

      expect(getSelected()).toEqual([0, 0, 0, 0]);
      done();
    }, 200);
  });

  it('should jump to the next cell, after pressing right key in quick edit mode', function (done) {
    var syncSources = jasmine.createSpy('syncSources');

    syncSources.plan = function (query, process) {
      process(choices.filter(function (choice) {
        return choice.indexOf(query) != -1;
      }));
    };

    handsontable({
      columns: [{
        type: 'autocomplete',
        source: syncSources,
        strict: false
      }, {}]
    });

    selectCell(1, 0);
    keyDownUp('x'); // trigger quick edit mode
    var $editorInput = $('.handsontableInput');
    $editorInput.val('an');
    keyDownUp(65); // a
    keyDownUp(78); // n

    setTimeout(function () {
      keyDownUp('arrow_right');

      expect(getSelected()).toEqual([1, 1, 1, 1]);
      done();
    }, 200);
  });

  it('should jump to the next cell, after pressing left key in quick edit mode', function (done) {
    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process(choices.filter(function (choice) {
        return choice.indexOf(query) != -1;
      }));
    });

    handsontable({
      columns: [{}, {
        type: 'autocomplete',
        source: syncSources,
        strict: false
      }]
    });

    selectCell(1, 1);
    keyDownUp('x'); // trigger quick edit mode
    var $editorInput = $('.handsontableInput');
    $editorInput.val('an');
    keyDownUp(65); // a
    keyDownUp(78); // n
    // put caret on the end of the text to ensure that editor will be closed after hit left arrow key
    Handsontable.dom.setCaretPosition($editorInput[0], 2, 2);

    setTimeout(function () {
      keyDownUp('arrow_left');

      expect(getSelected()).toEqual([1, 0, 1, 0]);
      done();
    }, 200);
  });

  it('should jump to the next cell, after pressing down key in quick edit mode', function (done) {
    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process(choices.filter(function (choice) {
        return choice.indexOf(query) != -1;
      }));
    });

    handsontable({
      columns: [{
        type: 'autocomplete',
        source: syncSources,
        strict: false
      }, {}]
    });
    selectCell(1, 0);
    keyDownUp('x'); // trigger quick edit mode
    var $editorInput = $('.handsontableInput');
    $editorInput.val('an');
    keyDownUp(65); // a
    keyDownUp(78); // n

    setTimeout(function () {
      keyDownUp('arrow_down');

      expect(getSelected()).toEqual([1, 0, 1, 0]);
      done();
    }, 200);
  });

  it('should jump to the next cell, after pressing down key in quick edit mode when no matching option list found', function (done) {
    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process(choices.filter(function (choice) {
        return choice.indexOf(query) != -1;
      }));
    });

    handsontable({
      columns: [{
        type: 'autocomplete',
        source: syncSources,
        strict: false
      }, {}]
    });
    selectCell(1, 0);
    keyDownUp('x'); // trigger quick edit mode
    var $editorInput = $('.handsontableInput');
    $editorInput.val('anananan');
    keyDownUp(65); // a
    keyDownUp(78); // n
    keyDownUp(65); // a
    keyDownUp(78); // n
    keyDownUp(65); // a
    keyDownUp(78); // n
    keyDownUp(65); // a
    keyDownUp(78); // n

    setTimeout(function () {
      keyDownUp('arrow_down');

      expect(getSelected()).toEqual([2, 0, 2, 0]);
      done();
    }, 200);
  });

  it('should not jump to the next cell, after pressing down key in quick edit mode when options list was opened', function (done) {
    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process(choices.filter(function (choice) {
        return choice.indexOf(query) != -1;
      }));
    });

    handsontable({
      columns: [{
        type: 'autocomplete',
        source: syncSources,
        strict: false
      }, {}]
    });
    selectCell(1, 0);
    keyDownUp('x'); // trigger quick edit mode
    var $editorInput = $('.handsontableInput');
    $editorInput.val('an');
    keyDownUp(65); // a
    keyDownUp(78); // n

    setTimeout(function () {
      keyDownUp('arrow_down');

      expect(getSelected()).toEqual([1, 0, 1, 0]);
      done();
    }, 200);
  });

  it('should select option in opened editor after pressing down key in quick edit mode', function (done) {
    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process(choices.filter(function (choice) {
        return choice.indexOf(query) != -1;
      }));
    });

    var hot = handsontable({
      columns: [{
        type: 'autocomplete',
        source: syncSources,
        strict: false
      }, {}]
    });

    selectCell(1, 0);
    keyDownUp('x'); // Trigger quick edit mode

    setTimeout(function () {
      keyDownUp('arrow_down');

      expect(hot.getActiveEditor().htEditor.getSelected()).toEqual([0, 0, 0, 0]);

      keyDownUp('arrow_down');

      expect(hot.getActiveEditor().htEditor.getSelected()).toEqual([1, 0, 1, 0]);

      keyDownUp('arrow_down');

      expect(hot.getActiveEditor().htEditor.getSelected()).toEqual([2, 0, 2, 0]);
      done();
    }, 200);
  });

  it('should select option in opened editor after pressing up key in quick edit mode', function (done) {
    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process(choices.filter(function (choice) {
        return choice.indexOf(query) != -1;
      }));
    });

    var hot = handsontable({
      columns: [{
        type: 'autocomplete',
        source: syncSources,
        strict: false
      }, {}]
    });

    selectCell(1, 0);
    keyDownUp('x'); // Trigger quick edit mode

    setTimeout(function () {
      hot.getActiveEditor().htEditor.selectCell(2, 0);

      expect(hot.getActiveEditor().htEditor.getSelected()).toEqual([2, 0, 2, 0]);

      keyDownUp('arrow_up');

      expect(hot.getActiveEditor().htEditor.getSelected()).toEqual([1, 0, 1, 0]);

      keyDownUp('arrow_up');

      expect(hot.getActiveEditor().htEditor.getSelected()).toEqual([0, 0, 0, 0]);

      keyDownUp('arrow_up');

      expect(hot.getActiveEditor().htEditor.getSelected()).toEqual([0, 0, 0, 0]);
      done();
    }, 200);
  });

  it('should not close editor in quick edit mode after pressing down key when last option is selected', function (done) {
    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process(choices.filter(function (choice) {
        return choice.indexOf(query) != -1;
      }));
    });

    var hot = handsontable({
      columns: [{
        type: 'autocomplete',
        source: syncSources,
        strict: false
      }, {}]
    });

    selectCell(1, 0);
    keyDownUp('x'); // Trigger quick edit mode

    setTimeout(function () {
      hot.getActiveEditor().htEditor.selectCell(7, 0);
      hot.listen();

      keyDownUp('arrow_down');
      keyDownUp('arrow_down');
      keyDownUp('arrow_down');
      keyDownUp('arrow_down');
      keyDownUp('arrow_down');

      expect(hot.getActiveEditor().isOpened()).toBe(true);
      done();
    }, 200);
  });

  it('should close editor in quick edit mode after pressing up key when no option is selected', function (done) {
    var syncSources = jasmine.createSpy('syncSources');

    syncSources.and.callFake(function (query, process) {
      process(choices.filter(function (choice) {
        return choice.indexOf(query) != -1;
      }));
    });

    var hot = handsontable({
      columns: [{
        type: 'autocomplete',
        source: syncSources,
        strict: false
      }, {}]
    });

    selectCell(1, 0);
    keyDownUp('x'); // Trigger quick edit mode

    setTimeout(function () {
      hot.getActiveEditor().htEditor.selectCell(1, 0);
      hot.listen();

      keyDownUp('arrow_up');
      keyDownUp('arrow_up');
      keyDownUp('arrow_up');

      expect(getSelected()).toEqual([0, 0, 0, 0]);
      done();
    }, 200);
  });
});

/***/ }),
/* 206 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('BaseEditor', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '" style="width: 300px; height: 200px; overflow: auto"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  describe('ctrl + enter when editor is active', function () {
    it('should populate value from the currently active cell to every cell in the selected range', function () {
      var hot = handsontable({
        data: Handsontable.helper.createSpreadsheetData(6, 6)
      });

      selectCell(1, 1, 2, 2);

      expect(getDataAtCell(1, 1)).toEqual('B2');
      expect(getDataAtCell(2, 2)).toEqual('C3');

      keyDown(Handsontable.helper.KEY_CODES.ENTER);
      keyDown('ctrl+enter');

      expect(getDataAtCell(1, 1)).toEqual('B2');
      expect(getDataAtCell(1, 2)).toEqual('B2');
      expect(getDataAtCell(2, 1)).toEqual('B2');
      expect(getDataAtCell(2, 2)).toEqual('B2');

      loadData(Handsontable.helper.createSpreadsheetData(6, 6));

      selectCell(1, 2, 2, 1);

      expect(getDataAtCell(1, 2)).toEqual('C2');
      expect(getDataAtCell(2, 1)).toEqual('B3');

      keyDown(Handsontable.helper.KEY_CODES.ENTER);
      keyDown('ctrl+enter');

      expect(getDataAtCell(1, 1)).toEqual('C2');
      expect(getDataAtCell(1, 2)).toEqual('C2');
      expect(getDataAtCell(2, 1)).toEqual('C2');
      expect(getDataAtCell(2, 2)).toEqual('C2');

      loadData(Handsontable.helper.createSpreadsheetData(6, 6));
      selectCell(2, 2, 1, 1);
      expect(getDataAtCell(2, 2)).toEqual('C3');

      keyDown(Handsontable.helper.KEY_CODES.ENTER);
      keyDown('ctrl+enter');

      expect(getDataAtCell(1, 1)).toEqual('C3');
      expect(getDataAtCell(1, 2)).toEqual('C3');
      expect(getDataAtCell(2, 1)).toEqual('C3');
      expect(getDataAtCell(2, 2)).toEqual('C3');

      loadData(Handsontable.helper.createSpreadsheetData(6, 6));
      selectCell(2, 1, 1, 2);
      expect(getDataAtCell(2, 1)).toEqual('B3');

      keyDown(Handsontable.helper.KEY_CODES.ENTER);
      keyDown('ctrl+enter');

      expect(getDataAtCell(1, 1)).toEqual('B3');
      expect(getDataAtCell(1, 2)).toEqual('B3');
      expect(getDataAtCell(2, 1)).toEqual('B3');
      expect(getDataAtCell(2, 2)).toEqual('B3');
    });
  });

  it('should exported all editors into Handsontable.editors object', function () {
    expect(Handsontable.editors.AutocompleteEditor).toBeDefined();
    expect(Handsontable.editors.BaseEditor).toBeDefined();
    expect(Handsontable.editors.CheckboxEditor).toBeDefined();
    expect(Handsontable.editors.DateEditor).toBeDefined();
    expect(Handsontable.editors.DropdownEditor).toBeDefined();
    expect(Handsontable.editors.HandsontableEditor).toBeDefined();
    expect(Handsontable.editors.MobileEditor).toBeDefined();
    expect(Handsontable.editors.NumericEditor).toBeDefined();
    expect(Handsontable.editors.PasswordEditor).toBeDefined();
    expect(Handsontable.editors.SelectEditor).toBeDefined();
    expect(Handsontable.editors.TextEditor).toBeDefined();
  });
});

/***/ }),
/* 207 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('DateEditor', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  function getDates() {
    return [['01/14/2006'], ['12/01/2008'], ['11/19/2011'], ['02/02/2004'], ['07/24/2011']];
  }

  it('should display Pikday calendar', function () {
    handsontable({
      data: getDates(),
      columns: [{
        type: 'date'
      }]
    });

    expect($('.pika-single').is(':visible')).toBe(false);

    selectCell(0, 0);
    keyDown('enter');

    expect($('.pika-single').is(':visible')).toBe(true);
  });

  it('should pass date picker config object to Pikday', function () {
    var onOpenSpy = jasmine.createSpy('open');
    var onCloseSpy = jasmine.createSpy('close');
    var hot = handsontable({
      data: getDates(),
      columns: [{
        type: 'date',
        datePickerConfig: {
          firstDay: 1,
          field: 'field', // read only - shouldn't overwrite
          trigger: 'trigger', // read only - shouldn't overwrite
          container: 'container', // read only - shouldn't overwrite
          bound: true, // read only - shouldn't overwrite
          i18n: {
            previousMonth: 'Poprzedni',
            nextMonth: 'Następny',
            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']
          },
          onOpen: onOpenSpy,
          onClose: onCloseSpy
        }
      }]
    });

    selectCell(0, 0);
    keyDown('enter');
    keyDown('esc');

    var config = hot.getActiveEditor().$datePicker.config();

    expect(config.field instanceof HTMLElement).toBe(true);
    expect(config.trigger instanceof HTMLElement).toBe(true);
    expect(config.container instanceof HTMLElement).toBe(true);
    expect(config.bound).toBe(false);
    expect(config.firstDay).toBe(1);
    expect(config.i18n.previousMonth).toBe('Poprzedni');
    expect(config.i18n.nextMonth).toBe('Następny');
    expect(onOpenSpy).toHaveBeenCalled();
    expect(onCloseSpy).toHaveBeenCalled();
  });

  it('should remove any HTML connected with Pikaday Calendar', function () {
    handsontable({
      data: getDates(),
      columns: [{
        type: 'date'
      }]
    });

    expect($('.pika-single').length).toBe(0);

    selectCell(0, 0);
    keyDown('enter');

    expect($('.pika-single').length).toBe(1);

    destroy();

    expect($('.pika-single').length).toBe(0);
  });

  it('should select date corresponding to cell value', function () {
    handsontable({
      data: getDates(),
      columns: [{
        type: 'date',
        dateFormat: 'MM/DD/YYYY'
      }]
    });

    selectCell(0, 0);
    keyDown('enter');

    var date = new Date(getDates()[0][0]);

    expect($('.pika-single').find('.pika-select-year').find(':selected').val()).toMatch(date.getFullYear().toString());
    expect($('.pika-single').find('.pika-select-month').find(':selected').val()).toMatch(date.getMonth().toString());
    expect($('.pika-single').find('.pika-table .is-selected').text()).toMatch(date.getDate().toString());
  });

  it('should save new date after clicked on calendar', function (done) {
    handsontable({
      data: getDates(),
      columns: [{
        type: 'date',
        dateFormat: 'MM/DD/YYYY'
      }]
    });

    selectCell(0, 0);
    expect(getDataAtCell(0, 0)).toMatch('01/14/2006');

    keyDown('enter');

    mouseDown($('.pika-single').find('.pika-table tbody tr:eq(0) td:eq(0) button'));

    setTimeout(function () {
      expect(getDataAtCell(0, 0)).toMatch('01/01/2006');
      done();
    }, 150);
  });

  it('should display fill handle after selected date on calendar', function (done) {
    handsontable({
      data: getDates(),
      columns: [{
        type: 'date',
        dateFormat: 'MM/DD/YYYY'
      }]
    });

    selectCell(0, 0);
    expect(getDataAtCell(0, 0)).toMatch('01/14/2006');

    keyDown('enter');

    mouseDown($('.pika-single').find('.pika-table tbody tr:eq(0) td:eq(0) button'));

    setTimeout(function () {
      expect(getDataAtCell(0, 0)).toMatch('01/01/2006');
      expect($('.htBorders .current.corner').is(':visible')).toBe(true);
      done();
    }, 150);
  });

  it('should setup in settings and display defaultDate on calendar', function (done) {
    handsontable({
      data: getDates(),
      minSpareRows: 1,
      columns: [{
        type: 'date',
        dateFormat: 'MM/DD/YYYY',
        defaultDate: '01/01/1900'
      }]
    });

    selectCell(5, 0);
    expect(getDataAtCell(5, 0)).toBe(null);

    keyDown('enter');

    var date = new Date('01/01/1900');

    expect($('.pika-single').find('.pika-select-year').find(':selected').val()).toMatch(date.getFullYear().toString());
    expect($('.pika-single').find('.pika-select-month').find(':selected').val()).toMatch(date.getMonth().toString());
    expect($('.pika-single').find('.pika-table .is-selected').text()).toMatch(date.getDate().toString());

    keyDown('enter');

    setTimeout(function () {
      expect(getDataAtCell(5, 0)).toMatch('01/01/1900');
      done();
    }, 150);
  });

  it('should close calendar after picking new date', function () {
    handsontable({
      data: getDates(),
      columns: [{
        type: 'date',
        dateFormat: 'MM/DD/YYYY'
      }]
    });

    selectCell(0, 0);
    keyDown('enter');

    expect($('.pika-single').is(':visible')).toBe(true);

    mouseDown($('.pika-single').find('.pika-table tbody tr:eq(0) td:eq(0) button'));

    expect($('.pika-single').is(':visible')).toBe(false);
  });

  it('should enable to input any value in textarea', function (done) {
    var hot = handsontable({
      data: getDates(),
      columns: [{
        type: 'date'
      }]
    });

    selectCell(0, 0);

    var editor = hot.getActiveEditor();

    editor.beginEditing();

    expect(editor.isOpened()).toBe(true);

    editor.TEXTAREA.value = 'foo';
    keyDownUp('o'.charCodeAt(0));

    expect(editor.getValue()).toEqual('foo');

    editor.finishEditing();

    setTimeout(function () {
      expect(getDataAtCell(0, 0)).toEqual('foo');
      done();
    }, 30);
  });

  it('should restore original when edited and pressed ESC ', function (done) {
    var hot = handsontable({
      data: getDates(),
      columns: [{
        type: 'date'
      }]
    });

    selectCell(0, 0);

    var editor = hot.getActiveEditor();

    editor.beginEditing();

    expect(editor.isOpened()).toBe(true);

    editor.TEXTAREA.value = 'foo';

    expect(editor.getValue()).toEqual('foo');

    keyDownUp(Handsontable.helper.KEY_CODES.ESCAPE); // cancel editing

    editor.finishEditing();

    setTimeout(function () {
      expect(getDataAtCell(0, 0)).toEqual('01/14/2006');
      done();
    }, 30);
  });

  it('should display a calendar based on a current date, even if a date in a wrong format was entered previously', function (done) {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 2),
      columns: [{ type: 'date' }, { type: 'date', dateFormat: 'YYYY-MM-DD' }],
      minSpareRows: 1
    });

    setDataAtCell(4, 1, '15-11-11');

    setTimeout(function () {
      selectCell(5, 1);
      keyDown('enter');

      expect($('.pika-single').is(':visible')).toBe(true);

      mouseDown($('.pika-single').find('.pika-table tbody tr:eq(3) td:eq(3) button'));
    }, 150);

    setTimeout(function () {
      var resultDate = getDataAtCell(5, 1);

      expect(moment(resultDate).year()).toEqual(moment().year());
      expect(moment(resultDate).month()).toEqual(moment().month());
      done();
    }, 300);
  });

  it('should display Pikaday Calendar bottom of the selected cell', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 2),
      columns: [{ type: 'date' }, { type: 'date' }]
    }),
        cellOffset,
        datePickerOffset;

    selectCell(1, 1);
    keyDown('enter');

    cellOffset = $(hot.getActiveEditor().TD).offset();
    datePickerOffset = $('.pika-single').offset();

    // 23 is a height of the editor cell
    expect(cellOffset.top + 23).toBeCloseTo(datePickerOffset.top, 0);
    expect(cellOffset.left).toBeCloseTo(datePickerOffset.left, 0);
  });

  it('should display Pikaday Calendar bottom of the selected cell when table have scrolls', function () {
    var container = $('#testContainer');

    container[0].style.height = '300px';
    container[0].style.width = '200px';
    container[0].style.overflow = 'hidden';

    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(30, 10),
      colWidths: 60,
      columns: [{ type: 'date' }, { type: 'date' }, { type: 'date' }, { type: 'date' }, { type: 'date' }, { type: 'date' }, { type: 'date' }]
    }),
        cellOffset,
        datePickerOffset;

    selectCell(20, 6);
    keyDown('enter');

    cellOffset = $(hot.getActiveEditor().TD).offset();
    datePickerOffset = $('.pika-single').offset();

    expect(cellOffset.top + 23).toBeCloseTo(datePickerOffset.top, 0);
    expect(cellOffset.left).toBeCloseTo(datePickerOffset.left, 0);
  });

  it('should not modify the edited date and time, when opening the editor', function () {
    var hot = handsontable({
      data: [['02/02/2015 8:00 AM']],
      columns: [{
        type: 'date',
        dateFormat: 'MM/DD/YYYY h:mm A',
        correctFormat: true,
        defaultDate: '01/01/1900',
        allowEmpty: false
      }]
    }),
        editor,
        cellValue;

    // setDataAtCell(0, 0, '02/02/2015 8:00 AM');
    cellValue = getDataAtCell(0, 0);

    selectCell(0, 0);
    keyDown('enter');

    editor = hot.getActiveEditor();

    expect(editor.TEXTAREA.value).toEqual(cellValue);
  });
});

/***/ }),
/* 208 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('DropdownEditor', function () {
  var id = 'testContainer';

  var choices = ['yellow', 'red', 'orange', 'green', 'blue', 'gray', 'black', 'white', 'purple', 'lime', 'olive', 'cyan'];

  var hot;

  beforeEach(function () {
    this.$container = $('<div id="' + id + '" style="width: 300px; height: 200px; overflow: auto"></div>').appendTo('body');
  });

  afterEach(function () {
    if (hot) {
      hot = null;
    }

    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  describe('open editor', function () {
    // see https://github.com/handsontable/handsontable/issues/3380
    it('should not throw error while selecting the next cell by hitting enter key', function () {
      var spy = jasmine.createSpyObj('error', ['test']);
      var prevError = window.onerror;

      window.onerror = function (messageOrEvent, source, lineno, colno, error) {
        spy.test();
      };
      handsontable({
        columns: [{
          editor: 'dropdown',
          source: choices
        }]
      });

      selectCell(0, 0);
      keyDownUp('enter');
      keyDownUp('enter');
      keyDownUp('enter');

      expect(spy.test.calls.count()).toBe(0);

      window.onerror = prevError;
    });
  });

  describe('closing the editor', function () {
    it('should not close editor on scrolling', function (done) {
      hot = handsontable({
        data: [['', 'two', 'three'], ['four', 'five', 'six']],
        columns: [{
          type: 'dropdown',
          source: choices
        }, {}, {}]
      });

      selectCell(0, 0);
      $(getCell(0, 0)).find('.htAutocompleteArrow').simulate('mousedown');
      $(getCell(0, 0)).find('.htAutocompleteArrow').simulate('mouseup');

      hot.view.wt.wtOverlays.topOverlay.scrollTo(1);
      var dropdown = hot.getActiveEditor();

      setTimeout(function () {
        expect($(dropdown.htContainer).is(':visible')).toBe(true);
        selectCell(0, 0);
      }, 30);

      setTimeout(function () {
        $(getCell(0, 0)).find('.htAutocompleteArrow').simulate('mousedown');
        $(getCell(0, 0)).find('.htAutocompleteArrow').simulate('mouseup');

        hot.view.wt.wtOverlays.topOverlay.scrollTo(3);
      }, 150);

      setTimeout(function () {
        expect($(dropdown.htContainer).is(':visible')).toBe(true);
        done();
      }, 200);
    });
  });

  it('should mark all invalid values as invalid, after pasting them into dropdown-type cells', function (done) {
    hot = handsontable({
      data: [['', 'two', 'three'], ['four', 'five', 'six']],
      columns: [{
        type: 'dropdown',
        source: choices
      }, {}, {}]
    });

    populateFromArray(0, 0, [['invalid'], ['input']], null, null, 'paste');

    setTimeout(function () {
      expect(Handsontable.dom.hasClass(getCell(0, 0), 'htInvalid')).toBe(true);
      expect(Handsontable.dom.hasClass(getCell(1, 0), 'htInvalid')).toBe(true);
      done();
    }, 40);
  });
});

/***/ }),
/* 209 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('HandsontableEditor', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  function getManufacturerData() {
    return [{ name: 'BMW', country: 'Germany', owner: 'Bayerische Motoren Werke AG' }, { name: 'Chrysler', country: 'USA', owner: 'Chrysler Group LLC' }, { name: 'Nissan', country: 'Japan', owner: 'Nissan Motor Company Ltd' }, { name: 'Suzuki', country: 'Japan', owner: 'Suzuki Motor Corporation' }, { name: 'Toyota', country: 'Japan', owner: 'Toyota Motor Corporation' }, { name: 'Volvo', country: 'Sweden', owner: 'Zhejiang Geely Holding Group' }];
  }

  it('should create an editor that is a Handsontable instance', function () {
    handsontable({
      columns: [{
        type: 'handsontable',
        handsontable: {
          colHeaders: ['Marque', 'Country', 'Parent company'],
          data: getManufacturerData()
        }
      }]
    });
    selectCell(2, 0);

    keyDownUp('enter');
    expect(this.$container.find('.handsontableEditor:visible').length).toEqual(1);
  });

  it('should destroy the editor when Esc is pressed', function () {
    handsontable({
      columns: [{
        type: 'handsontable',
        handsontable: {
          colHeaders: ['Marque', 'Country', 'Parent company'],
          data: getManufacturerData()
        }
      }]
    });
    selectCell(2, 0);

    keyDownUp('enter');
    keyDownUp('esc');
    expect(this.$container.find('.handsontableEditor:visible').length).toEqual(0);
  });

  // see https://github.com/handsontable/handsontable/issues/3380
  it('should not throw error while selecting the next cell by hitting enter key', function () {
    var spy = jasmine.createSpyObj('error', ['test']);
    var prevError = window.onerror;

    window.onerror = function (messageOrEvent, source, lineno, colno, error) {
      spy.test();
    };
    handsontable({
      columns: [{
        type: 'handsontable',
        handsontable: {
          data: [['Marque'], ['Country'], ['Parent company']]
        }
      }]
    });

    selectCell(0, 0);
    keyDownUp('enter');
    keyDownUp('enter');
    keyDownUp('enter');

    expect(spy.test.calls.count()).toBe(0);

    window.onerror = prevError;
  });

  it('Enter pressed in nested HT should set the value and hide the editor', function () {
    handsontable({
      columns: [{
        type: 'handsontable',
        handsontable: {
          colHeaders: ['Marque', 'Country', 'Parent company'],
          data: getManufacturerData()
        }
      }]
    });
    selectCell(2, 0);

    keyDownUp('enter');
    keyDownUp('arrow_down');
    keyDownUp('enter');
    expect(this.$container.find('.handsontableEditor:visible').length).toEqual(0);
    expect(getDataAtCell(2, 0)).toEqual('BMW');
  });

  it('should keep focus on textarea after arrow is pressed', function () {
    var hot = handsontable({
      columns: [{
        type: 'handsontable',
        handsontable: {
          colHeaders: ['Marque', 'Country', 'Parent company'],
          data: getManufacturerData()
        }
      }]
    });
    selectCell(2, 0);

    keyDownUp('enter');
    keyDownUp('arrow_down');
    expect(document.activeElement).toEqual(hot.getActiveEditor().TEXTAREA);
  });

  it('should focus the TD after HT editor is prepared and destroyed', function () {
    handsontable({
      columns: [{
        type: 'handsontable',
        handsontable: {
          colHeaders: ['Marque', 'Country', 'Parent company'],
          data: getManufacturerData()
        }
      }]
    });

    selectCell(2, 0);
    keyDownUp('arrow_down');
    keyDownUp('arrow_down');

    expect(getSelected()).toEqual([4, 0, 4, 0]);
  });

  it('should focus the TD after HT editor is prepared, finished (by keyboard) and destroyed', function () {
    var selections = [];

    handsontable({
      columns: [{
        type: 'handsontable',
        handsontable: {
          colHeaders: ['Marque', 'Country', 'Parent company'],
          data: getManufacturerData(),
          afterSelection: function afterSelection() {
            selections.push(['inner', arguments[0]]); // arguments[0] is selection start row
          }
        }
      }],
      afterSelection: function afterSelection() {
        selections.push(['outer', arguments[0]]); // arguments[0] is selection start row
      }
    });
    expect(selections.length).toBe(0);

    selectCell(1, 0);
    expect(selections[0]).toEqual(['outer', 1]);

    keyDownUp('arrow_down');
    expect(selections[1]).toEqual(['outer', 2]);

    keyDownUp('enter');

    keyDownUp('arrow_down');
    expect(selections[2]).toEqual(['inner', 0]);

    keyDownUp('esc');
    keyDownUp('arrow_down');
    expect(selections[3]).toEqual(['outer', 3]);

    expect(selections.length).toBe(4);
  });

  describe('strict mode', function () {
    it('should open editor and select cell (0, 0) in inner HOT', function () {
      var hot = handsontable({
        columns: [{
          type: 'handsontable',
          handsontable: {
            colHeaders: ['Marque', 'Country', 'Parent company'],
            data: getManufacturerData()
          },
          strict: true
        }]
      });
      selectCell(2, 0);

      keyDownUp('enter');

      var ht = hot.getActiveEditor();
      var innerHot = ht.htEditor;

      expect(innerHot.getSelected()).toEqual([0, 0, 0, 0]);
    });

    it('should hide textarea', function () {
      var hot = handsontable({
        columns: [{
          type: 'handsontable',
          handsontable: {
            colHeaders: ['Marque', 'Country', 'Parent company'],
            data: getManufacturerData()
          },
          strict: true
        }]
      });
      selectCell(2, 0);

      keyDownUp('enter');

      expect(hot.getActiveEditor().TEXTAREA.style.visibility).toEqual('hidden');
    });
  });

  describe('non strict mode', function () {

    it('should open editor and DO NOT select any cell in inner HOT', function () {
      var hot = handsontable({
        columns: [{
          type: 'handsontable',
          handsontable: {
            colHeaders: ['Marque', 'Country', 'Parent company'],
            data: getManufacturerData()
          }
        }]
      });
      selectCell(2, 0);

      keyDownUp('enter');

      var ht = hot.getActiveEditor();
      var innerHot = ht.htEditor;

      expect(innerHot.getSelected()).toBeUndefined();
    });

    it('should show textarea', function () {
      var hot = handsontable({
        columns: [{
          type: 'handsontable',
          handsontable: {
            colHeaders: ['Marque', 'Country', 'Parent company'],
            data: getManufacturerData()
          }
        }]
      });
      selectCell(2, 0);

      keyDownUp('enter');
      expect(hot.getActiveEditor().TEXTAREA.style.visibility).toEqual('visible');
    });
  });
});

/***/ }),
/* 210 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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"); } }

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; }

describe('editors', function () {
  var id = 'testContainer';
  var _Handsontable$editors = Handsontable.editors,
      registerEditor = _Handsontable$editors.registerEditor,
      getEditor = _Handsontable$editors.getEditor;


  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should register custom editor', function () {
    var MyEditor = function (_Handsontable$editors2) {
      _inherits(MyEditor, _Handsontable$editors2);

      function MyEditor() {
        _classCallCheck(this, MyEditor);

        return _possibleConstructorReturn(this, (MyEditor.__proto__ || Object.getPrototypeOf(MyEditor)).apply(this, arguments));
      }

      _createClass(MyEditor, [{
        key: 'init',
        value: function init() {
          this.TEXTAREA = document.createElement('TEXTAREA');
          this.TEXTAREA_PARENT = document.createElement('DIV');

          this.TEXTAREA_PARENT.appendChild(this.TEXTAREA);
          this.instance.rootElement.appendChild(this.TEXTAREA_PARENT);
        }
      }, {
        key: 'getValue',
        value: function getValue() {
          return '--' + this.TEXTAREA.value + '--';
        }
      }, {
        key: 'setValue',
        value: function setValue(value) {
          this.TEXTAREA.value = value;
        }
      }, {
        key: 'open',
        value: function open() {}
      }, {
        key: 'close',
        value: function close() {}
      }, {
        key: 'focus',
        value: function focus() {
          this.TEXTAREA.focus();
        }
      }]);

      return MyEditor;
    }(Handsontable.editors.BaseEditor);

    registerEditor('myEditor', MyEditor);

    var hot = handsontable({
      data: [[1, 6, 10]],
      columns: [{
        editor: 'myEditor'
      }]
    });

    selectCell(0, 0);
    keyDown('enter');
    document.activeElement.value = 'hello';
    destroyEditor();

    expect(getDataAtCell(0, 0)).toBe('--hello--');
  });

  it('should retrieve predefined editors by its names', function () {
    expect(getEditor('autocomplete')).toBeFunction();
    expect(getEditor('base')).toBeFunction();
    expect(getEditor('checkbox')).toBeFunction();
    expect(getEditor('date')).toBeFunction();
    expect(getEditor('dropdown')).toBeFunction();
    expect(getEditor('handsontable')).toBeFunction();
    expect(getEditor('mobile')).toBeFunction();
    expect(getEditor('numeric')).toBeFunction();
    expect(getEditor('password')).toBeFunction();
    expect(getEditor('select')).toBeFunction();
    expect(getEditor('text')).toBeFunction();
  });

  it('should retrieve custom editor by its names', function () {
    var MyEditor = function MyEditor() {
      _classCallCheck(this, MyEditor);
    };

    registerEditor('myEditor', MyEditor);

    expect(getEditor('myEditor')).toBe(MyEditor);
  });
});

/***/ }),
/* 211 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('noEditor', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '" style="width: 300px; height: 200px; overflow: auto"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('shouldn\'t begin editing when enterBeginsEditing equals true', function () {
    var selection;

    handsontable({
      enterBeginsEditing: true,
      editor: false
    });
    selectCell(2, 2);
    keyDown('enter');
    selection = getSelected();

    expect(selection).toEqual([2, 2, 2, 2]);
    expect(isEditorVisible()).toEqual(false);
  });

  it('shouldn\'t move down after editing', function () {
    var selection;

    handsontable({
      editor: false
    });
    selectCell(2, 2);
    keyDown('enter');
    keyDown('enter');
    selection = getSelected();

    expect(selection).toEqual([2, 2, 2, 2]);
  });

  it('shouldn\'t move down when enterBeginsEditing equals false', function () {
    var selection;

    handsontable({
      enterBeginsEditing: false,
      editor: false
    });
    selectCell(2, 2);
    keyDown('enter');
    selection = getSelected();

    expect(selection).toEqual([3, 2, 3, 2]);
    expect(isEditorVisible()).toEqual(false);
  });

  it('shouldn\'t render any value in editor', function () {
    handsontable({
      editor: false
    });
    setDataAtCell(2, 2, 'string');
    selectCell(2, 2);
    keyDown('enter');

    expect(keyProxy().length).toEqual(0);
  });

  it('shouldn\'t open editor after hitting F2', function () {
    handsontable({
      editor: false
    });
    selectCell(2, 2);

    expect(isEditorVisible()).toEqual(false);

    keyDown('f2');

    expect(isEditorVisible()).toEqual(false);
  });

  it('shouldn\'t open editor after hitting CapsLock', function () {
    handsontable({
      editor: false
    });
    selectCell(2, 2);

    expect(isEditorVisible()).toEqual(false);

    keyDown(Handsontable.helper.KEY_CODES.CAPS_LOCK);

    expect(isEditorVisible()).toEqual(false);
  });

  it('shouldn\'t open editor after double clicking on a cell', function (done) {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 2),
      editor: false
    });

    var cell = $(getCell(0, 0));
    var clicks = 0;
    window.scrollTo(0, cell.offset().top);

    setTimeout(function () {
      mouseDown(cell);
      mouseUp(cell);
      clicks++;
    }, 0);

    setTimeout(function () {
      mouseDown(cell);
      mouseUp(cell);
      clicks++;
    }, 100);

    setTimeout(function () {
      expect(clicks).toBe(2);
      expect(hot.getActiveEditor()).toBe(undefined);
      expect(isEditorVisible()).toBe(false);
      done();
    }, 200);
  });

  it('should not open editor after pressing a printable character', function () {
    handsontable({
      data: Handsontable.helper.createSpreadsheetData(3, 3),
      editor: false
    });
    selectCell(0, 0);

    expect(isEditorVisible()).toBe(false);

    this.$container.simulate('keydown', { keyCode: 'a'.charCodeAt(0) });

    expect(isEditorVisible()).toBe(false);
  });

  it('should not open editor after pressing a printable character with shift key', function () {
    handsontable({
      data: Handsontable.helper.createSpreadsheetData(3, 3),
      editor: false
    });
    selectCell(0, 0);

    expect(isEditorVisible()).toBe(false);

    this.$container.simulate('keydown', { keyCode: 'a'.charCodeAt(0), shiftKey: true });

    expect(isEditorVisible()).toBe(false);
  });

  it('should not not open editor after hitting ALT', function () {
    handsontable({
      data: Handsontable.helper.createSpreadsheetData(4, 4),
      editor: false
    });
    expect(getDataAtCell(0, 0)).toEqual('A1');

    selectCell(0, 0);
    keyDown(Handsontable.helper.KEY_CODES.ALT);

    expect(isEditorVisible()).toBe(false);
  });
});

/***/ }),
/* 212 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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; };

describe('NumericEditor', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  var arrayOfObjects = function arrayOfObjects() {
    return [{ id: 1, name: 'Ted', lastName: 'Right' }, { id: 2, name: 'Frank', lastName: 'Honest' }, { id: 3, name: 'Joan', lastName: 'Well' }, { id: 4, name: 'Sid', lastName: 'Strong' }, { id: 5, name: 'Jane', lastName: 'Neat' }, { id: 6, name: 'Chuck', lastName: 'Jackson' }, { id: 7, name: 'Meg', lastName: 'Jansen' }, { id: 8, name: 'Rob', lastName: 'Norris' }, { id: 9, name: 'Sean', lastName: 'O\'Hara' }, { id: 10, name: 'Eve', lastName: 'Branson' }];
  };

  it('should convert numeric value to number (object data source)', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', type: 'numeric' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });
    selectCell(2, 0);

    keyDown('enter');
    document.activeElement.value = '999';

    destroyEditor();

    setTimeout(function () {
      expect(_typeof(getDataAtCell(2, 0))).toEqual('number');
      expect(getDataAtCell(2, 0)).toEqual(999);
      done();
    }, 100);
  });

  it('should apply changes to editor after validation', function (done) {
    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', type: 'numeric' }]
    });

    selectCell(0, 0);
    keyDown('delete');

    setTimeout(function () {
      expect(getActiveEditor().originalValue).toEqual('');
      done();
    }, 100);
  });

  it('should allow custom validator', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      allowInvalid: false,
      columns: [{
        data: 'id',
        type: 'numeric',
        validator: function validator(val, cb) {
          cb(parseInt(val, 10) > 100);
        }
      }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });
    selectCell(2, 0);

    keyDown('enter');
    document.activeElement.value = '99';

    destroyEditor();

    setTimeout(function () {
      expect(getDataAtCell(2, 0)).not.toEqual(99); // should be ignored

      document.activeElement.value = '999';

      onAfterValidate.calls.reset();
      destroyEditor();
    }, 100);

    setTimeout(function () {
      expect(getDataAtCell(2, 0)).toEqual(999);
      done();
    }, 200);
  });

  it('should convert string in format \'XX.XX\' to a float with the same value', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', type: 'numeric' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });
    selectCell(2, 0);

    keyDown('enter');

    document.activeElement.value = '99.99';

    onAfterValidate.calls.reset();
    destroyEditor();

    setTimeout(function () {
      expect(getDataAtCell(2, 0)).toEqual(parseFloat(99.99));
      done();
    }, 100);
  });

  it('should convert string in format \'XX.XX\' to a float when passing float without leading zero', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', type: 'numeric' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });
    selectCell(2, 0);

    keyDown('enter');

    document.activeElement.value = '.74';

    onAfterValidate.calls.reset();
    destroyEditor();

    setTimeout(function () {
      expect(getDataAtCell(2, 0)).toEqual(parseFloat(0.74));
      done();
    }, 100);
  });

  it('should convert string in format \'XX,XX\' (with comma as separator) to a float with the same value if the numeric locale ' + 'specifies comma as the precision delimiter (language=de)', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', type: 'numeric', language: 'de-DE' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });
    selectCell(2, 0);

    keyDown('enter');

    document.activeElement.value = '99,99';

    onAfterValidate.calls.reset();
    destroyEditor();

    setTimeout(function () {
      expect(getDataAtCell(2, 0)).toEqual(parseFloat(99.99));
      done();
    }, 100);
  });

  it('should display a string in a format \'$X,XXX.XX\' when using language=en, appropriate format in column settings and \'XXXX.XX\' as ' + 'an input string', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', type: 'numeric', format: '$0,0.00', language: 'en-US' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });
    selectCell(2, 0);

    keyDown('enter');

    document.activeElement.value = '2456.22';

    onAfterValidate.calls.reset();
    destroyEditor();

    setTimeout(function () {
      expect(getCell(2, 0).innerHTML).toEqual('$2,456.22');
      done();
    }, 100);
  });

  it('should display a string in a format \'X.XXX,XX €\' when using language=de, appropriate format in column settings and \'XXXX,XX\' as an ' + 'input string (that comes from manual input)', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', type: 'numeric', format: '0,0.00 $', language: 'de-DE' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });
    selectCell(2, 0);

    keyDown('enter');

    document.activeElement.value = '2456,22';

    onAfterValidate.calls.reset();
    destroyEditor();

    setTimeout(function () {
      expect(getCell(2, 0).innerHTML).toEqual('2.456,22 €');
      done();
    }, 100);
  });

  it('should display a string in a format \'X.XXX,XX €\' when using language=de, appropriate format in column settings and \'XXXX.XX\' as an ' + 'input string (that comes from paste)', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', type: 'numeric', format: '0,0.00 $', language: 'de-DE' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });
    selectCell(2, 0);

    keyDown('enter');

    document.activeElement.value = '2456.22';

    onAfterValidate.calls.reset();
    destroyEditor();

    setTimeout(function () {
      expect(getCell(2, 0).innerHTML).toEqual('2.456,22 €');
      done();
    }, 100);
  });

  it('should not validate input values in different formats than \'XX.XX\' and \'XX,XX\'', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', type: 'numeric' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    selectCell(2, 0);

    function manuallySetValueTo(val) {
      keyDown('enter');

      document.activeElement.value = val;

      onAfterValidate.calls.reset();
      destroyEditor();
    }

    manuallySetValueTo('22.22');

    setTimeout(function () {
      expect($(getCell(2, 0)).hasClass('htInvalid')).toBe(false); // should validate alright
      manuallySetValueTo('2,000,000.22');
    }, 100);

    setTimeout(function () {
      expect($(getCell(2, 0)).hasClass('htInvalid')).toBe(true);
      manuallySetValueTo('11,11');
    }, 200);

    setTimeout(function () {
      expect($(getCell(2, 0)).hasClass('htInvalid')).toBe(false); // should validate alright
      manuallySetValueTo('one thounsand');
    }, 300);

    setTimeout(function () {
      expect($(getCell(2, 0)).hasClass('htInvalid')).toBe(true);
      manuallySetValueTo('99d99');
    }, 400);

    setTimeout(function () {
      expect($(getCell(2, 0)).hasClass('htInvalid')).toBe(true);
      done();
    }, 500);
  });

  it('should paste formatted data if source cell has format', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', type: 'numeric', format: '0,0.00 $', language: 'de-DE' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });
    selectCell(2, 0);

    keyDown('enter');

    document.activeElement.value = '€123,00';

    onAfterValidate.calls.reset();
    destroyEditor();

    setTimeout(function () {
      expect(getCell(2, 0).innerHTML).toEqual('123,00 €');
      done();
    }, 100);
  });

  it('should display a string in a format \'X XXX,XX €\' when using language=de, appropriate format in column settings and \'XXXX,XX\' as an ' + 'input string and ignore not needed zeros at the end', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: [{ id: 1, name: 'Ted', lastName: 'Right', money: 0 }, { id: 2, name: 'Frank', lastName: 'Honest', money: 0 }, { id: 3, name: 'Joan', lastName: 'Well', money: 0 }, { id: 4, name: 'Sid', lastName: 'Strong', money: 0 }, { id: 5, name: 'Jane', lastName: 'Neat', money: 0 }, { id: 6, name: 'Chuck', lastName: 'Jackson', money: 0 }, { id: 7, name: 'Meg', lastName: 'Jansen', money: 0 }, { id: 8, name: 'Rob', lastName: 'Norris', money: 0 }, { id: 9, name: 'Sean', lastName: 'O\'Hara', money: 0 }, { id: 10, name: 'Eve', lastName: 'Branson', money: 0 }],
      columns: [{ data: 'id', type: 'numeric', format: '0,0.00 $', language: 'de-DE' }, { data: 'name' }, { data: 'lastName' }, { data: 'money', type: 'numeric', format: '$0,0.00', language: 'en-US' }],
      afterValidate: onAfterValidate
    });

    selectCell(2, 0);

    function manuallySetValueTo(val) {
      keyDown('enter');

      document.activeElement.value = val;

      onAfterValidate.calls.reset();
      destroyEditor();
    }

    manuallySetValueTo('2456,220');

    setTimeout(function () {
      expect(getCell(2, 0).innerHTML).toEqual('2.456,22 €');

      deselectCell();
      selectCell(2, 3);
      manuallySetValueTo('2456.220');
    }, 100);

    setTimeout(function () {
      expect(getCell(2, 3).innerHTML).toEqual('$2,456.22');
      done();
    }, 200);
  });

  it('should mark text as invalid without removing', function (done) {
    var hot = handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', type: 'numeric', format: '0,0.00' }, { data: 'name' }, { data: 'lastName' }]
    });

    hot.setDataAtCell(0, 0, 'abc');

    setTimeout(function () {
      expect(hot.getDataAtCell(0, 0)).toEqual('abc');
      done();
    }, 200);
  });

  it('should not throw error on closing editor when column data is defined as \'length\'', function () {
    hot = handsontable({
      data: [{ length: 4 }, { length: 5 }],
      columns: [{
        data: 'length', type: 'numeric'
      }, {}, {}]
    });

    selectCell(1, 0);
    keyDown('enter');
    document.activeElement.value = '999';

    expect(function () {
      destroyEditor();
    }).not.toThrow();
  });

  describe('Cell corner is showed properly when changing focused cells #3877', function () {
    var isFocusedCellDisplayingCornerTest = function isFocusedCellDisplayingCornerTest(settings) {
      var moveFromRow = settings.moveFromRow;
      var moveFromCol = settings.moveFromCol;
      var moveToRow = settings.moveToRow;
      var moveToCol = settings.moveToCol;
      var doneFunc = settings.doneFunc;
      var $corner = settings.$container.find('.wtBorder.current.corner');

      selectCell(moveFromRow, moveFromCol);
      keyDown('enter');
      selectCell(moveToRow, moveToCol);

      setTimeout(function () {
        expect($corner.css('display')).toEqual('block');
        doneFunc();
      }, 100);
    };

    it('Moving from numeric editor to text editor', function (done) {
      handsontable({
        data: [{ id: 1, name: 'Ted', lastName: 'Right', money: 0 }],
        columns: [{ data: 'id' }, { data: 'name' }, { data: 'lastName' }, { data: 'money', type: 'numeric', format: '$0,0.00', language: 'en-US' }]
      });

      isFocusedCellDisplayingCornerTest({
        moveFromRow: 0,
        moveFromCol: 3,
        moveToRow: 0,
        moveToCol: 0,
        $container: this.$container,
        doneFunc: done
      });
    });

    it('Moving from text editor to numeric editor', function (done) {
      handsontable({
        data: [{ id: 1, name: 'Ted', lastName: 'Right', money: 0 }],
        columns: [{ data: 'id' }, { data: 'name' }, { data: 'lastName' }, { data: 'money', type: 'numeric', format: '$0,0.00', language: 'en-US' }]
      });

      isFocusedCellDisplayingCornerTest({
        moveFromRow: 0,
        moveFromCol: 1,
        moveToRow: 0,
        moveToCol: 3,
        $container: this.$container,
        doneFunc: done
      });
    });
  });
});

/***/ }),
/* 213 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('PasswordEditor', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '" style="width: 300px; height: 300px;"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should display editor as password field', function () {
    handsontable({
      data: [['Joe'], ['Timothy'], ['Margaret'], ['Jerry']],
      columns: [{
        editor: Handsontable.editors.PasswordEditor
      }]
    });

    selectCell(0, 0);
    keyDown('enter');

    var editor = $('.handsontableInput');

    expect(editor.is(':visible')).toBe(true);
    expect(editor.is(':password')).toBe(true);
  });

  it('should set passwordEditor using \'password\' alias', function () {
    handsontable({
      data: [['Joe'], ['Timothy'], ['Margaret'], ['Jerry']],
      columns: [{
        editor: 'password'
      }]
    });

    selectCell(0, 0);
    keyDown('enter');

    var editor = $('.handsontableInput');

    expect(editor.is(':visible')).toBe(true);
    expect(editor.is(':password')).toBe(true);
  });

  it('should set passwordEditor using column type \'password\' ', function () {
    handsontable({
      data: [['Joe'], ['Timothy'], ['Margaret'], ['Jerry']],
      columns: [{
        type: 'password'
      }]
    });

    selectCell(0, 0);
    keyDown('enter');

    var editorHolder = $('.handsontableInputHolder');
    var editor = editorHolder.find('.handsontableInput');

    expect(editorHolder.is(':visible')).toBe(true);
    expect(editor.is(':password')).toBe(true);
  });

  it('should save values typed in passwordEditor', function () {
    handsontable({
      data: [['Joe'], ['Timothy'], ['Margaret'], ['Jerry']],
      columns: [{
        editor: 'password'
      }]
    });

    selectCell(0, 0);

    expect(getDataAtCell(0, 0)).toMatch('Joe');
    expect(getRenderedValue(0, 0)).toMatch('Joe');

    keyDown('enter');

    var editorHolder = $('.handsontableInputHolder');
    var editor = editorHolder.find('.handsontableInput');

    expect(editorHolder.is(':visible')).toBe(true);

    editor.val('Edgar');

    selectCell(1, 0); // closes editor and saves current value

    expect(editorHolder.is(':visible')).toBe(false);

    expect(getDataAtCell(0, 0)).toMatch('Edgar');
    expect(getRenderedValue(0, 0)).toMatch('Edgar');
  });
});

/***/ }),
/* 214 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('SelectEditor', function () {

  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should display select', function () {
    handsontable({
      columns: [{
        editor: 'select'
      }]
    });

    selectCell(0, 0);

    var editor = $('.htSelectEditor');

    expect(editor.length).toEqual(1);
    expect(editor.is('select')).toBe(true);
    expect(editor.is(':visible')).toBe(false);

    keyDown('enter');

    expect(editor.is(':visible')).toBe(true);
    expect(editor.offset()).toEqual($(getCell(0, 0)).offset());
  });

  it('should display and correctly reposition select editor while scrolling', function (done) {
    var hot = handsontable({
      width: 200,
      height: 200,
      data: Handsontable.helper.createSpreadsheetData(100, 100),
      columns: [{
        editor: 'select'
      }, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, { editor: 'select' }]
    });
    var mainHolder = hot.view.wt.wtTable.holder;

    selectCell(0, 0);
    keyDown('enter');
    keyUp('enter');

    mainHolder.scrollTop = 10;
    mainHolder.scrollLeft = 20;
    var editor = $('.htSelectEditor');

    setTimeout(function () {
      expect(editor.css('top')).toEqual('-10px');
      expect(editor.css('left')).toEqual('-20px');
      done();
    }, 200);
  });

  it('should populate select with given options (array)', function () {
    var options = ['Misubishi', 'Chevrolet', 'Lamborgini'];

    handsontable({
      columns: [{
        editor: 'select',
        selectOptions: options
      }]
    });

    selectCell(0, 0);

    var editor = $('.htSelectEditor');

    keyDown('enter');

    var $options = editor.find('option');

    expect($options.length).toEqual(options.length);
    expect($options.eq(0).val()).toMatch(options[0]);
    expect($options.eq(0).html()).toMatch(options[0]);
    expect($options.eq(1).val()).toMatch(options[1]);
    expect($options.eq(1).html()).toMatch(options[1]);
    expect($options.eq(2).val()).toMatch(options[2]);
    expect($options.eq(2).html()).toMatch(options[2]);
  });

  it('should populate select with given options (object)', function () {
    var options = {
      mit: 'Misubishi',
      che: 'Chevrolet',
      lam: 'Lamborgini'
    };

    handsontable({
      columns: [{
        editor: 'select',
        selectOptions: options
      }]
    });

    selectCell(0, 0);

    var editor = $('.htSelectEditor');

    keyDown('enter');

    var $options = editor.find('option');

    expect($options.eq(0).val()).toMatch('mit');
    expect($options.eq(0).html()).toMatch(options.mit);
    expect($options.eq(1).val()).toMatch('che');
    expect($options.eq(1).html()).toMatch(options.che);
    expect($options.eq(2).val()).toMatch('lam');
    expect($options.eq(2).html()).toMatch(options.lam);
  });

  it('should populate select with given options (function:array)', function () {
    var options = function options() {
      return ['Misubishi', 'Chevrolet', 'Lamborgini'];
    };

    handsontable({
      columns: [{
        editor: 'select',
        selectOptions: options
      }]
    });

    selectCell(0, 0);

    var editor = $('.htSelectEditor');

    keyDown('enter');

    var $options = editor.find('option');

    expect($options.length).toEqual(options().length);
    expect($options.eq(0).val()).toMatch(options()[0]);
    expect($options.eq(0).html()).toMatch(options()[0]);
    expect($options.eq(1).val()).toMatch(options()[1]);
    expect($options.eq(1).html()).toMatch(options()[1]);
    expect($options.eq(2).val()).toMatch(options()[2]);
    expect($options.eq(2).html()).toMatch(options()[2]);
  });

  it('should populate select with given options (function:object)', function () {
    var options = function options() {
      return {
        mit: 'Misubishi',
        che: 'Chevrolet',
        lam: 'Lamborgini'
      };
    };

    handsontable({
      columns: [{
        editor: 'select',
        selectOptions: options
      }]
    });

    selectCell(0, 0);

    var editor = $('.htSelectEditor');

    keyDown('enter');

    var $options = editor.find('option');

    expect($options.eq(0).val()).toMatch('mit');
    expect($options.eq(0).html()).toMatch(options().mit);
    expect($options.eq(1).val()).toMatch('che');
    expect($options.eq(1).html()).toMatch(options().che);
    expect($options.eq(2).val()).toMatch('lam');
    expect($options.eq(2).html()).toMatch(options().lam);
  });

  it('should mark option matching cell value as selected', function () {
    var options = ['Misubishi', 'Chevrolet', 'Lamborgini'];

    handsontable({
      data: [['Misubishi'], ['Lamborgini'], ['Chevrolet']],
      columns: [{
        editor: 'select',
        selectOptions: options
      }]
    });

    selectCell(0, 0);

    var editor = $('.htSelectEditor');

    keyDown('enter');

    expect(editor.find('option:selected').text()).toEqual(getDataAtCell(0, 0));

    keyDown('enter');

    selectCell(1, 0);
    keyDown('enter');

    expect(editor.find('option:selected').text()).toEqual(getDataAtCell(1, 0));

    keyDown('enter');

    selectCell(2, 0);
    keyDown('enter');

    expect(editor.find('option:selected').text()).toEqual(getDataAtCell(2, 0));

    keyDown('enter');
  });

  it('should not prevent the default event action when select is clicked', function () {

    var options = function options() {
      return ['Misubishi', 'Chevrolet', 'Lamborgini'];
    };

    handsontable({
      columns: [{
        editor: 'select',
        selectOptions: options
      }]
    });

    selectCell(0, 0);

    var editor = $('.htSelectEditor');

    keyDown('enter');
    var select = editor.find('select');

    var selectMouseDownListener = jasmine.createSpy('selectMouseDownListener');
    $('body').on('mousedown', selectMouseDownListener);

    editor.mousedown();

    expect(selectMouseDownListener.calls.count()).toEqual(1);

    var event = selectMouseDownListener.calls.argsFor(0)[0];

    expect(event).toBeDefined();
    expect(event.isDefaultPrevented()).toBe(false);
  });
});

/***/ }),
/* 215 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('TextEditor', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '" style="width: 300px; height: 200px; overflow: hidden;"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should begin editing when enterBeginsEditing equals true', function () {
    handsontable({
      enterBeginsEditing: true,
      editor: 'text'
    });
    selectCell(2, 2);

    keyDown('enter');

    var selection = getSelected();
    expect(selection).toEqual([2, 2, 2, 2]);
    expect(isEditorVisible()).toEqual(true);
  });

  it('should move down after editing', function () {
    handsontable({
      editor: 'text'
    });
    selectCell(2, 2);

    keyDown('enter');
    keyDown('enter');

    var selection = getSelected();
    expect(selection).toEqual([3, 2, 3, 2]);
  });

  it('should move down when enterBeginsEditing equals false', function () {
    handsontable({
      enterBeginsEditing: false
    });
    selectCell(2, 2);

    keyDown('enter');

    var selection = getSelected();
    expect(selection).toEqual([3, 2, 3, 2]);
    expect(isEditorVisible()).toEqual(false);
  });

  it('should render string in textarea', function () {
    handsontable();
    setDataAtCell(2, 2, 'string');
    selectCell(2, 2);

    keyDown('enter');

    expect(keyProxy().val()).toEqual('string');
  });

  it('should render textarea editor in specified size at cell 0, 0 without headers', function (done) {
    var hot = handsontable();

    selectCell(0, 0);

    keyDown('enter');

    setTimeout(function () {
      expect(hot.getActiveEditor().TEXTAREA.style.height).toBe('23px');
      expect(hot.getActiveEditor().TEXTAREA.style.width).toBe('40px');
      done();
    }, 200);
  });

  it('should render textarea editor in specified size at cell 1, 0 without headers', function (done) {
    var hot = handsontable();

    selectCell(1, 1);

    keyDown('enter');

    setTimeout(function () {
      expect(hot.getActiveEditor().TEXTAREA.style.height).toBe('23px');
      done();
    }, 200);
  });

  it('should render textarea editor in specified size at cell 0, 0 with headers', function (done) {
    var hot = handsontable({
      rowHeaders: true,
      colHeaders: true
    });

    selectCell(0, 0);

    keyDown('enter');

    setTimeout(function () {
      expect(hot.getActiveEditor().TEXTAREA.style.height).toBe('23px');
      expect(hot.getActiveEditor().TEXTAREA.style.width).toBe('40px');
      expect(hot.getActiveEditor().textareaParentStyle.top).toBe('26px');
      done();
    }, 200);
  });

  it('should render textarea editor in specified size at cell 0, 0 with headers defined in columns', function (done) {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetObjectData(10, 10),
      columns: [{
        data: 'prop0',
        title: 'Prop 0'
      }, {
        data: 'prop1',
        title: 'Prop 1'
      }, {
        data: 'prop2',
        title: 'Prop 2'
      }, {
        data: 'prop3',
        title: 'Prop 3'
      }]
    });

    selectCell(0, 0);

    keyDown('enter');

    setTimeout(function () {
      expect(hot.getActiveEditor().TEXTAREA.style.height).toBe('23px');
      expect(parseInt(hot.getActiveEditor().TEXTAREA.style.width, 10)).toBeAroundValue(50, 4);
      expect(hot.getActiveEditor().textareaParentStyle.top).toBe('26px');
      done();
    }, 200);
  });

  it('should hide whole editor when it is higher then header', function (done) {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(50, 50),
      rowHeaders: true,
      colHeaders: true
    });

    setDataAtCell(2, 2, 'string\nstring\nstring');
    selectCell(2, 2);

    keyDown('enter');
    keyUp('enter');

    var mainHolder = hot.view.wt.wtTable.holder;

    mainHolder.scrollTop = 150;
    mainHolder.scrollLeft = 150;

    setTimeout(function () {
      expect(parseInt(hot.getActiveEditor().textareaParentStyle.top, 10)).toBeAroundValue(-77);
      expect(parseInt(hot.getActiveEditor().textareaParentStyle.left, 10)).toBeAroundValue(-1);
      done();
    }, 200);
  });

  it('should hide editor when quick navigation by click scrollbar was triggered', function (done) {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(50, 50),
      rowHeaders: true,
      colHeaders: true
    });

    setDataAtCell(2, 2, 'string\nstring\nstring');
    selectCell(2, 2);

    keyDown('enter');
    keyUp('enter');
    hot.scrollViewportTo(49);

    setTimeout(function () {
      expect(hot.getActiveEditor().textareaParentStyle.display).toBe('none');
      done();
    }, 100);
  });

  it('should render textarea editor in specified height (single line)', function (done) {
    var hot = handsontable(),
        editorHeight;

    setDataAtCell(2, 2, 'first line');
    selectCell(2, 2);

    keyDown('enter');

    setTimeout(function () {
      expect(hot.getActiveEditor().TEXTAREA.style.height).toBe('23px');
      done();
    }, 200);
  });

  it('should render textarea editor in specified height (multi line)', function (done) {
    var hot = handsontable(),
        editorHeight;

    setDataAtCell(2, 2, 'first line\n second line\n third line...');
    selectCell(2, 2);

    keyDown('enter');

    setTimeout(function () {
      expect(hot.getActiveEditor().TEXTAREA.style.height).toBe('64px');
      done();
    }, 200);
  });

  it('should render number in textarea', function () {
    handsontable();
    setDataAtCell(2, 2, 13);
    selectCell(2, 2);

    keyDown('enter');

    expect(keyProxy().val()).toEqual('13');
  });

  it('should render boolean true in textarea', function () {
    handsontable();
    setDataAtCell(2, 2, true);
    selectCell(2, 2);

    keyDown('enter');

    expect(keyProxy().val()).toEqual('true');
  });

  it('should render boolean false in textarea', function () {
    handsontable();
    setDataAtCell(2, 2, false);
    selectCell(2, 2);

    keyDown('enter');

    expect(keyProxy().val()).toEqual('false');
  });

  it('should render null in textarea', function () {
    handsontable();
    setDataAtCell(2, 2, null);
    selectCell(2, 2);

    keyDown('enter');

    expect(keyProxy().val()).toEqual('');
  });

  it('should render undefined in textarea', function () {
    handsontable();
    setDataAtCell(2, 2, void 0);
    selectCell(2, 2);

    keyDown('enter');

    expect(keyProxy().val()).toEqual('');
  });

  it('should render nested object value in textarea', function () {
    handsontable({
      data: [{
        name: {
          first: 'Tom',
          last: 'Kowalski',
          obj: {}
        }
      }, {
        name: {
          first: 'John',
          last: 'Cage',
          obj: {
            foo: 'bar'
          }
        }
      }],
      columns: [{
        data: 'name.last'
      }, {
        data: 'name.obj.foo'
      }]
    });
    selectCell(0, 0);
    keyDown('enter');

    expect(keyProxy().val()).toEqual('Kowalski');

    selectCell(1, 1);
    keyDown('enter');

    expect(keyProxy().val()).toEqual('bar');
  });

  it('should render nested object value in textarea after change rows order', function () {
    var hot = handsontable({
      data: [{
        name: {
          first: 'Tom',
          last: 'Kowalski',
          obj: {}
        }
      }, {
        name: {
          first: 'John',
          last: 'Cage',
          obj: {
            foo: 'bar'
          }
        }
      }],
      columns: [{
        data: 'name.last'
      }, {
        data: 'name.obj.foo'
      }],
      manualRowMove: true
    });

    hot.getPlugin('manualRowMove').moveRow(1, 0);
    hot.render();

    selectCell(0, 0);
    keyDown('enter');
    expect(keyProxy().val()).toEqual('Cage');
    keyDown('enter');

    expect(hot.getDataAtCell(0, 0)).toEqual('Cage');

    selectCell(1, 1);
    keyDown('enter');
    expect(keyProxy().val()).toEqual('');
    keyDown('enter');

    expect(hot.getDataAtCell(1, 1)).toEqual('');
  });

  it('should render nested object value in textarea after change columns order', function () {
    var hot = handsontable({
      data: [{
        name: {
          first: 'Tom',
          last: 'Kowalski',
          obj: {}
        }
      }, {
        name: {
          first: 'John',
          last: 'Cage',
          obj: {
            foo: 'bar'
          }
        }
      }],
      columns: [{
        data: 'name.last'
      }, {
        data: 'name.obj.foo'
      }],
      manualColumnMove: true
    });

    hot.getPlugin('manualColumnMove').moveColumn(1, 0);
    hot.render();

    selectCell(0, 0);
    keyDown('enter');
    expect(keyProxy().val()).toEqual('');
    keyDown('enter');

    expect(hot.getDataAtCell(0, 0)).toEqual('');

    selectCell(1, 1);
    keyDown('enter');
    expect(keyProxy().val()).toEqual('Cage');
    keyDown('enter');

    expect(hot.getDataAtCell(1, 1)).toEqual('Cage');
  });

  it('should render array value defined by columns settings in textarea', function () {
    handsontable({
      data: [['', 'Kia'], ['2012', 10], ['2013', 10]],
      columns: [{
        data: '1'
      }, {
        data: '0'
      }]
    });
    selectCell(0, 0);
    keyDown('enter');

    expect(keyProxy().val()).toEqual('Kia');

    selectCell(1, 1);
    keyDown('enter');

    expect(keyProxy().val()).toEqual('2012');
  });

  it('should open editor after hitting F2', function () {
    handsontable();
    selectCell(2, 2);

    var editor = $('.handsontableInput');
    expect(isEditorVisible()).toEqual(false);
    keyDown('f2');
    expect(isEditorVisible()).toEqual(true);
  });

  it('should close editor after hitting ESC', function () {
    handsontable();
    selectCell(2, 2);

    var editor = $('.handsontableInput');
    expect(isEditorVisible()).toEqual(false);
    keyDown('f2');
    expect(isEditorVisible()).toEqual(true);
    keyDown('esc');
    expect(isEditorVisible()).toEqual(false);
  });

  it('should NOT open editor after hitting CapsLock', function () {
    handsontable();
    selectCell(2, 2);

    var editor = $('.handsontableInput');
    expect(isEditorVisible()).toEqual(false);
    keyDown(Handsontable.helper.KEY_CODES.CAPS_LOCK);
    expect(isEditorVisible()).toEqual(false);
  });

  it('should open editor after cancelling edit and beginning it again', function () {
    handsontable();
    selectCell(2, 2);

    expect(isEditorVisible()).toEqual(false);
    keyDown('f2');
    expect(isEditorVisible()).toEqual(true);
    keyDown('esc');
    expect(isEditorVisible()).toEqual(false);
    keyDown('f2');
    expect(isEditorVisible()).toEqual(true);
  });

  it('loadData should not destroy editor', function () {
    handsontable();
    selectCell(2, 2);

    keyDown('f2');
    loadData(getData());

    expect(isEditorVisible()).toEqual(true);
  });

  it('updateSettings should not destroy editor', function () {
    handsontable();
    selectCell(2, 2);

    keyDown('f2');
    updateSettings({
      data: getData()
    });

    expect(isEditorVisible()).toEqual(true);
  });

  it('textarea should have cell dimensions (after render)', function () {
    var data = [['a', 'b'], ['c', 'd']];

    var hot = handsontable({
      data: data,
      minRows: 4,
      minCols: 4,
      minSpareRows: 4,
      minSpareCols: 4,
      enterMoves: false
    });

    selectCell(1, 1);
    var $td = getHtCore().find('tbody tr:eq(1) td:eq(1)');
    var editor = hot.getActiveEditor();
    keyDownUp('enter');
    expect(keyProxy().width()).toEqual($td.width());
    keyDownUp('enter');
    data[1][1] = 'dddddddddddddddddddd';
    render();
    keyDownUp('enter');

    expect(keyProxy().width()).toEqual($td.width());
  });

  it('global shortcuts (like CTRL+A) should be blocked when cell is being edited', function () {
    handsontable();
    selectCell(2, 2);

    keyDownUp('enter');

    keyDown(65, {
      ctrlKey: true
    }); // CTRL+A should NOT select all table when cell is edited

    var selection = getSelected();
    expect(selection).toEqual([2, 2, 2, 2]);
    expect(isEditorVisible()).toEqual(true);
  });

  it('should open editor after double clicking on a cell', function (done) {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(5, 2)
    });

    var cell = $(getCell(0, 0));
    var clicks = 0;

    window.scrollTo(0, cell.offset().top);

    setTimeout(function () {
      mouseDown(cell);
      mouseUp(cell);
      clicks++;
    }, 0);

    setTimeout(function () {
      mouseDown(cell);
      mouseUp(cell);
      clicks++;
    }, 100);

    setTimeout(function () {
      var editor = hot.getActiveEditor();

      expect(clicks).toBe(2);
      expect(editor.isOpened()).toBe(true);
      expect(editor.isInFullEditMode()).toBe(true);
      done();
    }, 200);
  });

  it('should call editor focus() method after opening an editor', function () {
    var hot = handsontable();
    selectCell(2, 2);

    var editor = hot.getActiveEditor();

    spyOn(editor, 'focus');

    expect(editor.isOpened()).toEqual(false);
    expect(editor.focus).not.toHaveBeenCalled();
    keyDown('f2');
    expect(editor.isOpened()).toEqual(true);
    expect(editor.focus).toHaveBeenCalled();
  });

  it('editor size should not exceed the viewport after text edit', function () {

    handsontable({
      data: Handsontable.helper.createSpreadsheetData(10, 5),
      width: 200,
      height: 200
    });

    selectCell(2, 2);

    keyDown('enter');

    expect(isEditorVisible()).toEqual(true);

    document.activeElement.value = 'Very very very very very very very very very very very very very very very very very long text';
    keyDownUp(32); // space - trigger textarea resize

    var $textarea = $(document.activeElement);
    var $wtHider = this.$container.find('.wtHider');

    expect($textarea.offset().left + $textarea.outerWidth()).not.toBeGreaterThan($wtHider.offset().left + this.$container.outerWidth());
    expect($textarea.offset().top + $textarea.outerHeight()).not.toBeGreaterThan($wtHider.offset().top + $wtHider.outerHeight());
  });

  it('should open editor after selecting cell in another table and hitting enter', function () {
    this.$container2 = $('<div id="' + id + '-2"></div>').appendTo('body');

    var hot1 = handsontable();
    var hot2 = handsontable2.call(this);

    this.$container.find('tbody tr:eq(0) td:eq(0)').simulate('mousedown');
    this.$container.find('tbody tr:eq(0) td:eq(0)').simulate('mouseup');

    // Open editor in HOT1
    keyDown('enter');
    var editor = $('.handsontableInputHolder');
    expect(editor.is(':visible')).toBe(true);

    // Close editor in HOT1
    keyDown('enter');
    expect(editor.is(':visible')).toBe(false);

    this.$container2.find('tbody tr:eq(0) td:eq(0)').simulate('mousedown');
    this.$container2.find('tbody tr:eq(0) td:eq(0)').simulate('mouseup');

    expect(hot1.getSelected()).toBeUndefined();
    expect(hot2.getSelected()).toEqual([0, 0, 0, 0]);

    // Open editor in HOT2
    keyDown('enter');
    editor = $('.handsontableInputHolder');
    expect(editor.is(':visible')).toBe(true);

    this.$container2.handsontable('destroy');
    this.$container2.remove();

    function handsontable2(options) {
      var container = this.$container2;
      container.handsontable(options);
      container[0].focus(); // otherwise TextEditor tests do not pass in IE8
      return container.data('handsontable');
    }
  });

  it('should open editor after pressing a printable character', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(3, 3)
    });

    selectCell(0, 0);

    var editorHolder = $('.handsontableInputHolder');
    //    var editorInput = editorHolder.find('.handsontableInput');

    expect(editorHolder.is(':visible')).toBe(false);

    //    var keyboardEvent = $.Event('keydown', {
    //      keyCode: 'a'.charCodeAt(0)
    //    });

    //    this.$container.trigger(keyboardEvent);

    this.$container.simulate('keydown', {
      keyCode: 'a'.charCodeAt(0)
    });

    expect(editorHolder.is(':visible')).toBe(true);
  });

  it('should open editor after pressing a printable character with shift key', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(3, 3)
    });

    selectCell(0, 0);

    var editorHolder = $('.handsontableInputHolder');

    expect(editorHolder.is(':visible')).toBe(false);

    /**
     * To reliably mimic SHIFT+SOME_KEY combination we have to trigger two events.
     * First we need to trigger keydown event with SHIFT keyCode (16)
     * and then trigger a keydown event with keyCode of SOME_KEY and shiftKey property set to true
     */
    //    var shiftKeyboardEvent = $.Event('keydown', {
    //      keyCode: 16, //shift
    //      shiftKey: true
    //    });
    //
    //    var keyboardEvent = $.Event('keydown', {
    //      keyCode: 'a'.charCodeAt(0),
    //      shiftKey: true
    //    });

    this.$container.simulate('keydown', {
      keyCode: 'a'.charCodeAt(0),
      shiftKey: true
    });

    //    this.$container.trigger(shiftKeyboardEvent);
    //    this.$container.trigger(keyboardEvent);

    expect(editorHolder.is(':visible')).toBe(true);
  });

  it('should be able to open editor after clearing cell data with DELETE', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(3, 3)
    });

    selectCell(0, 0);

    var editorHolder = $('.handsontableInputHolder');

    expect(editorHolder.is(':visible')).toBe(false);

    this.$container.simulate('keydown', {
      keyCode: 46
    });

    this.$container.simulate('keydown', {
      keyCode: 'a'.charCodeAt(0)
    });
    expect(editorHolder.is(':visible')).toBe(true);
  });

  it('should be able to open editor after clearing cell data with BACKSPACE', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(3, 3)
    });

    selectCell(0, 0);

    var editorHolder = $('.handsontableInputHolder');

    expect(editorHolder.is(':visible')).toBe(false);

    this.$container.simulate('keydown', {
      keyCode: 8 // backspace
    });

    this.$container.simulate('keydown', {
      keyCode: 'a'.charCodeAt(0)
    });

    expect(editorHolder.is(':visible')).toBe(true);
  });

  it('should scroll editor to a cell, if trying to edit cell that is outside of the viewport', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(20, 20),
      width: 100,
      height: 50
    });

    selectCell(0, 0);

    expect(getCell(0, 0)).not.toBeNull();
    expect(getCell(19, 19)).toBeNull();

    hot.view.scrollViewport({ row: 19, col: 19 });
    hot.render();

    expect(getCell(0, 0)).toBeNull();
    expect(getCell(19, 19)).not.toBeNull();

    keyDown('enter');

    expect(getCell(0, 0)).not.toBeNull();
    expect(getCell(19, 19)).toBeNull();
  });

  it('should open empty editor after clearing cell value width BACKSPACE', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(4, 4)
    });

    expect(getDataAtCell(0, 0)).toEqual('A1');

    selectCell(0, 0);

    keyDown(Handsontable.helper.KEY_CODES.BACKSPACE);

    expect(getDataAtCell(0, 0)).toEqual('');
    expect(hot.getActiveEditor().isOpened()).toBe(false);

    keyDown(Handsontable.helper.KEY_CODES.ENTER);

    expect(hot.getActiveEditor().isOpened()).toBe(true);
    expect(hot.getActiveEditor().getValue()).toEqual('');
  });

  it('should open empty editor after clearing cell value width DELETE', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(4, 4)
    });

    expect(getDataAtCell(0, 0)).toEqual('A1');

    selectCell(0, 0);

    keyDown(Handsontable.helper.KEY_CODES.DELETE);

    expect(getDataAtCell(0, 0)).toEqual('');
    expect(hot.getActiveEditor().isOpened()).toBe(false);

    keyDown(Handsontable.helper.KEY_CODES.ENTER);

    expect(hot.getActiveEditor().isOpened()).toBe(true);
    expect(hot.getActiveEditor().getValue()).toEqual('');
  });

  it('should not open editor after hitting ALT (#1239)', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(4, 4)
    });

    expect(getDataAtCell(0, 0)).toEqual('A1');

    selectCell(0, 0);

    keyDown(Handsontable.helper.KEY_CODES.ALT);

    expect(hot.getActiveEditor().isOpened()).toBe(false);
  });

  it('should open editor at the same coordinates as the edited cell', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(16, 8),
      fixedColumnsLeft: 2,
      fixedRowsTop: 2
    });

    var mainHolder = hot.view.wt.wtTable.holder;

    // corner
    selectCell(1, 1);
    keyDown(Handsontable.helper.KEY_CODES.ENTER);
    var $inputHolder = $('.handsontableInputHolder');
    expect($(getCell(1, 1)).offset().left).toEqual($inputHolder.offset().left + 1);
    expect($(getCell(1, 1)).offset().top).toEqual($inputHolder.offset().top + 1);

    // top
    selectCell(1, 4);
    keyDown(Handsontable.helper.KEY_CODES.ENTER);
    expect($(getCell(1, 4)).offset().left).toEqual($inputHolder.offset().left + 1);
    expect($(getCell(1, 4)).offset().top).toEqual($inputHolder.offset().top + 1);

    // left
    selectCell(4, 1);
    keyDown(Handsontable.helper.KEY_CODES.ENTER);
    expect($(getCell(4, 1)).offset().left).toEqual($inputHolder.offset().left + 1);
    expect($(getCell(4, 1)).offset().top).toEqual($inputHolder.offset().top + 1);

    // non-fixed
    selectCell(4, 4);
    keyDown(Handsontable.helper.KEY_CODES.ENTER);
    expect($(getCell(4, 4)).offset().left).toEqual($inputHolder.offset().left + 1);
    expect($(getCell(4, 4)).offset().top).toEqual($inputHolder.offset().top + 1);

    $(mainHolder).scrollTop(1000);
  });

  it('should open editor at the same coordinates as the edited cell after the table had been scrolled (corner)', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(16, 8),
      fixedColumnsLeft: 2,
      fixedRowsTop: 2
    });

    var $holder = $(hot.view.wt.wtTable.holder);

    $holder.scrollTop(100);
    $holder.scrollLeft(100);

    hot.render();

    // corner
    selectCell(1, 1);
    var currentCell = hot.getCell(1, 1, true);
    var left = $(currentCell).offset().left;
    var top = $(currentCell).offset().top;

    var $inputHolder = $('.handsontableInputHolder');
    keyDown(Handsontable.helper.KEY_CODES.ENTER);
    expect(left).toEqual($inputHolder.offset().left + 1);
    expect(top).toEqual($inputHolder.offset().top + 1);
  });

  it('should open editor at the same coordinates as the edited cell after the table had been scrolled (top)', function (done) {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(50, 50),
      fixedColumnsLeft: 2,
      fixedRowsTop: 2
    });

    var $holder = $(hot.view.wt.wtTable.holder);

    $holder[0].scrollTop = 500;

    setTimeout(function () {
      $holder[0].scrollLeft = 500;
    }, 100);

    setTimeout(function () {
      // top
      selectCell(1, 6);
    }, 200);

    setTimeout(function () {
      var currentCell = hot.getCell(1, 6, true);
      var left = $(currentCell).offset().left;
      var top = $(currentCell).offset().top;

      var $inputHolder = $('.handsontableInputHolder');
      keyDown(Handsontable.helper.KEY_CODES.ENTER);
      expect(left).toEqual($inputHolder.offset().left + 1);
      expect(top).toEqual($inputHolder.offset().top + 1);
      done();
    }, 300);
  });

  it('should open editor at the same coordinates as the edited cell after the table had been scrolled (left)', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(50, 50),
      fixedColumnsLeft: 2,
      fixedRowsTop: 2
    });

    var $holder = $(hot.view.wt.wtTable.holder);

    $holder.scrollTop(500);
    $holder.scrollLeft(500);

    hot.render();

    // left
    selectCell(6, 1);
    var currentCell = hot.getCell(6, 1, true);
    var left = $(currentCell).offset().left;
    var top = $(currentCell).offset().top;

    var $inputHolder = $('.handsontableInputHolder');
    keyDown(Handsontable.helper.KEY_CODES.ENTER);
    expect(left).toEqual($inputHolder.offset().left + 1);
    expect(top).toEqual($inputHolder.offset().top + 1);
  });

  it('should open editor at the same coordinates as the edited cell after the table had been scrolled (non-fixed)', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(50, 50),
      fixedColumnsLeft: 2,
      fixedRowsTop: 2
    });

    var $holder = $(hot.view.wt.wtTable.holder);

    $holder.scrollTop(500);
    $holder.scrollLeft(500);

    hot.render();

    // non-fixed
    selectCell(7, 7);
    var currentCell = hot.getCell(7, 7, true);
    var left = $(currentCell).offset().left;
    var top = $(currentCell).offset().top;

    var $inputHolder = $('.handsontableInputHolder');
    keyDown(Handsontable.helper.KEY_CODES.ENTER);
    expect(left).toEqual($inputHolder.offset().left + 1);
    expect(top).toEqual($inputHolder.offset().top + 1);
  });

  it('should display editor with the proper size, when the edited column is beyond the tables container', function () {
    this.$container.css('overflow', '');
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(3, 9)
    });

    selectCell(0, 7);
    keyDown(Handsontable.helper.KEY_CODES.ENTER);

    expect(Handsontable.dom.outerWidth(hot.getActiveEditor().TEXTAREA)).toBeAroundValue(Handsontable.dom.outerWidth(hot.getCell(0, 7)));
  });

  it('should display editor with the proper size, when editing a last row after the table is scrolled to the bottom', function () {
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(3, 8),
      minSpareRows: 1,
      height: 100
    });

    selectCell(0, 2);
    keyDown(Handsontable.helper.KEY_CODES.ENTER);
    var regularHeight = Handsontable.dom.outerHeight(hot.getActiveEditor().TEXTAREA);

    selectCell(3, 2);
    keyDown(Handsontable.helper.KEY_CODES.ENTER);
    keyDown(Handsontable.helper.KEY_CODES.ENTER);
    keyDown(Handsontable.helper.KEY_CODES.ENTER);

    // lame check, needs investigating why sometimes it leaves 2px error
    if (Handsontable.dom.outerHeight(hot.getActiveEditor().TEXTAREA) == regularHeight) {
      expect(Handsontable.dom.outerHeight(hot.getActiveEditor().TEXTAREA)).toEqual(regularHeight);
    } else {
      expect(Handsontable.dom.outerHeight(hot.getActiveEditor().TEXTAREA)).toEqual(regularHeight - 2);
    }
  });

  it('should render the text without trimming out the whitespace, if trimWhitespace is set to false', function () {
    this.$container.css('overflow', '');
    var hot = handsontable({
      data: Handsontable.helper.createSpreadsheetData(3, 9),
      trimWhitespace: false
    });

    selectCell(0, 2);
    keyDown(Handsontable.helper.KEY_CODES.ENTER);
    hot.getActiveEditor().TEXTAREA.value = '       test    of    whitespace      ';
    keyDown(Handsontable.helper.KEY_CODES.ENTER);

    expect(getDataAtCell(0, 2).length).toEqual(37);
  });

  it('should insert new line on caret position when pressing ALT + ENTER', function () {
    var data = [['Maserati', 'Mazda'], ['Honda', 'Mini']];

    var hot = handsontable({
      data: data
    });

    selectCell(0, 0);
    keyDown(Handsontable.helper.KEY_CODES.ENTER);

    var $editorInput = $('.handsontableInput');

    Handsontable.dom.setCaretPosition($editorInput[0], 2);

    $editorInput.simulate('keydown', {
      altKey: true,
      keyCode: Handsontable.helper.KEY_CODES.ENTER
    });

    expect(hot.getActiveEditor().TEXTAREA.value).toEqual('Ma\nserati');
  });

  it('should be displayed and resized properly, so it doesn\'t exceed the viewport dimensions', function () {
    var data = [['', '', '', '', ''], ['', 'The Dude abides. I don\'t know about you but I take comfort in that. It\'s good knowin\' he\'s out there. The ' + 'Dude. Takin\' \'er easy for all us sinners. Shoosh. I sure hope he makes the finals.', '', '', ''], ['', '', '', '', '']];

    var hot = handsontable({
      data: data,
      colWidths: 40,
      width: 300,
      height: 200,
      minSpareRows: 20,
      minSpareCols: 20
    });

    selectCell(1, 1);
    keyDown(Handsontable.helper.KEY_CODES.ENTER);

    var $editorInput = $('.handsontableInput');
    var $editedCell = $(hot.getCell(1, 1));

    expect($editorInput.outerWidth()).toEqual(hot.view.wt.wtTable.holder.clientWidth - $editedCell.position().left + 1);

    hot.view.wt.scrollHorizontal(3);
    hot.render();

    expect($editorInput.width() + $editorInput.offset().left).toBeLessThan(hot.view.wt.wtTable.holder.clientWidth);
  });

  it('should resize editor to properly size after focus', function (done) {
    var data = [['', '', '', '', '', '', '', '', '', '', ''], ['', '', '', '', '', '', '', '', '', '', ''], ['', '', '', '', '', '', '', '', '', '', ''], ['', '', '', '', '', '', '', '', '', '', ''], ['', '', '', '', '', '', '', '', '', '', 'sadiasdoadoajdoasjdoij doi ajdoiasjdasoidasoid'], ['', '', '', '', '', '', '', '', '', '', ''], ['', '', '', '', '', '', '', '', '', '', ''], ['', '', '', '', '', '', '', '', '', '', ''], ['', '', '', '', '', '', '', '', '', '', ''], ['', '', '', '', '', '', '', '', '', '', '']];
    var hot = handsontable({
      data: data,
      colWidths: 40,
      rowHeights: 25,
      width: 500,
      height: 220
    });

    selectCell(4, 10);
    keyDown(Handsontable.helper.KEY_CODES.ENTER);

    var $editorInput = $('.handsontableInput');

    setTimeout(function () {
      expect([105, 119]).toEqual(jasmine.arrayContaining([$editorInput.height()]));
      done();
    }, 150);
  });
});

/***/ }),
/* 216 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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; };

__webpack_require__(85);

__webpack_require__(102);

__webpack_require__(111);

__webpack_require__(112);

__webpack_require__(96);

__webpack_require__(110);

__webpack_require__(93);

__webpack_require__(94);

__webpack_require__(95);

__webpack_require__(84);

__webpack_require__(107);

__webpack_require__(105);

__webpack_require__(103);

__webpack_require__(108);

__webpack_require__(109);

__webpack_require__(104);

__webpack_require__(106);

__webpack_require__(97);

__webpack_require__(98);

__webpack_require__(99);

__webpack_require__(101);

__webpack_require__(100);

__webpack_require__(82);

__webpack_require__(83);

__webpack_require__(78);

__webpack_require__(81);

__webpack_require__(80);

__webpack_require__(79);

__webpack_require__(51);

__webpack_require__(87);

__webpack_require__(88);

__webpack_require__(90);

__webpack_require__(89);

__webpack_require__(86);

__webpack_require__(92);

__webpack_require__(91);

__webpack_require__(113);

__webpack_require__(116);

__webpack_require__(114);

__webpack_require__(115);

__webpack_require__(118);

__webpack_require__(117);

__webpack_require__(120);

__webpack_require__(119);

__webpack_require__(122);

__webpack_require__(121).install();

var regExp = new RegExp( false ? __ENV_ARGS__.testPathPattern : '.*', 'i');

[__webpack_require__(124), __webpack_require__(123)].forEach(function (req) {
  req.keys().forEach(function (key) {
    if (regExp.test(key)) {
      req(key);
    }
  });
});

__webpack_require__(75);

/***/ }),
/* 217 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('Public API', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  describe('Plugins', function () {
    it('should expose static method for registering external plugins', function () {
      expect(Handsontable.plugins.registerPlugin).toBeFunction();
    });

    it('should expose BasePlugin class', function () {
      expect(Handsontable.plugins.BasePlugin).toBeFunction();
    });

    it('should expose all registered plugin classes', function () {
      expect(Handsontable.plugins.AutoColumnSize).toBeFunction();
      expect(Handsontable.plugins.AutoRowSize).toBeFunction();
      expect(Handsontable.plugins.ColumnSorting).toBeFunction();
      expect(Handsontable.plugins.Comments).toBeFunction();
      expect(Handsontable.plugins.ContextMenu).toBeFunction();
      expect(Handsontable.plugins.ContextMenuCopyPaste).toBeFunction();
      expect(Handsontable.plugins.DragToScroll).toBeFunction();
      expect(Handsontable.plugins.ManualColumnFreeze).toBeFunction();
      expect(Handsontable.plugins.ManualColumnResize).toBeFunction();
      expect(Handsontable.plugins.ManualRowResize).toBeFunction();
      expect(Handsontable.plugins.MultipleSelectionHandles).toBeFunction();
      expect(Handsontable.plugins.TouchScroll).toBeFunction();
    });
  });

  describe('Editors', function () {
    it('should expose static method for registering external editors', function () {
      expect(Handsontable.editors.registerEditor).toBeFunction();
    });

    it('should expose static method for retrieving registered editors', function () {
      expect(Handsontable.editors.getEditor).toBeFunction();
    });

    it('should expose BaseEditor class', function () {
      expect(Handsontable.editors.BaseEditor).toBeFunction();
    });

    it('should expose all registered editor classes', function () {
      expect(Handsontable.editors.AutocompleteEditor).toBeFunction();
      expect(Handsontable.editors.CheckboxEditor).toBeFunction();
      expect(Handsontable.editors.DateEditor).toBeFunction();
      expect(Handsontable.editors.DropdownEditor).toBeFunction();
      expect(Handsontable.editors.HandsontableEditor).toBeFunction();
      expect(Handsontable.editors.MobileEditor).toBeFunction();
      expect(Handsontable.editors.NumericEditor).toBeFunction();
      expect(Handsontable.editors.PasswordEditor).toBeFunction();
      expect(Handsontable.editors.SelectEditor).toBeFunction();
      expect(Handsontable.editors.TextEditor).toBeFunction();
    });
  });

  describe('Renderers', function () {
    it('should expose static method for registering external renderers', function () {
      expect(Handsontable.renderers.registerRenderer).toBeFunction();
    });

    it('should expose static method for retrieving registered renderers', function () {
      expect(Handsontable.renderers.getRenderer).toBeFunction();
    });

    it('should expose BaseRenderer class', function () {
      expect(Handsontable.renderers.BaseRenderer).toBeFunction();
    });

    it('should expose all registered renderer functions', function () {
      expect(Handsontable.renderers.AutocompleteRenderer).toBeFunction();
      expect(Handsontable.renderers.CheckboxRenderer).toBeFunction();
      expect(Handsontable.renderers.HtmlRenderer).toBeFunction();
      expect(Handsontable.renderers.NumericRenderer).toBeFunction();
      expect(Handsontable.renderers.PasswordRenderer).toBeFunction();
      expect(Handsontable.renderers.TextRenderer).toBeFunction();
    });
  });

  describe('Validators', function () {
    it('should expose static method for registering external validators', function () {
      expect(Handsontable.validators.registerValidator).toBeFunction();
    });

    it('should expose static method for retrieving registered validators', function () {
      expect(Handsontable.validators.getValidator).toBeFunction();
    });

    it('should expose all registered validator functions', function () {
      expect(Handsontable.validators.AutocompleteValidator).toBeFunction();
      expect(Handsontable.validators.DateValidator).toBeFunction();
      expect(Handsontable.validators.NumericValidator).toBeFunction();
      expect(Handsontable.validators.TimeValidator).toBeFunction();
    });
  });

  describe('CellTypes', function () {
    it('should expose static method for registering external cell types', function () {
      expect(Handsontable.cellTypes.registerCellType).toBeFunction();
    });

    it('should expose static method for retrieving registered cell types', function () {
      expect(Handsontable.cellTypes.getCellType).toBeFunction();
    });

    it('should expose all registered cell type objects', function () {
      expect(Handsontable.cellTypes.autocomplete.editor).toBe(Handsontable.editors.AutocompleteEditor);
      expect(Handsontable.cellTypes.autocomplete.renderer).toBe(Handsontable.renderers.AutocompleteRenderer);
      expect(Handsontable.cellTypes.autocomplete.validator).toBe(Handsontable.validators.AutocompleteValidator);

      expect(Handsontable.cellTypes.checkbox.editor).toBe(Handsontable.editors.CheckboxEditor);
      expect(Handsontable.cellTypes.checkbox.renderer).toBe(Handsontable.renderers.CheckboxRenderer);
      expect(Handsontable.cellTypes.checkbox.validator).not.toBeDefined();

      expect(Handsontable.cellTypes.date.editor).toBe(Handsontable.editors.DateEditor);
      expect(Handsontable.cellTypes.date.renderer).toBe(Handsontable.renderers.AutocompleteRenderer);
      expect(Handsontable.cellTypes.date.validator).toBe(Handsontable.validators.DateValidator);

      expect(Handsontable.cellTypes.dropdown.editor).toBe(Handsontable.editors.DropdownEditor);
      expect(Handsontable.cellTypes.dropdown.renderer).toBe(Handsontable.renderers.AutocompleteRenderer);
      expect(Handsontable.cellTypes.dropdown.validator).toBe(Handsontable.validators.AutocompleteValidator);

      expect(Handsontable.cellTypes.handsontable.editor).toBe(Handsontable.editors.HandsontableEditor);
      expect(Handsontable.cellTypes.handsontable.renderer).toBe(Handsontable.renderers.AutocompleteRenderer);
      expect(Handsontable.cellTypes.handsontable.validator).not.toBeDefined();

      expect(Handsontable.cellTypes.numeric.editor).toBe(Handsontable.editors.NumericEditor);
      expect(Handsontable.cellTypes.numeric.renderer).toBe(Handsontable.renderers.NumericRenderer);
      expect(Handsontable.cellTypes.numeric.validator).toBe(Handsontable.validators.NumericValidator);

      expect(Handsontable.cellTypes.password.editor).toBe(Handsontable.editors.PasswordEditor);
      expect(Handsontable.cellTypes.password.renderer).toBe(Handsontable.renderers.PasswordRenderer);
      expect(Handsontable.cellTypes.password.validator).not.toBeDefined();

      expect(Handsontable.cellTypes.text.editor).toBe(Handsontable.editors.TextEditor);
      expect(Handsontable.cellTypes.text.renderer).toBe(Handsontable.renderers.TextRenderer);
      expect(Handsontable.cellTypes.text.validator).not.toBeDefined();

      expect(Handsontable.cellTypes.time.editor).toBe(Handsontable.editors.TextEditor);
      expect(Handsontable.cellTypes.time.renderer).toBe(Handsontable.renderers.TextRenderer);
      expect(Handsontable.cellTypes.time.validator).toBe(Handsontable.validators.TimeValidator);
    });
  });
});

/***/ }),
/* 218 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('AutocompleteRenderer', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should contain down arrow glyph', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      type: 'autocomplete',
      afterValidate: onAfterValidate
    });
    setDataAtCell(2, 2, 'string');

    setTimeout(function () {
      var html = getCell(2, 2).innerHTML;

      expect(html).toContain('string');
      expect(html).toContain('\u25BC');
      done();
    }, 100);
  });

  it('should open cell editor after clicking on arrow glyph', function () {
    var hot = handsontable({
      type: 'autocomplete'
    });

    selectCell(0, 0);

    expect(hot.getActiveEditor().isOpened()).toBe(false);

    $(getCell(0, 0)).find('.htAutocompleteArrow').simulate('mousedown');

    expect(hot.getActiveEditor().isOpened()).toBe(true);
  });

  it('should open cell editor after clicking on arrow glyph, after the table has been destroyed and reinitialized (#1367)', function () {
    var hot = handsontable({
      type: 'autocomplete'
    });

    destroy();

    hot = handsontable({
      type: 'autocomplete'
    });

    selectCell(0, 0);

    expect(hot.getActiveEditor().isOpened()).toBe(false);

    $(getCell(0, 0)).find('.htAutocompleteArrow').simulate('mousedown');

    expect(hot.getActiveEditor().isOpened()).toBe(true);
  });
});

/***/ }),
/* 219 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('CellDecorator', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  var arrayOfObjects = function arrayOfObjects() {
    return [{ id: 1, name: 'Ted', lastName: 'Right' }, { id: 2, name: 'Frank', lastName: 'Honest' }, { id: 3, name: 'Joan', lastName: 'Well' }];
  };

  it('should add an appropriate class name to every cell, if wordWrap=false is set to the whole table', function () {
    var hot = handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id' }, { data: 'name' }, { data: 'lastName' }],
      wordWrap: false
    });

    var cols = countCols(),
        rows = countRows();

    for (var i = 0; i < cols; i++) {
      for (var j = 0; j < rows; j++) {
        expect($(getCell(i, j)).hasClass(hot.getSettings().noWordWrapClassName)).toBe(true);
      }
    }
  });

  it('should add an appropriate class name to every cell in a column, if wordWrap=false is set to the column settings', function () {
    var hot = handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id' }, { data: 'name', wordWrap: false }, { data: 'lastName' }]
    });

    var rows = countRows();

    for (var i = 0; i < rows; i++) {
      expect($(getCell(i, 1)).hasClass(hot.getSettings().noWordWrapClassName)).toBe(true);
    }

    for (var _i = 0; _i < rows; _i++) {
      expect($(getCell(_i, 0)).hasClass(hot.getSettings().noWordWrapClassName)).toBe(false); // no class added to other columns
      expect($(getCell(_i, 2)).hasClass(hot.getSettings().noWordWrapClassName)).toBe(false);
    }
  });

  it('should add an appropriate class to a cell, if wordWrap=false is set to a single cell', function () {
    var hot = handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id' }, { data: 'name' }, { data: 'lastName' }]
    });

    expect($(getCell(1, 1)).hasClass(hot.getSettings().noWordWrapClassName)).toBe(false);

    getCellMeta(1, 1).wordWrap = false;
    render();

    expect($(getCell(1, 1)).hasClass(hot.getSettings().noWordWrapClassName)).toBe(true);
  });

  it('should set "white-space" css parameter to "nowrap" if htNoWrap class is added to a cell', function () {
    var hot = handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id' }, { data: 'name' }, { data: 'lastName' }]
    });

    expect(window.getComputedStyle(getCell(1, 1)).whiteSpace).not.toEqual('nowrap');

    getCellMeta(1, 1).wordWrap = false;
    render();

    expect(window.getComputedStyle(getCell(1, 1)).whiteSpace).toEqual('nowrap');
  });

  it('should not add cell `htInvalid` class when trying to add not proper value', function (done) {
    var hot = handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id' }, { data: 'name' }, { data: 'salary', type: 'numeric', allowInvalid: false }]
    });

    setDataAtCell(0, 2, 'non-numeric value');

    setTimeout(function () {
      expect($(getCell(0, 2)).hasClass(hot.getSettings().invalidCellClassName)).toBe(false);
      done();
    }, 200);
  });
});

/***/ }),
/* 220 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('CheckboxRenderer', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '" style="width: 300px; height: 200px;"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should render values as checkboxes', function () {
    handsontable({
      data: [[true], [false], [true]],
      columns: [{ type: 'checkbox' }]
    });

    expect($(getRenderedValue(0, 0)).is(':checkbox')).toBe(true);
    expect($(getRenderedValue(1, 0)).is(':checkbox')).toBe(true);
    expect($(getRenderedValue(2, 0)).is(':checkbox')).toBe(true);
  });

  it('should render check checkboxes for cell which value is true', function () {
    handsontable({
      data: [[true], [false], [true]],
      columns: [{ type: 'checkbox' }]
    });

    expect($(getRenderedContent(0, 0)).prop('checked')).toBe(true);
    expect($(getRenderedContent(1, 0)).prop('checked')).toBe(false);
    expect($(getRenderedContent(2, 0)).prop('checked')).toBe(true);
  });

  it('should use templates to check appropriate checkboxes', function () {
    handsontable({
      data: [['yes'], ['no'], ['yes']],
      columns: [{
        type: 'checkbox',
        checkedTemplate: 'yes',
        uncheckedTemplate: 'no'
      }]
    });

    expect($(getRenderedContent(0, 0)).prop('checked')).toBe(true);
    expect($(getRenderedContent(1, 0)).prop('checked')).toBe(false);
    expect($(getRenderedContent(2, 0)).prop('checked')).toBe(true);
  });

  it('should select cell after checkbox click', function () {
    var hot = handsontable({
      data: [[true], [false], [true]],
      columns: [{ type: 'checkbox' }]
    });

    hot.selectCell(0, 0);

    this.$container.find(':checkbox').eq(2).simulate('mousedown');

    expect(hot.getSelected()).toEqual([2, 0, 2, 0]);
  });

  it('should select cell after label click', function () {
    var hot = handsontable({
      data: [[true], [false], [true]],
      columns: [{ type: 'checkbox', label: { position: 'before', value: 'Sure? ' } }]
    });

    hot.selectCell(0, 0);

    this.$container.find('td label').eq(2).simulate('mousedown');

    expect(hot.getSelected()).toEqual([2, 0, 2, 0]);
  });

  it('should reverse selection in checkboxes', function () {
    handsontable({
      data: [[true], [false], [true]],
      columns: [{ type: 'checkbox' }]
    });

    this.$container.find(':checkbox').eq(0).simulate('click');
    this.$container.find(':checkbox').eq(1).simulate('click');
    this.$container.find(':checkbox').eq(2).simulate('click');

    expect(getData()).toEqual([[false], [true], [false]]);
  });

  it('shouldn\'t uncheck checkboxes', function () {
    handsontable({
      data: [[true], [true], [true]],
      columns: [{ type: 'checkbox', readOnly: true }]
    });

    this.$container.find(':checkbox').trigger('click');

    expect(getData()).toEqual([[true], [true], [true]]);
  });

  it('should check single box after hitting space', function () {
    handsontable({
      data: [[true], [true], [true]],
      columns: [{ type: 'checkbox' }]
    });

    var afterChangeCallback = jasmine.createSpy('afterChangeCallback');
    addHook('afterChange', afterChangeCallback);

    var checkboxes = this.$container.find(':checkbox');

    expect(checkboxes.eq(0).prop('checked')).toBe(true);
    expect(checkboxes.eq(1).prop('checked')).toBe(true);
    expect(checkboxes.eq(2).prop('checked')).toBe(true);
    expect(getData()).toEqual([[true], [true], [true]]);

    selectCell(0, 0);

    //  this.$container.find(':checkbox').eq(0).simulate('click');
    //  this.$container.simulate('keydown',{
    //    keyCode: 32
    //  });
    keyDown('space');

    checkboxes = this.$container.find(':checkbox');

    expect(checkboxes.eq(0).prop('checked')).toBe(false);
    expect(checkboxes.eq(1).prop('checked')).toBe(true);
    expect(checkboxes.eq(2).prop('checked')).toBe(true);
    expect(getData()).toEqual([[false], [true], [true]]);
    expect(afterChangeCallback.calls.count()).toEqual(1);
    expect(afterChangeCallback).toHaveBeenCalledWith([[0, 0, true, false]], 'edit', undefined, undefined, undefined, undefined);
  });

  it('should not check single box after hitting space, if cell is readOnly', function () {
    handsontable({
      data: [[true], [true], [true]],
      columns: [{ type: 'checkbox', readOnly: true }]
    });

    var afterChangeCallback = jasmine.createSpy('afterChangeCallback');
    addHook('afterChange', afterChangeCallback);

    var checkboxes = this.$container.find(':checkbox');

    expect(checkboxes.eq(0).prop('checked')).toBe(true);
    expect(checkboxes.eq(1).prop('checked')).toBe(true);
    expect(checkboxes.eq(2).prop('checked')).toBe(true);
    expect(getData()).toEqual([[true], [true], [true]]);

    selectCell(0, 0);

    keyDown('space');

    checkboxes = this.$container.find(':checkbox');

    expect(checkboxes.eq(0).prop('checked')).toBe(true);
    expect(checkboxes.eq(1).prop('checked')).toBe(true);
    expect(checkboxes.eq(2).prop('checked')).toBe(true);
    expect(getData()).toEqual([[true], [true], [true]]);
    expect(afterChangeCallback).not.toHaveBeenCalled();
  });

  it('should not check single box after hitting space, if last column is readOnly (#3562)', function () {
    handsontable({
      data: [[true, true], [false, false], [true, true]],
      columns: [{ type: 'checkbox' }, { type: 'checkbox', readOnly: true }]
    });

    selectCell(0, 0);
    keyDown('space');
    selectCell(0, 1);
    keyDown('space');
    selectCell(1, 0);
    keyDown('space');
    selectCell(1, 1);
    keyDown('space');

    var checkboxes = this.$container.find(':checkbox');

    // column 0
    expect(checkboxes.eq(0).prop('checked')).toBe(false);
    expect(checkboxes.eq(2).prop('checked')).toBe(true);
    expect(checkboxes.eq(4).prop('checked')).toBe(true);

    // column 1
    expect(checkboxes.eq(1).prop('checked')).toBe(true);
    expect(checkboxes.eq(3).prop('checked')).toBe(false);
    expect(checkboxes.eq(5).prop('checked')).toBe(true);
    expect(getData()).toEqual([[false, true], [true, false], [true, true]]);
  });

  it('should change checkboxes values properly when data contains null or/and undefined', function () {
    handsontable({
      data: [[null], [undefined]],
      colHeaders: true,
      columns: [{
        type: 'checkbox'
      }]
    });

    selectCell(0, 0, 1, 0);
    keyDown('space');

    expect(getDataAtCol(0)).toEqual([true, true]);

    selectCell(0, 0, 1, 0);
    keyDown('space');

    expect(getDataAtCol(0)).toEqual([false, false]);
  });

  it('should change checkboxes values for cells below the viewport (hot initialized by startRows) #4037', function () {
    handsontable({
      startRows: 200,
      colHeaders: true,
      columns: [{
        type: 'checkbox'
      }]
    });

    selectCell(0, 0, 199, 0);
    keyDown('space');

    expect(getDataAtCell(199, 0)).toEqual(true);
  });

  it('should reverse checkboxes state after hitting space, when multiple cells are selected', function () {
    var hot = handsontable({
      data: [[true], [false], [true]],
      columns: [{ type: 'checkbox' }]
    });

    var afterChangeCallback = jasmine.createSpy('afterChangeCallback');
    addHook('afterChange', afterChangeCallback);

    var checkboxes = this.$container.find(':checkbox');

    expect(checkboxes.eq(0).prop('checked')).toBe(true);
    expect(checkboxes.eq(1).prop('checked')).toBe(false);
    expect(checkboxes.eq(2).prop('checked')).toBe(true);
    expect(getData()).toEqual([[true], [false], [true]]);

    selectCell(0, 0, 2, 0);

    keyDown('space');

    checkboxes = this.$container.find(':checkbox');

    expect(checkboxes.eq(0).prop('checked')).toBe(false);
    expect(checkboxes.eq(1).prop('checked')).toBe(true);
    expect(checkboxes.eq(2).prop('checked')).toBe(false);
    expect(getData()).toEqual([[false], [true], [false]]);
    expect(afterChangeCallback.calls.count()).toEqual(1);
    expect(afterChangeCallback).toHaveBeenCalledWith([[0, 0, true, false], [1, 0, false, true], [2, 0, true, false]], 'edit', undefined, undefined, undefined, undefined);
  });

  it('should reverse checkboxes state after hitting space, when multiple cells are selected and selStart > selEnd', function () {
    handsontable({
      data: [[true], [false], [true]],
      columns: [{ type: 'checkbox' }]
    });

    var afterChangeCallback = jasmine.createSpy('afterChangeCallback');
    addHook('afterChange', afterChangeCallback);

    var checkboxes = this.$container.find(':checkbox');

    expect(checkboxes.eq(0).prop('checked')).toBe(true);
    expect(checkboxes.eq(1).prop('checked')).toBe(false);
    expect(checkboxes.eq(2).prop('checked')).toBe(true);
    expect(getData()).toEqual([[true], [false], [true]]);

    selectCell(2, 0, 0, 0); // selStart = [2,0], selEnd = [0,0]

    keyDown('space');

    checkboxes = this.$container.find(':checkbox');

    expect(checkboxes.eq(0).prop('checked')).toBe(false);
    expect(checkboxes.eq(1).prop('checked')).toBe(true);
    expect(checkboxes.eq(2).prop('checked')).toBe(false);
    expect(getData()).toEqual([[false], [true], [false]]);
    expect(afterChangeCallback.calls.count()).toEqual(1);
    expect(afterChangeCallback).toHaveBeenCalledWith([[0, 0, true, false], [1, 0, false, true], [2, 0, true, false]], 'edit', undefined, undefined, undefined, undefined);
  });

  it('should open cell editors of cell that does not have checkboxRenderer (#1199)', function () {
    var hot = handsontable({
      data: [[true, 'B0'], [true, 'B1'], [true, 'B2']],
      columns: [{ type: 'checkbox' }, { type: 'text' }]
    });

    selectCell(0, 1);

    expect(hot.getActiveEditor().isOpened()).toBe(false);

    keyDown('space');

    expect(hot.getActiveEditor().isOpened()).toBe(true);
  });

  it('double click on checkbox cell should invert the value', function () {
    handsontable({
      data: [[true], [false], [true]],
      columns: [{ type: 'checkbox' }]
    });

    selectCell(0, 0);

    mouseDoubleClick(getCell(0, 0));
    expect(getDataAtCell(0, 0)).toBe(false);

    mouseDoubleClick(getCell(0, 0));
    expect(getDataAtCell(0, 0)).toBe(true);

    mouseDoubleClick(getCell(0, 0));
    expect(getDataAtCell(0, 0)).toBe(false);
  });

  it('should change checkbox state from checked to unchecked after hitting ENTER', function () {
    handsontable({
      data: [[true], [true], [true]],
      columns: [{ type: 'checkbox' }]
    });

    var afterChangeCallback = jasmine.createSpy('afterChangeCallback');
    addHook('afterChange', afterChangeCallback);

    var checkboxes = this.$container.find(':checkbox');

    expect(checkboxes.eq(0).prop('checked')).toBe(true);
    expect(checkboxes.eq(1).prop('checked')).toBe(true);
    expect(checkboxes.eq(2).prop('checked')).toBe(true);
    expect(getData()).toEqual([[true], [true], [true]]);

    selectCell(0, 0);

    keyDown('enter');

    checkboxes = this.$container.find(':checkbox');

    expect(checkboxes.eq(0).prop('checked')).toBe(false);
    expect(checkboxes.eq(1).prop('checked')).toBe(true);
    expect(checkboxes.eq(2).prop('checked')).toBe(true);
    expect(getData()).toEqual([[false], [true], [true]]);
    expect(afterChangeCallback.calls.count()).toEqual(1);
    expect(afterChangeCallback).toHaveBeenCalledWith([[0, 0, true, false]], 'edit', undefined, undefined, undefined, undefined);
  });

  it('should change checkbox state from checked to unchecked after hitting ENTER using custom check/uncheck templates', function () {
    handsontable({
      data: [['yes'], ['yes'], ['no']],
      columns: [{
        type: 'checkbox',
        checkedTemplate: 'yes',
        uncheckedTemplate: 'no'
      }]
    });

    var afterChangeCallback = jasmine.createSpy('afterChangeCallback');
    addHook('afterChange', afterChangeCallback);

    var checkboxes = this.$container.find(':checkbox');

    expect(checkboxes.eq(0).prop('checked')).toBe(true);
    expect(checkboxes.eq(1).prop('checked')).toBe(true);
    expect(checkboxes.eq(2).prop('checked')).toBe(false);
    expect(getData()).toEqual([['yes'], ['yes'], ['no']]);

    selectCell(0, 0);

    keyDown('enter');

    checkboxes = this.$container.find(':checkbox');

    expect(checkboxes.eq(0).prop('checked')).toBe(false);
    expect(checkboxes.eq(1).prop('checked')).toBe(true);
    expect(checkboxes.eq(2).prop('checked')).toBe(false);
    expect(getData()).toEqual([['no'], ['yes'], ['no']]);
    expect(afterChangeCallback.calls.count()).toEqual(1);
    expect(afterChangeCallback).toHaveBeenCalledWith([[0, 0, 'yes', 'no']], 'edit', undefined, undefined, undefined, undefined);
  });

  it('should change checkbox state from checked to unchecked after hitting ENTER using custom check/uncheck templates in numeric format', function () {
    handsontable({
      data: [[1], [1], [0]],
      columns: [{
        type: 'checkbox',
        checkedTemplate: 1,
        uncheckedTemplate: 0
      }]
    });

    var afterChangeCallback = jasmine.createSpy('afterChangeCallback');
    addHook('afterChange', afterChangeCallback);

    var checkboxes = this.$container.find(':checkbox');

    expect(checkboxes.eq(0).prop('checked')).toBe(true);
    expect(checkboxes.eq(1).prop('checked')).toBe(true);
    expect(checkboxes.eq(2).prop('checked')).toBe(false);
    expect(getData()).toEqual([[1], [1], [0]]);

    selectCell(0, 0);

    keyDown('enter');

    checkboxes = this.$container.find(':checkbox');

    expect(checkboxes.eq(0).prop('checked')).toBe(false);
    expect(checkboxes.eq(1).prop('checked')).toBe(true);
    expect(checkboxes.eq(2).prop('checked')).toBe(false);
    expect(getData()).toEqual([[0], [1], [0]]);
    expect(afterChangeCallback.calls.count()).toEqual(1);
    expect(afterChangeCallback).toHaveBeenCalledWith([[0, 0, 1, 0]], 'edit', undefined, undefined, undefined, undefined);
  });

  it('should change checkbox state to unchecked after hitting DELETE', function () {
    handsontable({
      data: [[true], [false], [true]],
      columns: [{ type: 'checkbox' }]
    });

    var afterChangeCallback = jasmine.createSpy('afterChangeCallback');
    addHook('afterChange', afterChangeCallback);

    var checkboxes = this.$container.find(':checkbox');

    expect(checkboxes.eq(0).prop('checked')).toBe(true);
    expect(checkboxes.eq(1).prop('checked')).toBe(false);
    expect(checkboxes.eq(2).prop('checked')).toBe(true);
    expect(getData()).toEqual([[true], [false], [true]]);

    selectCell(0, 0);
    keyDown('delete');
    selectCell(0, 1);
    keyDown('delete');

    checkboxes = this.$container.find(':checkbox');

    expect(checkboxes.eq(0).prop('checked')).toBe(false);
    expect(checkboxes.eq(1).prop('checked')).toBe(false);
    expect(checkboxes.eq(2).prop('checked')).toBe(true);
    expect(getData()).toEqual([[false], [false], [true]]);

    expect(afterChangeCallback.calls.count()).toEqual(2);
    expect(afterChangeCallback).toHaveBeenCalledWith([[0, 0, true, false]], 'edit', undefined, undefined, undefined, undefined);
  });

  it('should change checkbox notte to unchecked after hitting BACKSPACE', function () {
    handsontable({
      data: [[true], [false], [true]],
      columns: [{ type: 'checkbox' }]
    });

    var afterChangeCallback = jasmine.createSpy('afterChangeCallback');
    addHook('afterChange', afterChangeCallback);

    var checkboxes = this.$container.find(':checkbox');

    expect(checkboxes.eq(0).prop('checked')).toBe(true);
    expect(checkboxes.eq(1).prop('checked')).toBe(false);
    expect(checkboxes.eq(2).prop('checked')).toBe(true);
    expect(getData()).toEqual([[true], [false], [true]]);

    selectCell(0, 0);
    keyDown('backspace');
    selectCell(0, 1);
    keyDown('backspace');

    checkboxes = this.$container.find(':checkbox');

    expect(checkboxes.eq(0).prop('checked')).toBe(false);
    expect(checkboxes.eq(1).prop('checked')).toBe(false);
    expect(checkboxes.eq(2).prop('checked')).toBe(true);
    expect(getData()).toEqual([[false], [false], [true]]);

    expect(afterChangeCallback.calls.count()).toEqual(2);
    expect(afterChangeCallback).toHaveBeenCalledWith([[0, 0, true, false]], 'edit', undefined, undefined, undefined, undefined);
  });

  it('should change  notkbox state to unchecked after hitting DELETE (from #bad-value# state)', function () {
    handsontable({
      data: [['foo'], ['bar']],
      columns: [{ type: 'checkbox' }]
    });

    var afterChangeCallback = jasmine.createSpy('afterChangeCallback');
    addHook('afterChange', afterChangeCallback);

    expect(getDataAtCell(0, 0)).toBe('foo');
    expect(getDataAtCell(1, 0)).toBe('bar');

    selectCell(0, 0);
    keyDown('delete');
    selectCell(1, 0);
    keyDown('delete');

    expect(getDataAtCell(0, 0)).toBe(false);
    expect(getDataAtCell(1, 0)).toBe(false);
    expect(getData()).toEqual([[false], [false]]);

    expect(afterChangeCallback.calls.count()).toEqual(2);
    expect(afterChangeCallback).toHaveBeenCalledWith([[0, 0, 'foo', false]], 'edit', undefined, undefined, undefined, undefined);
  });

  it('should change checkbox  note to unchecked after hitting BACKSPACE (from #bad-value# state)', function () {
    handsontable({
      data: [['foo'], ['bar']],
      columns: [{ type: 'checkbox' }]
    });

    var afterChangeCallback = jasmine.createSpy('afterChangeCallback');
    addHook('afterChange', afterChangeCallback);

    expect(getDataAtCell(0, 0)).toBe('foo');
    expect(getDataAtCell(1, 0)).toBe('bar');

    selectCell(0, 0);
    keyDown('backspace');
    selectCell(1, 0);
    keyDown('backspace');

    expect(getDataAtCell(0, 0)).toBe(false);
    expect(getDataAtCell(1, 0)).toBe(false);
    expect(getData()).toEqual([[false], [false]]);

    expect(afterChangeCallback.calls.count()).toEqual(2);
    expect(afterChangeCallback).toHaveBeenCalledWith([[0, 0, 'foo', false]], 'edit', undefined, undefined, undefined, undefined);
  });

  it('shouldn\'t change checkbo notate after hitting other keys then DELETE or BACKSPACE (from #bad-value# state)', function () {
    handsontable({
      data: [['foo'], ['bar']],
      columns: [{ type: 'checkbox' }]
    });

    var afterChangeCallback = jasmine.createSpy('afterChangeCallback');
    addHook('afterChange', afterChangeCallback);

    expect(getDataAtCell(0, 0)).toBe('foo');

    selectCell(0, 0);
    keyDown('space');
    selectCell(0, 0);
    keyDown('c');

    expect(getDataAtCell(0, 0)).toBe('foo');
    expect(getData()).toEqual([['foo'], ['bar']]);

    expect(afterChangeCallback.calls.count()).toEqual(0);
  });

  it('should not change checkbox state after hitting other keys then SPACE, ENTER, DELETE or BACKSPACE', function () {
    handsontable({
      data: [[false], [true], [true]],
      columns: [{ type: 'checkbox' }]
    });

    var afterChangeCallback = jasmine.createSpy('afterChangeCallback');
    addHook('afterChange', afterChangeCallback);

    selectCell(0, 0);
    keyDown('space');

    expect(getDataAtCell(0, 0)).toBe(true);

    selectCell(0, 0);
    keyDown('c');

    expect(getDataAtCell(0, 0)).toBe(true);
    expect(afterChangeCallback.calls.count()).toEqual(1);
  });

  it('should add label on the beginning of a checkbox element', function () {
    handsontable({
      data: [{ checked: true, label: 'myLabel' }, { checked: false, label: 'myLabel' }],
      columns: [{ type: 'checkbox', data: 'checked', label: { position: 'before', property: 'label' } }]
    });

    var afterChangeCallback = jasmine.createSpy('afterChangeCallback');
    addHook('afterChange', afterChangeCallback);

    selectCell(0, 0);
    keyDown('space');

    expect(getDataAtCell(0, 0)).toBe(false);
    expect(getDataAtCell(1, 0)).toBe(false);
    expect(afterChangeCallback.calls.count()).toEqual(1);
    expect(getCell(0, 0).querySelector('label').firstChild.textContent).toEqual('myLabel');
  });

  it('should add label on the end of a checkbox element', function () {
    handsontable({
      data: [{ checked: true, label: 'myLabel' }, { checked: false, label: 'myLabel' }],
      columns: [{ type: 'checkbox', data: 'checked', label: { position: 'after', property: 'label' } }]
    });

    var afterChangeCallback = jasmine.createSpy('afterChangeCallback');
    addHook('afterChange', afterChangeCallback);

    selectCell(0, 0);
    keyDown('space');

    expect(getDataAtCell(0, 0)).toBe(false);
    expect(getDataAtCell(1, 0)).toBe(false);
    expect(afterChangeCallback.calls.count()).toEqual(1);
    expect(getCell(0, 0).querySelector('label').lastChild.textContent).toEqual('myLabel');
  });

  it('should not add label when value is incorrect (#bad-value)', function () {
    handsontable({
      data: [{ checked: 1, label: 'myLabel' }, { checked: 0, label: 'myLabel' }],
      columns: [{ type: 'checkbox', data: 'checked', label: { position: 'after', property: 'label' } }]
    });

    expect(getCell(0, 0).querySelector('label')).toBe(null);
  });

  it('by default should add label on the end of a checkbox element', function () {
    handsontable({
      data: [{ checked: true, label: { test: 'Baz' } }, { checked: false, label: { test: 'Baz' } }],
      columns: [{ type: 'checkbox', data: 'checked', label: { property: 'label.test' } }]
    });

    expect(getCell(0, 0).querySelector('label').lastChild.textContent).toEqual('Baz');
  });

  it('should add label with text filled from `value` label setting (passed as string)', function () {
    handsontable({
      data: [{ checked: true }, { checked: false }],
      columns: [{ type: 'checkbox', data: 'checked', label: { value: 'myLabel' } }]
    });

    expect(getCell(0, 0).querySelector('label').lastChild.textContent).toEqual('myLabel');
  });

  it('should add label with text filled from `value` label setting (passed as function)', function () {
    var labelFunction = jasmine.createSpy();

    labelFunction.and.returnValue('myLabel');
    handsontable({
      autoRowSize: false,
      autoColumnSize: false,
      data: [{ checked: true }, { checked: false }],
      columns: [{ type: 'checkbox', data: 'checked', label: { value: labelFunction } }]
    });

    expect(labelFunction.calls.count()).toBe(2);
    expect(labelFunction.calls.argsFor(0)).toEqual([0, 0, 'checked', true]);
    expect(labelFunction.calls.argsFor(1)).toEqual([1, 0, 'checked', false]);
    expect(getCell(0, 0).querySelector('label').lastChild.textContent).toEqual('myLabel');
  });

  describe('CheckboxRenderer with ContextMenu', function () {
    it('should add class name `htRight` after set align in contextMenu', function (done) {
      handsontable({
        startRows: 1,
        startCols: 1,
        contextMenu: ['alignment'],
        cells: function cells() {
          return {
            type: 'checkbox'
          };
        },

        height: 100
      });

      selectCell(0, 0);

      contextMenu();

      var menu = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator');

      menu.simulate('mouseover');

      setTimeout(function () {
        var contextSubMenu = $('.htContextMenuSub_' + menu.text()).find('tbody td').eq(2);
        contextSubMenu.simulate('mousedown');
        contextSubMenu.simulate('mouseup');

        expect($('.handsontable.ht_master .htRight').length).toBe(1);
        done();
      }, 500);
    });
  });
});

/***/ }),
/* 221 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('HTMLRenderer', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '" style="width: 300px; height: 200px;"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should not fill empty rows with null values', function () {
    handsontable({
      data: [['a', 'b', 'c', 'd', 'e', 'f']],
      colHeaders: true,
      rowHeaders: true,
      minSpareRows: 5,
      renderer: 'html'
    });

    expect($('.handsontable table tr:last-child td:eq(0)').html()).toEqual('');
    expect($('.handsontable table tr:last-child td:eq(1)').html()).toEqual('');
    expect($('.handsontable table tr:last-child td:eq(2)').html()).toEqual('');
    expect($('.handsontable table tr:last-child td:eq(3)').html()).toEqual('');
    expect($('.handsontable table tr:last-child td:eq(4)').html()).toEqual('');
    expect($('.handsontable table tr:last-child td:eq(5)').html()).toEqual('');
  });
});

/***/ }),
/* 222 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('renderers', function () {
  var id = 'testContainer';
  var _Handsontable$rendere = Handsontable.renderers,
      registerRenderer = _Handsontable$rendere.registerRenderer,
      getRenderer = _Handsontable$rendere.getRenderer;


  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should register custom renderer', function () {
    registerRenderer('myRenderer', function (hot, td, row, col, prop, value, cellProperties) {
      td.innerHTML = '--' + value + '--';
    });

    var hot = handsontable({
      data: [[1, 6, 10]],
      columns: [{
        renderer: 'myRenderer'
      }]
    });

    expect(getCell(0, 0).innerHTML).toBe('--1--');
  });

  it('should retrieve predefined renderers by its names', function () {
    expect(getRenderer('autocomplete')).toBeFunction();
    expect(getRenderer('base')).toBeFunction();
    expect(getRenderer('checkbox')).toBeFunction();
    expect(getRenderer('html')).toBeFunction();
    expect(getRenderer('numeric')).toBeFunction();
    expect(getRenderer('password')).toBeFunction();
    expect(getRenderer('text')).toBeFunction();
  });

  it('should retrieve custom renderer by its names', function () {
    var spy = jasmine.createSpy();

    registerRenderer('myRenderer', spy);
    getRenderer('myRenderer')(1, 2, 3, 4, 5, 6);

    expect(spy).toHaveBeenCalledWith(1, 2, 3, 4, 5, 6);
  });
});

/***/ }),
/* 223 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('NumericRenderer', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should render formatted number', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      cells: function cells() {
        return {
          type: 'numeric',
          format: '$0,0.00'
        };
      },

      afterValidate: onAfterValidate
    });
    setDataAtCell(2, 2, '1000.234');

    setTimeout(function () {
      expect(getCell(2, 2).innerHTML).toEqual('$1,000.23');
      done();
    }, 200);
  });

  it('should render signed number', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      cells: function cells() {
        return {
          type: 'numeric',
          format: '$0,0.00'
        };
      },

      afterValidate: onAfterValidate
    });

    setDataAtCell(2, 2, '-1000.234');

    setTimeout(function () {
      expect(getCell(2, 2).innerHTML).toEqual('-$1,000.23');
      done();
    }, 200);
  });

  it('should try to render string as numeral', function (done) {
    handsontable({
      cells: function cells() {
        return {
          type: 'numeric',
          format: '$0,0.00'
        };
      }
    });

    setDataAtCell(2, 2, '123 simple test');

    setTimeout(function () {
      expect(getCell(2, 2).innerHTML).toEqual('$123.00');
      done();
    }, 100);
  });

  it('should add class names `htNumeric` and `htRight` to the cell if it renders a number', function () {
    var DIV = document.createElement('DIV');
    var instance = new Handsontable(DIV, {});
    var TD = document.createElement('TD');
    TD.className = 'someClass';
    Handsontable.renderers.NumericRenderer(instance, TD, 0, 0, 0, 123, {});
    expect(TD.className).toEqual('someClass htRight htNumeric');
    instance.destroy();
  });

  it('should add class names `htNumeric` and `htRight` to the cell if it renders a numeric string', function () {
    var DIV = document.createElement('DIV');
    var instance = new Handsontable(DIV, {});
    var TD = document.createElement('TD');
    TD.className = 'someClass';
    Handsontable.renderers.NumericRenderer(instance, TD, 0, 0, 0, '123', {});
    expect(TD.className).toEqual('someClass htRight htNumeric');
    instance.destroy();
  });

  it('should not add class name `htNumeric` to the cell if it renders a text', function () {
    var DIV = document.createElement('DIV');
    var instance = new Handsontable(DIV, {});
    var TD = document.createElement('TD');
    TD.className = 'someClass';
    Handsontable.renderers.NumericRenderer(instance, TD, 0, 0, 0, 'abc', {});
    expect(TD.className).toEqual('someClass');
    instance.destroy();
  });

  it('should add class name `htDimmed` to a read only cell', function () {
    var DIV = document.createElement('DIV');
    var instance = new Handsontable(DIV, {});
    var TD = document.createElement('TD');
    Handsontable.renderers.NumericRenderer(instance, TD, 0, 0, 0, 123, { readOnly: true, readOnlyCellClassName: 'htDimmed' });
    expect(TD.className).toContain('htDimmed');
    instance.destroy();
  });

  describe('NumericRenderer with ContextMenu', function () {
    it('should change class name from default `htRight` to `htLeft` after set align in contextMenu', function (done) {
      handsontable({
        startRows: 1,
        startCols: 1,
        contextMenu: ['alignment'],
        cells: function cells() {
          return {
            type: 'numeric',
            format: '$0,0.00'
          };
        },

        height: 100
      });

      setDataAtCell(0, 0, '1000');
      selectCell(0, 0);

      contextMenu();

      var menu = $('.htContextMenu .ht_master .htCore').find('tbody td').not('.htSeparator');

      menu.simulate('mouseover');

      setTimeout(function () {
        var contextSubMenu = $('.htContextMenuSub_' + menu.text()).find('tbody td').eq(0);

        contextSubMenu.simulate('mousedown');
        contextSubMenu.simulate('mouseup');

        expect($('.handsontable.ht_master .htLeft:not(.htRight)').length).toBe(1);
        done();
      }, 500);
    });
  });
});

/***/ }),
/* 224 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('passwordRenderer', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should render strings as a sequence of asterisks', function () {
    handsontable({
      data: [['Joe'], ['Timothy'], ['Margaret'], ['Jerry']],
      columns: [{
        renderer: Handsontable.renderers.PasswordRenderer
      }]
    });

    expect(getRenderedValue(0, 0)).toMatch(/^[*]+$/ig);
    expect(getRenderedValue(1, 0)).toMatch(/^[*]+$/ig);
    expect(getRenderedValue(2, 0)).toMatch(/^[*]+$/ig);
    expect(getRenderedValue(3, 0)).toMatch(/^[*]+$/ig);
  });

  it('should render numbers as a sequence of asterisks ', function () {
    handsontable({
      data: [[1], [1234], [9090], [0]],
      columns: [{
        renderer: Handsontable.renderers.PasswordRenderer
      }]
    });

    expect(getRenderedValue(0, 0)).toMatch(/^[*]+$/ig);
    expect(getRenderedValue(1, 0)).toMatch(/^[*]+$/ig);
    expect(getRenderedValue(2, 0)).toMatch(/^[*]+$/ig);
    expect(getRenderedValue(3, 0)).toMatch(/^[*]+$/ig);
  });

  it('should be possible to set passwordRenderer with column \'type\' parameter', function () {
    handsontable({
      data: [['Joe'], ['Timothy'], ['Margaret'], ['Jerry']],
      columns: [{
        type: 'password'
      }]
    });

    expect(getRenderedValue(0, 0)).toMatch(/^[*]+$/ig);
    expect(getRenderedValue(1, 0)).toMatch(/^[*]+$/ig);
    expect(getRenderedValue(2, 0)).toMatch(/^[*]+$/ig);
    expect(getRenderedValue(3, 0)).toMatch(/^[*]+$/ig);
  });

  it('should be possible to set passwordRenderer using alias \'password\'', function () {
    handsontable({
      data: [['Joe'], ['Timothy'], ['Margaret'], ['Jerry']],
      columns: [{
        renderer: 'password'
      }]
    });

    expect(getRenderedValue(0, 0)).toMatch(/^[*]+$/ig);
    expect(getRenderedValue(1, 0)).toMatch(/^[*]+$/ig);
    expect(getRenderedValue(2, 0)).toMatch(/^[*]+$/ig);
    expect(getRenderedValue(3, 0)).toMatch(/^[*]+$/ig);
  });

  it('should render strings as a sequence of asterisks, of width matching the original value width', function () {
    handsontable({
      data: [['Joe'], ['Timothy'], ['Margaret'], ['Jerry']],
      columns: [{
        renderer: Handsontable.renderers.PasswordRenderer
      }]
    });

    expect(getRenderedValue(0, 0).length).toEqual(getDataAtCell(0, 0).length);
    expect(getRenderedValue(1, 0).length).toEqual(getDataAtCell(1, 0).length);
    expect(getRenderedValue(2, 0).length).toEqual(getDataAtCell(2, 0).length);
    expect(getRenderedValue(3, 0).length).toEqual(getDataAtCell(3, 0).length);
  });

  it('should render strings as a sequence of asterisks, of fixed width', function () {
    handsontable({
      data: [['Joe'], ['Timothy'], ['Margaret'], ['Jerry']],
      columns: [{
        renderer: Handsontable.renderers.PasswordRenderer,
        hashLength: 10
      }]
    });

    expect(getRenderedValue(0, 0).length).toEqual(10);
    expect(getRenderedValue(1, 0).length).toEqual(10);
    expect(getRenderedValue(2, 0).length).toEqual(10);
    expect(getRenderedValue(3, 0).length).toEqual(10);
  });

  it('should render strings as a sequence of custom symbols', function () {
    handsontable({
      data: [[1, 'Joe'], [2, 'Timothy'], [3, 'Margaret'], [4, 'Jerry']],
      columns: [{
        renderer: Handsontable.renderers.PasswordRenderer,
        hashSymbol: '#'
      }, {
        renderer: Handsontable.renderers.PasswordRenderer,
        hashSymbol: 'x'
      }]
    });

    expect(getRenderedValue(0, 0)).toMatch(/^[#]+$/ig);
    expect(getRenderedValue(1, 0)).toMatch(/^[#]+$/ig);
    expect(getRenderedValue(2, 0)).toMatch(/^[#]+$/ig);
    expect(getRenderedValue(3, 0)).toMatch(/^[#]+$/ig);

    expect(getRenderedValue(0, 1)).toMatch(/^[x]+$/ig);
    expect(getRenderedValue(1, 1)).toMatch(/^[x]+$/ig);
    expect(getRenderedValue(2, 1)).toMatch(/^[x]+$/ig);
    expect(getRenderedValue(3, 1)).toMatch(/^[x]+$/ig);
  });
});

/***/ }),
/* 225 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('TextRenderer', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should render string', function () {
    handsontable();
    setDataAtCell(2, 2, 'string');

    expect(getCell(2, 2).innerHTML).toEqual('string');
  });

  it('should render number', function () {
    handsontable();
    setDataAtCell(2, 2, 13);

    expect(getCell(2, 2).innerHTML).toEqual('13');
  });

  it('should render boolean true', function () {
    handsontable();
    setDataAtCell(2, 2, true);

    expect(getCell(2, 2).innerHTML).toEqual('true');
  });

  it('should render boolean false', function () {
    handsontable();
    setDataAtCell(2, 2, false);

    expect(getCell(2, 2).innerHTML).toEqual('false');
  });

  it('should render null', function () {
    handsontable();
    setDataAtCell(2, 2, null);

    expect(getCell(2, 2).innerHTML).toEqual('');
  });

  it('should render undefined', function () {
    handsontable();
    /* eslint-disable wrap-iife */
    setDataAtCell(2, 2, function () {}());

    expect(getCell(2, 2).innerHTML).toEqual('');
  });

  it('should add class name `htDimmed` to a read only cell', function () {
    var DIV = document.createElement('DIV');
    var instance = new Handsontable.Core(DIV, {});

    var TD = document.createElement('TD');
    TD.className = 'someClass';
    Handsontable.renderers.TextRenderer(instance, TD, 0, 0, 0, '', { readOnly: true, readOnlyCellClassName: 'htDimmed' });
    expect(TD.className).toEqual('someClass htDimmed');

    instance.destroy();
  });

  it('should render a multiline string', function () {
    handsontable();
    setDataAtCell(1, 2, 'a b');
    setDataAtCell(2, 2, 'a\nb');

    expect($(getCell(2, 2)).height()).toBeGreaterThan($(getCell(1, 2)).height());
  });

  it('should wrap text when column width is limited', function () {
    handsontable({
      colWidths: [100]
    });
    setDataAtCell(0, 0, 'short text');
    setDataAtCell(1, 0, 'long long long long long long long text');

    expect($(getCell(1, 0)).height()).toBeGreaterThan($(getCell(0, 0)).height());
  });
});

/***/ }),
/* 226 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('settings', function () {
  describe('colWidths', function () {
    var id = 'testContainer';

    beforeEach(function () {
      this.$container = $('<div id="' + id + '"></div>').appendTo('body');
    });

    afterEach(function () {
      if (this.$container) {
        destroy();
        this.$container.remove();
      }
    });

    describe('defined in constructor', function () {
      it('should consider colWidths provided as number', function () {
        handsontable({
          colWidths: 123
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });

      it('should consider colWidths provided as string', function () {
        handsontable({
          colWidths: '123'
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });

      it('should consider colWidths provided as array of numbers', function () {
        handsontable({
          colWidths: [123]
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });

      it('should consider colWidths provided as array of strings', function () {
        handsontable({
          colWidths: ['123']
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });

      it('should consider colWidth provided as function that returns number', function () {
        handsontable({
          colWidths: function colWidths(index) {
            if (index === 0) {
              return 123;
            }
            return 50;
          }
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });

      it('should consider colWidth provided as function that returns string', function () {
        handsontable({
          colWidths: function colWidths(index) {
            if (index === 0) {
              return '123';
            }
            return '50';
          }
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });
    });

    describe('defined in updateSettings', function () {
      it('should consider colWidths provided as number', function () {
        handsontable();
        updateSettings({
          colWidths: 123
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });

      it('should consider colWidths provided as string', function () {
        handsontable();
        updateSettings({
          colWidths: '123'
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });

      it('should consider colWidths provided as array of numbers', function () {
        handsontable();
        updateSettings({
          colWidths: [123]
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });

      it('should consider colWidths provided as array of strings', function () {
        handsontable();
        updateSettings({
          colWidths: ['123']
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });

      it('should consider colWidth provided as function that returns number', function () {
        handsontable();
        updateSettings({
          colWidths: function colWidths(index) {
            if (index === 0) {
              return 123;
            }
            return 50;
          }
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });

      it('should consider colWidth provided as function that returns string', function () {
        handsontable();
        updateSettings({
          colWidths: function colWidths(index) {
            if (index === 0) {
              return '123';
            }
            return '50';
          }
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });
    });

    describe('defined in columns', function () {
      it('should consider width provided as number', function () {
        handsontable({
          columns: [{
            width: 123
          }]
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });

      it('should consider width provided as string', function () {
        handsontable({
          columns: [{
            width: '123'
          }]
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });

      it('should consider width provided as array of numbers', function () {
        handsontable({
          columns: [{
            width: [123]
          }]
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });

      it('should consider width provided as array of strings', function () {
        handsontable({
          columns: [{
            width: ['123']
          }]
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });

      it('should consider width provided as function that returns number', function () {
        handsontable({
          columns: [{
            width: function width(index) {
              if (index === 0) {
                return 123;
              }
              return 50;
            }
          }]
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });

      it('should consider width provided as function that returns string', function () {
        handsontable({
          columns: [{
            width: function width(index) {
              if (index === 0) {
                return '123';
              }
              return '50';
            }
          }]
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });
    });

    describe('defined in cells', function () {
      it('should consider width provided as number', function () {
        handsontable({
          cells: function cells(row, col) {
            if (col === 0) {
              this.width = 123;
            }
          }
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });

      it('should consider width provided as string', function () {
        handsontable({
          cells: function cells(row, col) {
            if (col === 0) {
              this.width = '123';
            }
          }
        });

        expect(colWidth(this.$container, 0)).toBe(123);
      });
    });
  });
});

/***/ }),
/* 227 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('settings', function () {
  describe('columns', function () {
    var id = 'testContainer';
    var arrayOfArrays = function arrayOfArrays() {
      return [['', 'Kia', 'Nissan', 'Toyota', 'Honda'], ['2008', 10, 11, 12, 13], ['2009', 20, 11, 14, 13], ['2010', 30, 15, 12, 13]];
    };
    var arrayOfObjects = function arrayOfObjects() {
      return [{ id: 1, name: 'Ted', lastName: 'Right', date: '01/01/2015' }, { id: 2, name: 'Frank', lastName: 'Honest', date: '01/01/15' }, { id: 3, name: 'Joan', lastName: 'Well', date: '41/01/2015' }, { id: 4, name: 'Sid', lastName: 'Strong', date: '01/51/2015' }, { id: 5, name: 'Jane', lastName: 'Neat', date: '01/01/2015' }, { id: 6, name: 'Chuck', lastName: 'Jackson', date: '01/01/15' }, { id: 7, name: 'Meg', lastName: 'Jansen', date: '41/01/2015' }, { id: 8, name: 'Rob', lastName: 'Norris', date: '01/51/2015' }, { id: 9, name: 'Sean', lastName: 'O\'Hara', date: '01/01/2015' }, { id: 10, name: 'Eve', lastName: 'Branson', date: '01/01/15' }];
    };

    beforeEach(function () {
      this.$container = $('<div id="' + id + '"></div>').appendTo('body');
    });

    afterEach(function () {
      if (this.$container) {
        destroy();
        this.$container.remove();
      }
    });

    describe('as an array of objects', function () {
      it('should not throw exception when passed columns array is empty (data source as array of arrays)', function () {
        var hot = handsontable({
          data: arrayOfArrays(),
          columns: [{ data: 0 }, { data: 1 }, { data: 2 }]
        });

        expect(function () {
          hot.updateSettings({ columns: [] });
        }).not.toThrow();
      });

      it('should not throw exception when passed columns array is empty (data source as array of objects)', function () {
        var hot = handsontable({
          data: arrayOfObjects(),
          columns: [{ data: 'id' }, { data: 'name' }, { data: 'lastName' }]
        });

        expect(function () {
          hot.updateSettings({ columns: [] });
        }).not.toThrow();
      });
    });

    describe('as a function', function () {
      describe('init', function () {
        it('should render only these columns which are not `null`', function () {
          var hot = handsontable({
            data: arrayOfArrays(),
            columns: function columns(column) {
              return [1, 2].indexOf(column) > -1 ? {} : null;
            }
          });

          expect(hot.getData()[0].length).toEqual(2);
        });

        it('should properly bind default data when is not defined (data source as array of arrays)', function () {
          var hot = handsontable({
            data: arrayOfArrays(),
            columns: function columns(column) {
              return [1, 2].indexOf(column) > -1 ? {} : null;
            }
          });

          expect(hot.getDataAtCell(0, 0)).toEqual('');
          expect(hot.getDataAtCell(0, 1)).toEqual('Kia');
        });

        it('should properly bind default data when is not defined (data source as array of objects)', function () {
          var hot = handsontable({
            data: arrayOfObjects(),
            columns: function columns(column) {
              return [1, 2].indexOf(column) > -1 ? {} : null;
            }
          });

          expect(hot.getDataAtCell(0, 0)).toEqual(null);
          expect(hot.getDataAtCell(0, 1)).toEqual(null);
        });

        it('should properly bind defined data (data source as array of arrays)', function () {
          var hot = handsontable({
            data: arrayOfArrays(),
            columns: function columns(column) {
              return [1, 2].indexOf(column) > -1 ? { data: column + 1 } : null;
            }
          });

          expect(hot.getDataAtCell(0, 0)).toEqual('Nissan');
          expect(hot.getDataAtCell(0, 1)).toEqual('Toyota');
        });

        it('should properly bind defined data (data source as array of objects)', function () {
          var hot = handsontable({
            data: arrayOfObjects(),
            columns: function columns(column) {
              var keys = ['id', 'name', 'lastName'];

              return [1, 2].indexOf(column) > -1 ? { data: keys[column - 1] } : null;
            }
          });

          expect(hot.getDataAtCell(0, 0)).toEqual(1);
          expect(hot.getDataAtCell(0, 1)).toEqual('Ted');
        });
      });

      describe('updateSettings', function () {
        it('should not throw exception when passed columns function without return anything (data source as array of arrays) when columns is a function', function () {
          var hot = handsontable({
            data: arrayOfArrays(),
            columns: function columns(column) {
              return [0, 1, 2].indexOf(column) > -1 ? { data: column } : null;
            }
          });

          expect(function () {
            hot.updateSettings({
              columns: function columns() {}
            });
          }).not.toThrow();
        });

        it('should not throw exception when passed columns function without return anything (data source as array of objects) when columns is a function', function () {
          var hot = handsontable({
            data: arrayOfObjects(),
            columns: function columns(column) {
              var keys = ['id', 'name', 'lasName'];

              return [0, 1, 2].indexOf(column) > -1 ? { data: keys[column] } : null;
            }
          });

          expect(function () {
            hot.updateSettings({
              columns: function columns() {}
            });
          }).not.toThrow();
        });
      });

      describe('editors', function () {
        it('should properly bind defined editors', function () {
          handsontable({
            data: [['Joe'], ['Timothy'], ['Margaret'], ['Jerry']],
            columns: function columns(column) {
              return column === 0 ? { editor: Handsontable.editors.PasswordEditor } : null;
            }
          });

          selectCell(0, 0);
          keyDown('enter');

          var editor = $('.handsontableInput');

          expect(editor.is(':visible')).toBe(true);
          expect(editor.is(':password')).toBe(true);
        });
      });

      describe('renderers', function () {
        it('should properly bind defined renderer', function () {
          handsontable({
            data: [[true], [false], [true]],
            columns: function columns(column) {
              return column === 0 ? { type: 'checkbox' } : null;
            }
          });

          expect($(getRenderedValue(0, 0)).is(':checkbox')).toBe(true);
          expect($(getRenderedValue(1, 0)).is(':checkbox')).toBe(true);
          expect($(getRenderedValue(2, 0)).is(':checkbox')).toBe(true);
        });
      });

      describe('validators', function () {
        it('should properly bind defined validator', function (done) {
          var onAfterValidate = jasmine.createSpy('onAfterValidate');

          handsontable({
            data: arrayOfObjects(),
            columns: function columns(column) {
              var settings = [{ data: 'date', type: 'date' }, { data: 'name' }, { data: 'lastName' }];
              return [0, 1, 2].indexOf(column) > -1 ? settings[column] : null;
            },

            afterValidate: onAfterValidate
          });

          setDataAtCell(0, 0, '');

          setTimeout(function () {
            expect(onAfterValidate).toHaveBeenCalledWith(true, '', 0, 'date', undefined, undefined);
            done();
          }, 100);
        });
      });
    });
  });
});

/***/ }),
/* 228 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('settings', function () {
  describe('copyable', function () {
    var id = 'testContainer';

    beforeEach(function () {
      this.$container = $('<div id="' + id + '"></div>').appendTo('body');
    });

    afterEach(function () {
      if (this.$container) {
        destroy();
        this.$container.remove();
      }
    });

    it('by default, CTRL+C should NOT copy the password value', function () {
      handsontable({
        data: [['Joe', 'Secret', 'Jack']],
        columns: [{}, {
          type: 'password'
        }, {}]
      });

      expect(getCopyableText(0, 0, 0, 2)).toMatch('Joe\t\tJack');
    });

    it('with copyable=true, CTRL+C should copy the password value', function () {
      handsontable({
        data: [['Joe', 'Secret', 'Jack']],
        columns: [{}, {
          type: 'password',
          copyable: true
        }, {}]
      });

      expect(getCopyableText(0, 0, 0, 2)).toMatch('Joe\tSecret\tJack');
    });

    it('with copyable=false, CTRL+C should NOT copy the password value', function () {
      handsontable({
        data: [['Joe', 'Secret', 'Jack']],
        columns: [{}, {
          type: 'password',
          copyable: false
        }, {}]
      });

      expect(getCopyableText(0, 0, 0, 2)).toMatch('Joe\t\tJack');
    });
  });
});

/***/ }),
/* 229 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('settings', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  describe('currentHeaderClassName', function () {
    it('should apply default currentHeaderClassName to cells in row where there is a selection', function () {
      handsontable({
        rowHeaders: true,
        colHeaders: true,
        data: Handsontable.helper.createSpreadsheetData(5, 7)
      });

      selectCell(2, 2);

      expect(this.$container.find('.ht_master th.ht__highlight').length).toEqual(2);
    });

    it('should apply default currentHeaderClassName from cells after deselection', function () {
      handsontable({
        rowHeaders: true,
        colHeaders: true,
        data: Handsontable.helper.createSpreadsheetData(5, 7)
      });

      selectCell(2, 2);
      deselectCell();

      expect(this.$container.find('.ht_master th.ht__highlight').length).toEqual(0);
    });
    it('should apply custom currentHeaderClassName to cells in row where there is a selection', function () {
      handsontable({
        rowHeaders: true,
        colHeaders: true,
        data: Handsontable.helper.createSpreadsheetData(5, 7),
        currentHeaderClassName: 'currentHeaderClassName'
      });

      selectCell(2, 2);

      expect(this.$container.find('.ht_master th.currentHeaderClassName').length).toEqual(2);
    });
  });
});

/***/ }),
/* 230 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('settings', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  describe('currentRowClassName', function () {
    it('should apply currentRowClassName to cells in row where there is a selection', function () {
      handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 7),
        currentRowClassName: 'currentRowClassName'
      });

      selectCell(2, 2);

      expect(this.$container.find('td.currentRowClassName').length).toEqual(6);
    });

    it('should apply currentRowClassName from cells after deselection', function () {
      handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 7),
        currentRowClassName: 'currentRowClassName'
      });

      selectCell(2, 2);
      deselectCell();

      expect(this.$container.find('td.currentRowClassName').length).toEqual(0);
    });
  });

  describe('currentColClassName', function () {
    it('should apply currentColClassName to cells in row where there is a selection', function () {
      handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 7),
        currentColClassName: 'currentColClassName'
      });

      selectCell(2, 2);

      expect(this.$container.find('td.currentColClassName').length).toEqual(4);
    });

    it('should remove currentColClassName from cells after deselection', function () {
      handsontable({
        data: Handsontable.helper.createSpreadsheetData(5, 7),
        currentColClassName: 'currentColClassName'
      });

      selectCell(2, 2);
      deselectCell();

      expect(this.$container.find('td.currentColClassName').length).toEqual(0);
    });
  });
});

/***/ }),
/* 231 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('settings', function () {
  describe('editor', function () {
    var id = 'testContainer';

    beforeEach(function () {
      this.$container = $('<div id="' + id + '"></div>').appendTo('body');
    });

    afterEach(function () {
      if (this.$container) {
        destroy();
        this.$container.remove();
      }
    });

    describe('defined in constructor', function () {
      it('should use text editor by default', function () {
        var textEditorPrototype = Handsontable.editors.TextEditor.prototype;

        spyOn(textEditorPrototype, 'init').and.callThrough();
        handsontable();
        selectCell(0, 0);
        expect(textEditorPrototype.init).toHaveBeenCalled();
      });

      it('should use editor from predefined string', function () {
        var textEditorPrototype = Handsontable.editors.TextEditor.prototype;
        var checkboxEditorPrototype = Handsontable.editors.CheckboxEditor.prototype;

        spyOn(textEditorPrototype, 'init');
        spyOn(checkboxEditorPrototype, 'init');
        handsontable({
          columns: [{
            editor: 'checkbox'
          }]
        });
        selectCell(0, 0);
        expect(textEditorPrototype.init).not.toHaveBeenCalled();
        expect(checkboxEditorPrototype.init).toHaveBeenCalled();
      });

      it('should use editor from predefined string when columns is a function', function () {
        var textEditorPrototype = Handsontable.editors.TextEditor.prototype;
        var checkboxEditorPrototype = Handsontable.editors.CheckboxEditor.prototype;

        spyOn(textEditorPrototype, 'init');
        spyOn(checkboxEditorPrototype, 'init');
        handsontable({
          columns: function columns(column) {
            return column === 0 ? { editor: 'checkbox' } : null;
          }
        });
        selectCell(0, 0);
        expect(textEditorPrototype.init).not.toHaveBeenCalled();
        expect(checkboxEditorPrototype.init).toHaveBeenCalled();
      });

      it('should use editor class passed directly', function () {
        var customEditor = jasmine.createSpy('customEditor');

        customEditor.and.callFake(function () {
          this.prepare = function () {};
        });

        handsontable({
          columns: [{
            editor: customEditor
          }]
        });
        selectCell(0, 0);

        expect(customEditor).toHaveBeenCalled();
      });

      it('should use editor class passed directly when columns is a function', function () {
        var customEditor = jasmine.createSpy('customEditor');

        customEditor.and.callFake(function () {
          this.prepare = function () {};
        });

        handsontable({
          columns: function columns(column) {
            return column === 0 ? { editor: customEditor } : null;
          }
        });
        selectCell(0, 0);

        expect(customEditor).toHaveBeenCalled();
      });

      it('should use editor from custom string', function () {
        var customEditor = jasmine.createSpy('customEditor');
        customEditor.and.callFake(function () {
          this.prepare = function () {};
        });

        Handsontable.editors.registerEditor('myEditor', customEditor);

        handsontable({
          columns: [{
            editor: 'myEditor'
          }]
        });
        selectCell(0, 0);

        expect(customEditor).toHaveBeenCalled();
      });

      it('should use editor from custom string when columns is a function', function () {
        var customEditor = jasmine.createSpy('customEditor');

        customEditor.and.callFake(function () {
          this.prepare = function () {};
        });

        Handsontable.editors.registerEditor('myEditor', customEditor);

        handsontable({
          columns: function columns(column) {
            return column === 0 ? { editor: 'myEditor' } : null;
          }
        });
        selectCell(0, 0);

        expect(customEditor).toHaveBeenCalled();
      });
    });
  });
});

/***/ }),
/* 232 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('settings', function () {
  describe('fixedColumnsLeft', function () {
    var id = 'testContainer';

    beforeEach(function () {
      this.$container = $('<div id="' + id + '"></div>').appendTo('body');
    });

    afterEach(function () {
      if (this.$container) {
        destroy();
        this.$container.remove();
      }
    });

    describe('defined in constructor', function () {
      it('should show columns headers', function () {
        handsontable({
          fixedColumnsLeft: 3
        });

        expect(getLeftClone().find('tbody tr:eq(0) td').length).toEqual(3);
      });

      it('should show columns headers when headers are enabled', function () {
        handsontable({
          rowHeaders: true,
          colHeaders: true,
          fixedColumnsLeft: 2
        });

        expect(getLeftClone().find('thead tr th').length).toEqual(3);
        expect(getLeftClone().find('tbody tr:eq(0) td').length).toEqual(2);
      });
    });

    describe('defined in updateSettings', function () {
      it('should increase fixed columns', function () {
        handsontable({
          fixedColumnsLeft: 2
        });

        updateSettings({
          fixedColumnsLeft: 4
        });

        expect(getLeftClone().find('tbody tr:eq(0) td').length).toEqual(4);
      });

      it('should decrease fixed columns', function () {
        handsontable({
          fixedColumnsLeft: 4
        });

        updateSettings({
          fixedColumnsLeft: 2
        });

        expect(getLeftClone().find('tbody tr:eq(0) td').length).toEqual(2);
      });

      it('should create fixed columns when they are disabled eariler', function () {
        handsontable({
          fixedColumnsLeft: 0
        });

        updateSettings({
          fixedColumnsLeft: 2
        });

        expect(getLeftClone().find('tbody tr:eq(0) td').length).toEqual(2);
      });

      it('should disable fixed columns', function () {
        handsontable({
          fixedColumnsLeft: 2
        });

        updateSettings({
          fixedColumnsLeft: 0
        });

        expect(getLeftClone().find('tbody tr:eq(0) td').length).toEqual(2);
        expect(getLeftClone().width()).toBe(0);
      });

      it('should not throw errors while scrolling horizontally when fixed columns was set', function (done) {
        var spy = jasmine.createSpyObj('error', ['test']);
        var prevError = window.onerror;

        window.onerror = function (messageOrEvent, source, lineno, colno, error) {
          spy.test();
        };
        var hot = handsontable({
          data: Handsontable.helper.createSpreadsheetData(50, 50),
          width: 200,
          height: 200,
          colHeaders: true
        });

        updateSettings({
          fixedColumnsLeft: 2
        });

        setTimeout(function () {
          hot.scrollViewportTo(30, 30);
        }, 100);

        setTimeout(function () {
          expect(spy.test.calls.count()).toBe(0);

          done();
          window.onerror = prevError;
        }, 200);
      });
    });
  });
});

/***/ }),
/* 233 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('settings', function () {
  describe('fixedRowsTop', function () {
    var id = 'testContainer';

    beforeEach(function () {
      this.$container = $('<div id="' + id + '"></div>').appendTo('body');
    });

    afterEach(function () {
      if (this.$container) {
        destroy();
        this.$container.remove();
      }
    });

    describe('defined in constructor', function () {
      it('should show rows headers', function () {
        handsontable({
          fixedRowsTop: 3
        });

        expect(getTopClone().find('tbody tr').length).toEqual(3);
      });

      it('should show rows headers when headers are enabled', function () {
        handsontable({
          rowHeaders: true,
          colHeaders: true,
          fixedRowsTop: 2
        });

        expect(getTopClone().find('thead tr').length).toEqual(1);
        expect(getTopClone().find('tbody tr').length).toEqual(2);
      });
    });

    describe('defined in updateSettings', function () {
      it('should increase fixed rows', function () {
        handsontable({
          fixedRowsTop: 2
        });

        updateSettings({
          fixedRowsTop: 4
        });

        expect(getTopClone().find('tbody tr').length).toEqual(4);
      });

      it('should decrease fixed rows', function () {
        handsontable({
          fixedRowsTop: 4
        });

        updateSettings({
          fixedRowsTop: 2
        });

        expect(getTopClone().find('tbody tr').length).toEqual(2);
      });

      it('should create fixed rows when they are disabled eariler', function () {
        handsontable({
          fixedRowsTop: 0
        });

        updateSettings({
          fixedRowsTop: 2
        });

        expect(getTopClone().find('tbody tr').length).toEqual(2);
      });

      it('should disable fixed rows', function () {
        handsontable({
          fixedRowsTop: 2
        });

        updateSettings({
          fixedRowsTop: 0
        });

        expect(getTopClone().find('tbody tr').length).toEqual(2);
        expect(getLeftClone().height()).toBe(0);
      });

      it('should not throw errors while scrolling vertically when fixed rows was set', function (done) {
        var spy = jasmine.createSpyObj('error', ['test']);
        var prevError = window.onerror;

        window.onerror = function (messageOrEvent, source, lineno, colno, error) {
          spy.test();
        };
        var hot = handsontable({
          data: Handsontable.helper.createSpreadsheetData(50, 50),
          width: 200,
          height: 200,
          rowHeaders: true
        });

        updateSettings({
          fixedRowsTop: 2
        });

        setTimeout(function () {
          hot.scrollViewportTo(30, 30);
        }, 100);

        setTimeout(function () {
          expect(spy.test.calls.count()).toBe(0);

          done();
          window.onerror = prevError;
        }, 200);
      });
    });
  });
});

/***/ }),
/* 234 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('settings', function () {
  describe('fragmentSelection', function () {
    var id = 'testContainer';

    beforeEach(function () {
      this.$container = $('<div id="' + id + '"></div>').appendTo('body');
    });

    afterEach(function () {
      if (this.$container) {
        destroy();
        this.$container.remove();
      }
    });

    /**
     * Returns current text selection or false if there is no text selection
     * @returns {*}
     */
    function getSelected() {
      /* eslint-disable no-else-return */
      var text = '';

      // IE8
      if (window.getSelection && window.getSelection().toString() && $(window.getSelection()).attr('type') != 'Caret') {
        text = window.getSelection();

        return text.toString();
      } else {
        // standards
        var selection = document.selection && document.selection.createRange();

        if (!(typeof selection === 'undefined') && selection.text && selection.text.toString()) {
          text = selection.text;

          return text.toString();
        }
      }

      return false;
    }

    /**
     * Selects a <fromEl> node at as many siblings as given in the <cells> value
     * Note: IE8 fallback assumes that a node contains exactly one word
     * @param fromEl
     * @param siblings
     */
    function selectElementText(fromEl, siblings) {
      var doc = window.document;
      var sel;
      var range;

      if (window.getSelection && doc.createRange) {
        // standards
        sel = window.getSelection();
        range = doc.createRange();
        range.setStartBefore(fromEl, 0);
        while (siblings > 1) {
          fromEl = fromEl.nextSibling;
          siblings--;
        }
        range.setEndAfter(fromEl, 0);
        sel.removeAllRanges();
        sel.addRange(range);
      } else if (doc.body.createTextRange) {
        // IE8
        range = doc.body.createTextRange();
        range.moveToElementText(fromEl);
        range.moveEnd('word', siblings + 1);
        range.select();
      }
    }

    describe('constructor', function () {
      it('should disallow fragmentSelection when set to false', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(4, 4),
          fragmentSelection: false
        });
        selectElementText(this.$container.find('tr:eq(0) td:eq(1)')[0], 3);

        mouseDown(this.$container.find('tr:eq(0) td:eq(3)'));
        mouseUp(this.$container.find('tr:eq(0) td:eq(3)'));

        var sel = getSelected();
        expect(sel).toEqual(false);
      });

      it('should allow fragmentSelection when set to true', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(4, 4),
          fragmentSelection: true
        });
        selectElementText(this.$container.find('td')[1], 3);

        mouseDown(this.$container.find('tr:eq(0) td:eq(3)'));
        mouseUp(this.$container.find('tr:eq(0) td:eq(3)'));

        var sel = getSelected();
        sel = sel.replace(/\s/g, ''); // tabs and spaces between <td>s are inconsistent in browsers, so let's ignore them
        expect(sel).toEqual('B1C1D1');
      });

      it('should allow fragmentSelection from one cell when set to `cell`', function () {
        var hot = handsontable({
          data: Handsontable.helper.createSpreadsheetData(4, 4),
          fragmentSelection: 'cell'
        });
        selectElementText(this.$container.find('td')[1], 1);

        mouseDown(this.$container.find('tr:eq(0) td:eq(1)'));
        mouseOver(this.$container.find('tr:eq(0) td:eq(1)'));
        mouseMove(this.$container.find('tr:eq(0) td:eq(1)'));
        mouseUp(this.$container.find('tr:eq(0) td:eq(1)'));

        expect(getSelected().replace(/\s/g, '')).toEqual('B1');
      });

      it('should disallow fragmentSelection from one cell when set to `cell` and when user selects adjacent cell', function () {
        var hot = handsontable({
          data: Handsontable.helper.createSpreadsheetData(4, 4),
          fragmentSelection: 'cell'
        });
        selectElementText(this.$container.find('td')[1], 1);

        mouseDown(this.$container.find('tr:eq(0) td:eq(1)'));
        mouseOver(this.$container.find('tr:eq(0) td:eq(2)'));
        mouseMove(this.$container.find('tr:eq(0) td:eq(2)'));
        mouseUp(this.$container.find('tr:eq(0) td:eq(2)'));

        expect(getSelected()).toEqual(false);
      });

      it('should disallow fragmentSelection of Handsontable chrome (anything that is not table) when set to false', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(4, 4),
          fragmentSelection: false
        });
        var $div = $('<div style="position: absolute; top: 0; left: 0">Text</div>');
        this.$container.append($div);
        selectElementText($div[0], 1);

        mouseDown($div);

        var sel = getSelected();
        expect(sel).toEqual(false);
      });

      it('should disallow fragmentSelection of Handsontable chrome (anything that is not table) when set to true', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(4, 4),
          fragmentSelection: true
        });
        var $div = $('<div style="position: absolute; top: 0; left: 0">Text</div>');
        this.$container.append($div);
        selectElementText($div[0], 1);

        mouseDown($div);

        var sel = getSelected();
        expect(sel).toEqual(false);
      });
    });

    describe('dynamic', function () {
      it('should disallow fragmentSelection when set to false', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(4, 4),
          fragmentSelection: true
        });
        updateSettings({ fragmentSelection: false });
        selectElementText(this.$container.find('tr:eq(0) td:eq(1)')[0], 3);

        mouseDown(this.$container.find('tr:eq(0) td:eq(3)'));
        mouseUp(this.$container.find('tr:eq(0) td:eq(3)'));

        var sel = getSelected();
        expect(sel).toEqual(false);
      });

      it('should allow fragmentSelection when set to true', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(4, 4),
          fragmentSelection: false
        });
        updateSettings({ fragmentSelection: true });
        selectElementText(this.$container.find('td')[1], 3);

        mouseDown(this.$container.find('tr:eq(0) td:eq(3)'));
        mouseUp(this.$container.find('tr:eq(0) td:eq(3)'));

        var sel = getSelected();
        sel = sel.replace(/\s/g, ''); // tabs and spaces between <td>s are inconsistent in browsers, so let's ignore them
        expect(sel).toEqual('B1C1D1');
      });
    });
  });
});

/***/ }),
/* 235 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('settings', function () {
  describe('maxCols', function () {
    var id = 'testContainer';

    beforeEach(function () {
      this.$container = $('<div id="' + id + '"></div>').appendTo('body');
    });

    afterEach(function () {
      if (this.$container) {
        destroy();
        this.$container.remove();
      }
    });

    describe('works on init', function () {
      it('should show data properly when `maxCols` is set to 0', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(10, 10),
          maxCols: 0
        });

        expect(getSourceDataAtRow(0).length).toEqual(10);
        expect(countSourceCols()).toEqual(10);
        expect(getData().length).toEqual(0);
        expect(getDataAtRow(0)).toEqual([]);
        expect(countCols()).toEqual(0);
        expect(countEmptyCols()).toEqual(0);
        expect(getDataAtCol(0)).toEqual([]);
        expect(getDataAtCol(1)).toEqual([]);
      });

      it('should show data properly when `maxCols` is set to value > 0', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(10, 10),
          maxCols: 5
        });

        expect(getSourceDataAtRow(0).length).toEqual(10);
        expect(countSourceCols()).toEqual(10);
        expect(getData()[0].length).toEqual(5);
        expect(getDataAtRow(0).length).toEqual(5);
        expect(countCols()).toEqual(5);
        expect(countEmptyCols()).toEqual(0);
        expect(getDataAtCol(6)).toEqual([]);
      });

      it('should show data properly when `maxCols` is set to infinity value', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(10, 10),
          maxCols: Infinity
        });

        expect(getSourceDataAtRow(0).length).toEqual(10);
        expect(countSourceCols()).toEqual(10);
        expect(getData()[0].length).toEqual(10);
        expect(getDataAtRow(0).length).toEqual(10);
        expect(countCols()).toEqual(10);
        expect(countEmptyCols()).toEqual(0);
        expect(getDataAtCol(0)).toEqual(['A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'A8', 'A9', 'A10']);
      });

      describe('when `columns` property was set', function () {
        it('should show data properly when `maxCols` is set to value > 0', function () {
          handsontable({
            columns: [{ type: 'text' }, { type: 'text' }, { type: 'text' }, { type: 'text' }, { type: 'text' }],
            minRows: 10,
            maxCols: 2
          });

          expect(getSourceDataAtRow(0).length).toEqual(5);
          expect(countSourceCols()).toEqual(5);
          expect(getData()[0].length).toEqual(2);
          expect(getDataAtRow(0).length).toEqual(2);
          expect(countCols()).toEqual(2);
          expect(getDataAtCol(3)).toEqual([]);
        });
      });
    });

    describe('update settings works', function () {
      it('should show data properly after maxCols is updated to 0', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(10, 10)
        });

        updateSettings({
          maxCols: 0
        });

        expect(getSourceDataAtRow(0).length).toEqual(10);
        expect(countSourceCols()).toEqual(10);
        expect(getData().length).toEqual(0);
        expect(getDataAtRow(0)).toEqual([]);
        expect(countCols()).toEqual(0);
        expect(getDataAtCol(0)).toEqual([]);
        expect(getDataAtCol(1)).toEqual([]);
      });

      it('should show data properly after maxCols is updated to value > 0 -> test no. 1', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(10, 10)
        });

        updateSettings({
          maxCols: 2
        });

        expect(getSourceDataAtRow(0).length).toEqual(10);
        expect(countSourceCols()).toEqual(10);
        expect(getData()[0].length).toEqual(2);
        expect(getDataAtRow(0).length).toEqual(2);
        expect(countCols()).toEqual(2);
        expect(countEmptyCols()).toEqual(0);
        expect(getDataAtCol(3)).toEqual([]);
      });

      it('should show data properly after maxCols is updated to value > 0 -> test no. 2', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(10, 10),
          maxCols: 5
        });

        updateSettings({
          maxCols: 2
        });

        expect(getSourceDataAtRow(0).length).toEqual(10);
        expect(countSourceCols()).toEqual(10);
        expect(getData()[0].length).toEqual(2);
        expect(getDataAtRow(0).length).toEqual(2);
        expect(countCols()).toEqual(2);
        expect(countEmptyCols()).toEqual(0);
        expect(getDataAtCol(3)).toEqual([]);
      });

      it('should show data properly after maxCols is updated to value > 0 -> test no. 3', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(10, 10),
          maxCols: 2
        });

        updateSettings({
          maxCols: 5
        });

        expect(getSourceDataAtRow(0).length).toEqual(10);
        expect(countSourceCols()).toEqual(10);
        expect(getData()[0].length).toEqual(5);
        expect(getDataAtRow(0).length).toEqual(5);
        expect(countCols()).toEqual(5);
        expect(countEmptyCols()).toEqual(0);
        expect(getDataAtCol(6)).toEqual([]);
      });

      it('should show data properly after maxCols is updated to infinity value -> test no. 1', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(10, 10)
        });

        updateSettings({
          maxCols: Infinity
        });

        expect(getSourceDataAtRow(0).length).toEqual(10);
        expect(countSourceCols()).toEqual(10);
        expect(getData()[0].length).toEqual(10);
        expect(getDataAtRow(0).length).toEqual(10);
        expect(countCols()).toEqual(10);
        expect(countEmptyCols()).toEqual(0);
        expect(getDataAtCol(0)).toEqual(['A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'A8', 'A9', 'A10']);
      });

      it('should show data properly after maxCols is updated to infinity value -> test no. 2', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(10, 10),
          maxCols: 2
        });

        updateSettings({
          maxCols: Infinity
        });

        expect(getSourceDataAtRow(0).length).toEqual(10);
        expect(countSourceCols()).toEqual(10);
        expect(getData()[0].length).toEqual(10);
        expect(getDataAtRow(0).length).toEqual(10);
        expect(countCols()).toEqual(10);
        expect(countEmptyCols()).toEqual(0);
        expect(getDataAtCol(0)).toEqual(['A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'A8', 'A9', 'A10']);
      });

      describe('works when `columns` property was set', function () {
        it('should show data properly when `maxCols` is updated to value > 0', function () {
          handsontable({
            columns: [{ type: 'text' }, { type: 'text' }, { type: 'text' }, { type: 'text' }, { type: 'text' }],
            minRows: 10
          });

          updateSettings({
            maxCols: 2
          });

          expect(getSourceDataAtRow(0).length).toEqual(5);
          expect(countSourceCols()).toEqual(5);
          expect(getData()[0].length).toEqual(2);
          expect(getDataAtRow(0).length).toEqual(2);
          expect(countCols()).toEqual(2);
          expect(getDataAtCol(0).length).toEqual(10);
        });
      });
    });
  });
});

/***/ }),
/* 236 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('settings', function () {
  describe('maxRows', function () {
    var id = 'testContainer';

    beforeEach(function () {
      this.$container = $('<div id="' + id + '"></div>').appendTo('body');
    });

    afterEach(function () {
      if (this.$container) {
        destroy();
        this.$container.remove();
      }
    });

    describe('works on init', function () {
      it('should show data properly when `maxRows` is set to 0', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(10, 10),
          maxRows: 0
        });

        expect(getSourceDataAtCol(0).length).toEqual(10);
        expect(countSourceRows()).toEqual(10);
        expect(getData().length).toEqual(0);
        expect(getDataAtCol(0)).toEqual([]);
        expect(countRows()).toEqual(0);
        expect(countEmptyRows()).toEqual(0);
        expect(getDataAtRow(0)).toEqual([]);
        expect(getDataAtRow(1)).toEqual([]);
      });

      it('should show data properly when `maxRows` is set to value > 0', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(10, 10),
          maxRows: 5
        });

        expect(getSourceDataAtCol(0).length).toEqual(10);
        expect(countSourceRows()).toEqual(10);
        expect(getData().length).toEqual(5);
        expect(getDataAtCol(0).length).toEqual(5);
        expect(countRows()).toEqual(5);
        expect(countEmptyRows()).toEqual(0);
        expect(getDataAtRow(6)).toEqual([]);
      });

      it('should show data properly when `maxRows` is set to infinity value', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(10, 10),
          maxRows: Infinity
        });

        expect(getSourceDataAtCol(0).length).toEqual(10);
        expect(countSourceRows()).toEqual(10);
        expect(getData().length).toEqual(10);
        expect(getDataAtCol(0).length).toEqual(10);
        expect(countRows()).toEqual(10);
        expect(countEmptyRows()).toEqual(0);
        expect(getDataAtRow(0)).toEqual(['A1', 'B1', 'C1', 'D1', 'E1', 'F1', 'G1', 'H1', 'I1', 'J1']);
      });
    });

    describe('update settings works', function () {
      it('should show data properly after maxRows is updated to 0', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(10, 10)
        });

        updateSettings({
          maxRows: 0
        });

        expect(getSourceDataAtCol(0).length).toEqual(10);
        expect(countSourceRows()).toEqual(10);
        expect(getData().length).toEqual(0);
        expect(getDataAtCol(0)).toEqual([]);
        expect(countRows()).toEqual(0);
        expect(countEmptyRows()).toEqual(0);
        expect(getDataAtRow(0)).toEqual([]);
        expect(getDataAtRow(1)).toEqual([]);
      });

      it('should show data properly after maxRows is updated to value > 0 -> test no. 1', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(10, 10)
        });

        updateSettings({
          maxRows: 2
        });

        expect(getSourceDataAtCol(0).length).toEqual(10);
        expect(countSourceRows()).toEqual(10);
        expect(getData().length).toEqual(2);
        expect(getDataAtCol(0).length).toEqual(2);
        expect(countRows()).toEqual(2);
        expect(countEmptyRows()).toEqual(0);
        expect(getDataAtRow(3)).toEqual([]);
      });

      it('should show data properly after maxRows is updated to value > 0 -> test no. 2', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(10, 10),
          maxRows: 5
        });

        updateSettings({
          maxRows: 2
        });

        expect(getSourceDataAtCol(0).length).toEqual(10);
        expect(countSourceRows()).toEqual(10);
        expect(getData().length).toEqual(2);
        expect(getDataAtCol(0).length).toEqual(2);
        expect(countRows()).toEqual(2);
        expect(countEmptyRows()).toEqual(0);
        expect(getDataAtRow(3)).toEqual([]);
      });

      it('should show data properly after maxRows is updated to value > 0 -> test no. 3', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(10, 10),
          maxRows: 2
        });

        updateSettings({
          maxRows: 5
        });

        expect(getSourceDataAtCol(0).length).toEqual(10);
        expect(countSourceRows()).toEqual(10);
        expect(getData().length).toEqual(5);
        expect(getDataAtCol(0).length).toEqual(5);
        expect(countRows()).toEqual(5);
        expect(countEmptyRows()).toEqual(0);
        expect(getDataAtRow(6)).toEqual([]);
      });

      it('should show data properly after maxRows is updated to infinity value -> test no. 1', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(10, 10)
        });

        updateSettings({
          maxRows: Infinity
        });

        expect(getSourceDataAtCol(0).length).toEqual(10);
        expect(countSourceRows()).toEqual(10);
        expect(getData().length).toEqual(10);
        expect(getDataAtCol(0).length).toEqual(10);
        expect(countRows()).toEqual(10);
        expect(countEmptyRows()).toEqual(0);
        expect(getDataAtRow(0)).toEqual(['A1', 'B1', 'C1', 'D1', 'E1', 'F1', 'G1', 'H1', 'I1', 'J1']);
      });

      it('should show data properly after maxRows is updated to infinity value -> test no. 2', function () {
        handsontable({
          data: Handsontable.helper.createSpreadsheetData(10, 10),
          maxRows: 2
        });

        updateSettings({
          maxRows: Infinity
        });

        expect(getSourceDataAtCol(0).length).toEqual(10);
        expect(countSourceRows()).toEqual(10);
        expect(getData().length).toEqual(10);
        expect(getDataAtCol(0).length).toEqual(10);
        expect(countRows()).toEqual(10);
        expect(countEmptyRows()).toEqual(0);
        expect(getDataAtRow(0)).toEqual(['A1', 'B1', 'C1', 'D1', 'E1', 'F1', 'G1', 'H1', 'I1', 'J1']);
      });
    });
  });
});

/***/ }),
/* 237 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('settings', function () {
  describe('renderer', function () {
    var id = 'testContainer';

    beforeEach(function () {
      this.$container = $('<div id="' + id + '"></div>').appendTo('body');
    });

    afterEach(function () {
      if (this.$container) {
        destroy();
        this.$container.remove();
      }
    });

    describe('defined in constructor', function () {
      it('should use text renderer by default', function () {
        var originalTextRenderer = Handsontable.cellTypes.text.renderer;

        spyOn(Handsontable.cellTypes.text, 'renderer');
        Handsontable.renderers.registerRenderer('text', Handsontable.cellTypes.text.renderer);

        handsontable();
        expect(Handsontable.cellTypes.text.renderer).toHaveBeenCalled();

        Handsontable.renderers.registerRenderer('text', originalTextRenderer);
      });

      it('should use renderer from predefined string', function () {
        var originalTextRenderer = Handsontable.renderers.TextRenderer;
        spyOn(Handsontable.renderers, 'TextRenderer');
        Handsontable.renderers.registerRenderer('text', Handsontable.renderers.TextRenderer);

        var originalCheckboxRenderer = Handsontable.renderers.CheckboxRenderer;
        spyOn(Handsontable.renderers, 'CheckboxRenderer');
        Handsontable.renderers.registerRenderer('checkbox', Handsontable.renderers.CheckboxRenderer);

        handsontable({
          columns: [{
            renderer: 'checkbox'
          }]
        });
        expect(Handsontable.renderers.TextRenderer).not.toHaveBeenCalled();
        expect(Handsontable.renderers.CheckboxRenderer).toHaveBeenCalled();

        Handsontable.renderers.registerRenderer('text', originalTextRenderer);
        Handsontable.renderers.registerRenderer('checkbox', originalCheckboxRenderer);
      });

      it('should use renderer from predefined string when columns is a function', function () {
        var originalTextRenderer = Handsontable.renderers.TextRenderer;

        spyOn(Handsontable.renderers, 'TextRenderer');
        Handsontable.renderers.registerRenderer('text', Handsontable.renderers.TextRenderer);

        var originalCheckboxRenderer = Handsontable.renderers.CheckboxRenderer;
        spyOn(Handsontable.renderers, 'CheckboxRenderer');
        Handsontable.renderers.registerRenderer('checkbox', Handsontable.renderers.CheckboxRenderer);

        handsontable({
          columns: function columns(column) {
            return column === 0 ? { renderer: 'checkbox' } : null;
          }
        });
        expect(Handsontable.renderers.TextRenderer).not.toHaveBeenCalled();
        expect(Handsontable.renderers.CheckboxRenderer).toHaveBeenCalled();

        Handsontable.renderers.registerRenderer('text', originalTextRenderer);
        Handsontable.renderers.registerRenderer('checkbox', originalCheckboxRenderer);
      });

      it('should use renderer from custom function', function () {
        var called = false;

        function myRenderer() {
          called = true;
        }

        handsontable({
          columns: [{
            renderer: myRenderer
          }]
        });

        expect(called).toBe(true);
      });

      it('should use renderer from custom function when columns is a function', function () {
        var called = false;

        function myRenderer() {
          called = true;
        }

        handsontable({
          columns: function columns(column) {
            return column === 0 ? { renderer: myRenderer } : null;
          }
        });

        expect(called).toBe(true);
      });

      it('should use renderer from custom string', function () {
        var myRenderer = jasmine.createSpy('myRenderer');

        Handsontable.renderers.registerRenderer('myRenderer', myRenderer);

        handsontable({
          columns: [{
            renderer: 'myRenderer'
          }]
        });

        expect(myRenderer).toHaveBeenCalled();
      });

      it('should use renderer from custom string when columns is a function', function () {
        var myRenderer = jasmine.createSpy('myRenderer');

        Handsontable.renderers.registerRenderer('myRenderer', myRenderer);

        handsontable({
          columns: function columns(column) {
            return column === 0 ? { renderer: 'myRenderer' } : null;
          }
        });

        expect(myRenderer).toHaveBeenCalled();
      });
    });

    it('should call renderer with cellProperties.row, cellProperties.col matching row and col arguments', function () {
      var rendererSpy = jasmine.createSpy('rendererSpy').and.callThrough();
      var cellPropertiesCache = [];

      rendererSpy.and.callFake(function (instance, TD, row, col, prop, value, cellProperties) {
        cellPropertiesCache.push({
          row: cellProperties.row,
          col: cellProperties.col
        });
      });

      handsontable({
        renderer: rendererSpy
      });

      for (var i = 0, len = rendererSpy.calls.count(); i < len; i++) {
        var args = rendererSpy.calls.argsFor(i);
        var row = args[2];
        var col = args[3];
        var cellProperties = cellPropertiesCache[i];

        expect(row).toEqual(cellProperties.row);
        expect(col).toEqual(cellProperties.col);
      }
    });

    it('should call cells function before passing cellProperties to renderer', function () {
      var rendererSpy = jasmine.createSpy('rendererSpy').and.callThrough();
      var cellPropertiesCache = [];

      rendererSpy.and.callFake(function (instance, TD, row, col, prop, value, cellProperties) {
        cellPropertiesCache.push({
          cellsRow: cellProperties.cellsRow,
          cellsCol: cellProperties.cellsCol
        });
      });

      handsontable({
        renderer: rendererSpy,
        cells: function cells(row, col) {
          return {
            cellsRow: row,
            cellsCol: col
          };
        }
      });

      for (var i = 0, len = rendererSpy.calls.count(); i < len; i++) {
        var args = rendererSpy.calls.argsFor(i);
        var row = args[2];
        var col = args[3];
        var cellProperties = cellPropertiesCache[i];

        expect(row).toEqual(cellProperties.cellsRow);
        expect(col).toEqual(cellProperties.cellsCol);
      }
    });
  });
});

/***/ }),
/* 238 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('settings', function () {
  describe('tableClassName', function () {
    var id = 'testContainer';

    beforeEach(function () {
      this.$container = $('<div id="' + id + '"></div>').appendTo('body');
    });

    afterEach(function () {
      if (this.$container) {
        destroy();
        this.$container.remove();
      }
    });

    it('should add class name every table element inside handsontable wrapper element (as string, without overlays)', function () {
      var hot = handsontable({
        colHeaders: false,
        rowHeaders: false,
        tableClassName: 'foo'
      });

      var possibleCounts = [3, 4]; // 3 for non-pro, 4 for pro (bottom overlay)

      // all overlays is created anyway but without left-top corner
      expect(possibleCounts.indexOf(hot.rootElement.querySelectorAll('table.foo').length)).toBeGreaterThan(-1);
    });

    it('should add class name every table element inside handsontable wrapper element (as string, with overlays)', function () {
      var hot = handsontable({
        colHeaders: true,
        rowHeaders: true,
        tableClassName: 'foo'
      });

      var possibleCounts = [4, 5]; // 4 for non-pro, 5 for pro (bottom overlay)

      expect(possibleCounts.indexOf(hot.rootElement.querySelectorAll('table.foo').length)).toBeGreaterThan(-1);
    });

    it('should add class name every table element inside handsontable wrapper element (as string with spaces, without overlays)', function () {
      var hot = handsontable({
        colHeaders: false,
        rowHeaders: false,
        tableClassName: 'foo bar'
      });

      var possibleCounts = [3, 4]; // 3 for non-pro, 4 for pro (bottom overlay)

      // all overlays is created anyway but without left-top corner
      expect(possibleCounts.indexOf(hot.rootElement.querySelectorAll('table.foo').length)).toBeGreaterThan(-1);
      expect(possibleCounts.indexOf(hot.rootElement.querySelectorAll('table.bar').length)).toBeGreaterThan(-1);
    });

    it('should add class name every table element inside handsontable wrapper element (as string with spaces, with overlays)', function () {
      var hot = handsontable({
        colHeaders: true,
        rowHeaders: true,
        tableClassName: 'foo bar'
      });

      var possibleCounts = [4, 5]; // 4 for non-pro, 5 for pro (bottom overlay)

      expect(possibleCounts.indexOf(hot.rootElement.querySelectorAll('table.foo').length)).toBeGreaterThan(-1);
      expect(possibleCounts.indexOf(hot.rootElement.querySelectorAll('table.bar').length)).toBeGreaterThan(-1);
    });

    it('should add class name every table element inside handsontable wrapper element (as array, without overlays)', function () {
      var hot = handsontable({
        colHeaders: false,
        rowHeaders: false,
        tableClassName: ['foo', 'bar', 'baz']
      });

      var possibleCounts = [3, 4]; // 3 for non-pro, 4 for pro (bottom overlay)

      expect(possibleCounts.indexOf(hot.rootElement.querySelectorAll('table.foo').length)).toBeGreaterThan(-1);
      expect(possibleCounts.indexOf(hot.rootElement.querySelectorAll('table.bar').length)).toBeGreaterThan(-1);
      expect(possibleCounts.indexOf(hot.rootElement.querySelectorAll('table.baz').length)).toBeGreaterThan(-1);
    });

    it('should add class name every table element inside handsontable wrapper element (as array, with overlays)', function () {
      var hot = handsontable({
        colHeaders: true,
        rowHeaders: true,
        tableClassName: ['foo', 'bar', 'baz']
      });

      var possibleCounts = [4, 5]; // 4 for non-pro, 5 for pro (bottom overlay)

      expect(possibleCounts.indexOf(hot.rootElement.querySelectorAll('table.foo').length)).toBeGreaterThan(-1);
      expect(possibleCounts.indexOf(hot.rootElement.querySelectorAll('table.bar').length)).toBeGreaterThan(-1);
      expect(possibleCounts.indexOf(hot.rootElement.querySelectorAll('table.baz').length)).toBeGreaterThan(-1);
    });
  });
});

/***/ }),
/* 239 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('GhostTable', function () {

  var hotSettings = {
    data: [['A', '1', 'A\nB\nC'], ['B', '2', 'A-----B-------C'], ['C', '3', 'A---\n--B-------C']]
  };
  var gt;

  beforeEach(function () {
    this.$container = $('<div id="testContainer"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
    if (gt) {
      gt.clean();
      gt = null;
    }
  });

  describe('row', function () {
    it('should throw exception if we try to add column after added row', function () {
      var hot = handsontable(hotSettings);
      var exception = false;
      var samples = new Map();
      gt = new Handsontable.__GhostTable(hot);

      gt.addRow(0, samples);

      try {
        gt.addColumn(0, samples);
      } catch (ex) {
        exception = true;
      }

      expect(exception).toBe(true);
    });

    it('should create container element only for first row', function () {
      var hot = handsontable(hotSettings);
      var samples = new Map();
      gt = new Handsontable.__GhostTable(hot);

      spyOn(gt, 'createContainer').and.callThrough();

      gt.addRow(0, samples);
      gt.addRow(0, samples);
      gt.addRow(0, samples);
      gt.addRow(1, samples);
      gt.addRow(2, samples);

      expect(gt.createContainer.calls.count()).toBe(1);
      expect(gt.createContainer.calls.mostRecent().args).toEqual(['handsontable']);
    });

    it('should add row to rows collection after call `addRow` method', function () {
      var hot = handsontable(hotSettings);
      var samples = new Map();
      gt = new Handsontable.__GhostTable(hot);

      expect(gt.rows.length).toBe(0);

      samples.clear();
      samples.set(0, { strings: [{ value: 'Foo', row: 0 }, { value: 'Foo Bar', row: 0 }] });

      gt.addRow(0, samples);

      expect(gt.rows.length).toBe(1);
      expect(gt.rows[0].row).toBe(0);
      expect(gt.rows[0].table.className).toBe('htCore');
      expect(gt.rows[0].table.nodeName).toBe('TABLE');
      expect(gt.rows[0].table.querySelectorAll('colgroup > col').length).toBe(2);
      expect(gt.rows[0].table.querySelector('tbody > tr > td').innerHTML).toBe('Foo');

      samples.clear();
      samples.set(0, { strings: [{ value: 'Bar', row: 1 }, { value: 'Baz1234', row: 1 }] });

      gt.addRow(1, samples);

      expect(gt.rows.length).toBe(2);
      expect(gt.rows[1].row).toBe(1);
      expect(gt.rows[1].table.className).toBe('htCore');
      expect(gt.rows[1].table.nodeName).toBe('TABLE');
      expect(gt.rows[1].table.querySelectorAll('colgroup > col').length).toBe(2);
      expect(gt.rows[1].table.querySelector('tbody > tr > td').innerHTML).toBe('Bar');
    });

    it('should get valid heights', function () {
      var hot = handsontable(hotSettings);
      var heightSpy = jasmine.createSpy();
      var samples = new Map();
      gt = new Handsontable.__GhostTable(hot);

      samples.clear();
      samples.set(0, { strings: [{ value: 'Foo', row: 0 }, { value: 'Foo.....Bar', row: 0 }] });

      gt.addRow(0, samples);

      samples.clear();
      samples.set(0, { strings: [{ value: 'Foo\nBar\nsqw', row: 1 }] });

      gt.addRow(1, samples);

      samples.clear();
      samples.set(0, { strings: [{ value: 'Foo', row: 0 }, { value: 'Foo Bar', row: 0 }] });

      gt.addRow(2, samples);
      gt.getHeights(heightSpy);

      expect(heightSpy.calls.count()).toBe(3);
      expect(heightSpy.calls.argsFor(0)[0]).toBe(0);
      expect(heightSpy.calls.argsFor(0)[1]).toBe(23);
      expect(heightSpy.calls.argsFor(1)[0]).toBe(1);
      expect(heightSpy.calls.argsFor(1)[1]).toBe(64);
      expect(heightSpy.calls.argsFor(2)[0]).toBe(2);
      expect(heightSpy.calls.argsFor(2)[1]).toBe(43);
    });
  });

  describe('column', function () {
    it('should throw exception if we try to add row after added column', function () {
      var hot = handsontable(hotSettings);
      var exception = false;
      var samples = new Map();
      gt = new Handsontable.__GhostTable(hot);

      gt.addColumn(0, samples);

      try {
        gt.addRow(0, samples);
      } catch (ex) {
        exception = true;
      }

      expect(exception).toBe(true);
    });

    it('should create container element only for first column', function () {
      var hot = handsontable(hotSettings);
      var samples = new Map();
      gt = new Handsontable.__GhostTable(hot);

      spyOn(gt, 'createContainer').and.callThrough();

      gt.addColumn(0, samples);
      gt.addColumn(0, samples);
      gt.addColumn(0, samples);
      gt.addColumn(1, samples);
      gt.addColumn(2, samples);

      expect(gt.createContainer.calls.count()).toBe(1);
      expect(gt.createContainer.calls.mostRecent().args).toEqual(['handsontable']);
    });

    it('should add column to columns collection after call `addColumn` method', function () {
      var hot = handsontable(hotSettings);
      var samples = new Map();
      gt = new Handsontable.__GhostTable(hot);

      expect(gt.columns.length).toBe(0);

      samples.clear();
      samples.set(0, { strings: [{ value: 'Foo', col: 0 }, { value: 'Foo Bar', col: 0 }] });

      gt.addColumn(0, samples);

      expect(gt.columns.length).toBe(1);
      expect(gt.columns[0].col).toBe(0);
      expect(gt.columns[0].table.className).toBe('htCore');
      expect(gt.columns[0].table.style.width).toBe('auto');
      expect(gt.columns[0].table.style.tableLayout).toBe('auto');
      expect(gt.columns[0].table.nodeName).toBe('TABLE');
      expect(gt.columns[0].table.querySelectorAll('thead > tr > th').length).toBe(1);
      expect(gt.columns[0].table.querySelector('tbody > tr > td').innerHTML).toBe('Foo');

      samples.clear();
      samples.set(0, { strings: [{ value: 'Bar', row: 1 }, { value: 'Baz1234', row: 1 }] });

      gt.addColumn(1, samples);

      expect(gt.columns.length).toBe(2);
      expect(gt.columns[1].col).toBe(1);
      expect(gt.columns[1].table.className).toBe('htCore');
      expect(gt.columns[1].table.nodeName).toBe('TABLE');
      expect(gt.columns[1].table.querySelectorAll('thead > tr > th').length).toBe(1);
      expect(gt.columns[1].table.querySelector('tbody > tr > td').innerHTML).toBe('Bar');
    });

    it('should get valid widths', function () {
      var hot = handsontable(hotSettings);
      var widthSpy = jasmine.createSpy();
      var samples = new Map();
      gt = new Handsontable.__GhostTable(hot);

      samples.clear();
      samples.set(0, { strings: [{ value: 'Foo', col: 0 }, { value: 'Foo.....Bar', col: 0 }] });

      gt.addColumn(0, samples);

      samples.clear();
      samples.set(0, { strings: [{ value: 'Foo\nBar\nsqw', col: 1 }] });

      gt.addColumn(1, samples);

      samples.clear();
      samples.set(0, { strings: [{ value: 'Foo', col: 0 }, { value: 'Foo Bar', col: 0 }] });

      gt.addColumn(2, samples);
      gt.getWidths(widthSpy);

      expect(widthSpy.calls.count()).toBe(3);
      expect(widthSpy.calls.argsFor(0)[0]).toBe(0);
      expect(widthSpy.calls.argsFor(0)[1]).toBeAroundValue(87, 4);
      expect(widthSpy.calls.argsFor(1)[0]).toBe(1);
      expect(widthSpy.calls.argsFor(1)[1]).toBeAroundValue(41, 4);
      expect(widthSpy.calls.argsFor(2)[0]).toBe(2);
      expect(widthSpy.calls.argsFor(2)[1]).toBeAroundValue(68, 4);
    });
  });

  it('should reset internal state after call `clean` method', function () {
    var hot = handsontable(hotSettings);
    var samples = new Map();
    gt = new Handsontable.__GhostTable(hot);

    gt.addColumn(0, samples);
    gt.rows.push({});
    gt.getWidths(function () {});

    expect(gt.columns.length).toBe(1);
    expect(gt.samples).toBeDefined();
    expect(gt.injected).toBe(true);
    expect(gt.container).toBeDefined();
    expect(document.querySelector('.htGhostTable')).toBeDefined();

    gt.clean();

    expect(gt.columns.length).toBe(0);
    expect(gt.samples).toBe(null);
    expect(gt.injected).toBe(false);
    expect(gt.container).toBe(null);
    expect(document.querySelector('.htGhostTable')).toBe(null);
  });

  it('should be detected as vertical if at least one row is added', function () {
    var hot = handsontable(hotSettings);
    var samples = new Map();
    var gt = new Handsontable.__GhostTable(hot);

    gt.addRow(0, samples);

    expect(gt.isVertical()).toBe(true);
    expect(gt.isHorizontal()).toBe(false);
  });

  it('should be detected as horizontal if at least one column is added', function () {
    var hot = handsontable(hotSettings);
    var samples = new Map();
    var gt = new Handsontable.__GhostTable(hot);

    gt.addColumn(0, samples);

    expect(gt.isVertical()).toBe(false);
    expect(gt.isHorizontal()).toBe(true);
  });
});

/***/ }),
/* 240 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('autocompleteValidator', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  describe('allowEmpty', function () {
    it('should validate empty cells positively (by default)', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');
      var hot = handsontable({
        data: [['some', 'sample', 'data']],
        columns: [{
          type: 'autocomplete',
          source: ['some', 'sample', 'data'],
          strict: true
        }, {
          type: 'autocomplete',
          source: ['some', 'sample', 'data'],
          strict: true
        }, {
          type: 'autocomplete',
          source: ['some', 'sample', 'data'],
          strict: true
        }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(0, 0, '');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(true, '', 0, 0, undefined, undefined);
        done();
      }, 100);
    });

    it('should validate empty cells positively when allowEmpty is set to true', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');
      var hot = handsontable({
        data: [['some', 'sample', 'data']],
        columns: [{
          type: 'autocomplete',
          source: ['some', 'sample', 'data'],
          strict: true
        }, {
          type: 'autocomplete',
          source: ['some', 'sample', 'data'],
          strict: true
        }, {
          type: 'autocomplete',
          source: ['some', 'sample', 'data'],
          strict: true
        }],
        allowEmpty: true,
        afterValidate: onAfterValidate
      });

      setDataAtCell(0, 0, '');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(true, '', 0, 0, undefined, undefined);
        done();
      }, 100);
    });

    it('should validate empty cells negatively when allowEmpty is set to false', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');
      var hot = handsontable({
        data: [['some', 'sample', 'data']],
        columns: [{
          type: 'autocomplete',
          source: ['some', 'sample', 'data'],
          strict: true
        }, {
          type: 'autocomplete',
          source: ['some', 'sample', 'data'],
          strict: true
        }, {
          type: 'autocomplete',
          source: ['some', 'sample', 'data'],
          strict: true
        }],
        allowEmpty: false,
        afterValidate: onAfterValidate
      });

      setDataAtCell(0, 0, '');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(false, '', 0, 0, undefined, undefined);
        done();
      }, 100);
    });

    it('should respect the allowEmpty property for a single column', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');
      var hot = handsontable({
        data: [['some', 'sample', 'data']],
        columns: [{
          type: 'autocomplete',
          source: ['some', 'sample', 'data'],
          strict: true
        }, {
          type: 'autocomplete',
          source: ['some', 'sample', 'data'],
          strict: true,
          allowEmpty: false
        }, {
          type: 'autocomplete',
          source: ['some', 'sample', 'data'],
          strict: true
        }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(0, 0, '');
      setDataAtCell(0, 1, '');
      setDataAtCell(0, 2, '');

      setTimeout(function () {
        expect(onAfterValidate.calls.argsFor(0)).toEqual([true, '', 0, 0, undefined, undefined]);
        expect(onAfterValidate.calls.argsFor(1)).toEqual([false, '', 0, 1, undefined, undefined]);
        expect(onAfterValidate.calls.argsFor(2)).toEqual([true, '', 0, 2, undefined, undefined]);
        done();
      }, 100);
    });

    it('should work for null and undefined values in cells', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');
      var hot = handsontable({
        data: [['some', 'sample', 'data']],
        columns: [{
          type: 'autocomplete',
          source: ['some', 'sample', 'data'],
          strict: true
        }, {
          type: 'autocomplete',
          source: ['some', 'sample', 'data'],
          strict: true
        }, {
          type: 'autocomplete',
          source: ['some', 'sample', 'data'],
          strict: true
        }],
        allowEmpty: false,
        afterValidate: onAfterValidate
      });

      setDataAtCell(0, 0, null);
      setDataAtCell(0, 1, void 0);
      setDataAtCell(0, 2, '');

      setTimeout(function () {
        expect(onAfterValidate.calls.argsFor(0)).toEqual([false, null, 0, 0, undefined, undefined]);
        expect(onAfterValidate.calls.argsFor(1)).toEqual([false, void 0, 0, 1, undefined, undefined]);
        expect(onAfterValidate.calls.argsFor(2)).toEqual([false, '', 0, 2, undefined, undefined]);
        done();
      }, 100);
    });
  });
  describe('strict mode', function () {
    it('sshould validate negatively when chars have different size', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');
      var hot = handsontable({
        data: [['some', 'sample', 'data']],
        columns: [{
          type: 'autocomplete',
          source: ['some', 'sample', 'data'],
          strict: true
        }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(0, 0, 'Some');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(false, 'Some', 0, 0, undefined, undefined);
        done();
      }, 100);
    });
  });
});

/***/ }),
/* 241 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('dateValidator', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  var arrayOfObjects = function arrayOfObjects() {
    return [{ date: '01/01/2015', name: 'Ted', lastName: 'Right' }, { date: '01/01/15', name: 'Frank', lastName: 'Honest' }, { date: '41/01/2015', name: 'Joan', lastName: 'Well' }, { date: '01/51/2015', name: 'Sid', lastName: 'Strong' }];
  };

  it('should validate an empty string (default behavior)', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'date', type: 'date' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(0, 0, '');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(true, '', 0, 'date', undefined, undefined);
      done();
    }, 100);
  });

  it('should rewrite an ISO 8601 string to the correct format if a date-string in different format is provided', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'date', type: 'date', dateFormat: 'MM/DD/YYYY', correctFormat: true }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(1, 0, '2016-03-18');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(true, '2016-03-18', 1, 'date', undefined, undefined);
    }, 100);

    setTimeout(function () {
      expect(getDataAtCell(1, 0)).toEqual('03/18/2016');
      done();
    }, 130);
  });

  it('should not positively validate a non-date string', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'date', type: 'date' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(0, 0, 'wat');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(false, 'wat', 0, 'date', undefined, undefined);
      done();
    }, 100);
  });

  it('should not positively validate a incorrect date string', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'date', type: 'date' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(0, 0, '33/01/2014');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(false, '33/01/2014', 0, 'date', undefined, undefined);
      done();
    }, 100);
  });

  it('should not positively validate a date string in wrong format', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'date', type: 'date' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(1, 0, '01/01/15');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(false, '01/01/15', 1, 'date', undefined, undefined);
      done();
    }, 100);
  });

  it('should not positively validate a date string in wrong format (if custom format is provided)', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'date', type: 'date', dateFormat: 'DD/MM/YY' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(1, 0, '01/01/2015');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(false, '01/01/2015', 1, 'date', undefined, undefined);
      done();
    }, 100);
  });

  it('should positively validate a date string in correct format', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'date', type: 'date' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(1, 0, '01/01/2015');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(true, '01/01/2015', 1, 'date', undefined, undefined);
      done();
    }, 100);
  });

  it('should positively validate a date string in correct format (if custom format is provided)', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'date', type: 'date', dateFormat: 'DD/MM/YY' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(1, 0, '23/03/15');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(true, '23/03/15', 1, 'date', undefined, undefined);
      done();
    }, 100);
  });

  describe('allowEmpty', function () {
    it('should not validate an empty string when allowEmpty is set as `false`', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'date', type: 'date', dateFormat: 'DD/MM/YY', allowEmpty: false }, { data: 'name' }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(1, 0, '');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(false, '', 1, 'date', undefined, undefined);
        done();
      }, 100);
    });

    it('should not validate `null` when allowEmpty is set as `false`', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'date', type: 'date', dateFormat: 'DD/MM/YY', allowEmpty: false }, { data: 'name' }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(1, 0, null);

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(false, null, 1, 'date', undefined, undefined);
        done();
      }, 100);
    });

    it('should not validate `undefined` when allowEmpty is set as `false`', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'date', type: 'date', dateFormat: 'DD/MM/YY', allowEmpty: false }, { data: 'name' }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(1, 0, void 0);

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(false, void 0, 1, 'date', undefined, undefined);
        done();
      }, 100);
    });
  });

  describe('correctFormat', function () {
    it('should not make any changes to entered string if correctFormat is not set', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'date', type: 'date', dateFormat: 'MM/DD/YY' }, { data: 'name' }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(1, 0, '11/23/2013');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(false, '11/23/2013', 1, 'date', undefined, undefined);
        done();
      }, 100);
    });

    it('should not make any changes to entered string if correctFormat is set to false', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'date', type: 'date', dateFormat: 'MM/DD/YY', correctFormat: false }, { data: 'name' }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(1, 0, '11/23/2013');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(false, '11/23/2013', 1, 'date', undefined, undefined);
        done();
      }, 100);
    });

    it('should rewrite the string to the correct format if a date-string in different format is provided', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'date', type: 'date', dateFormat: 'MM/DD/YYYY', correctFormat: true }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(1, 0, '1/10/15');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(true, '1/10/15', 1, 'date', undefined, undefined);
      }, 100);

      setTimeout(function () {
        expect(getDataAtCell(1, 0)).toEqual('01/10/2015');
        done();
      }, 130);
    });

    it('should rewrite the string to the correct format if a date-string in different format is provided (for non-default format)', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'date', type: 'date', dateFormat: 'DD.MM.YYYY', correctFormat: true }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(1, 0, '5.3.2016');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(true, '5.3.2016', 1, 'date', undefined, undefined);
      }, 100);

      setTimeout(function () {
        expect(getDataAtCell(1, 0)).toEqual('05.03.2016');
        done();
      }, 130);
    });

    it('should not try to correct format of non-date strings', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'date', type: 'date', dateFormat: 'DD/MM/YY', correctFormat: true }, { data: 'name' }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(1, 0, 'test non-date string');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(false, 'test non-date string', 1, 'date', undefined, undefined);
        done();
      }, 100);
    });
  });
});

/***/ }),
/* 242 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

describe('validators', function () {
  var id = 'testContainer';
  var _Handsontable$validat = Handsontable.validators,
      registerValidator = _Handsontable$validat.registerValidator,
      getValidator = _Handsontable$validat.getValidator;


  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  it('should register custom validator', _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
    var onAfterValidate, hot;
    return regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            registerValidator('myValidator', function (value, cb) {
              cb(value === 10);
            });

            onAfterValidate = jasmine.createSpy('onAfterValidate');
            hot = handsontable({
              data: [[1, 6, 10]],
              columns: [{
                validator: 'myValidator'
              }],
              afterValidate: onAfterValidate
            });


            hot.setDataAtCell(1, 0, 10);

            _context.next = 6;
            return sleep(100);

          case 6:

            expect(onAfterValidate).toHaveBeenCalledWith(true, 10, 1, 0, undefined, undefined);

            hot.setDataAtCell(2, 0, 2);

            _context.next = 10;
            return sleep(100);

          case 10:

            expect(onAfterValidate).toHaveBeenCalledWith(false, 2, 2, 0, undefined, undefined);

          case 11:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, undefined);
  })));

  it('should retrieve predefined validators by its names', function () {
    expect(getValidator('autocomplete')).toBeFunction();
    expect(getValidator('date')).toBeFunction();
    expect(getValidator('numeric')).toBeFunction();
    expect(getValidator('time')).toBeFunction();
  });

  it('should retrieve custom validator by its names', function () {
    registerValidator('myValidator', function (value, cb) {
      cb(value === 10);
    });

    getValidator('myValidator')(2, function (isValid) {
      expect(isValid).toBe(false);
    });

    getValidator('myValidator')('10', function (isValid) {
      expect(isValid).toBe(false);
    });

    getValidator('myValidator')(10, function (isValid) {
      expect(isValid).toBe(true);
    });
  });
});

/***/ }),
/* 243 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('numericValidator', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  var arrayOfObjects = function arrayOfObjects() {
    return [{ id: 1, name: 'Ted', lastName: 'Right' }, { id: 2, name: 'Frank', lastName: 'Honest' }, { id: 3, name: 'Joan', lastName: 'Well' }, { id: 4, name: 'Sid', lastName: 'Strong' }, { id: 5, name: 'Jane', lastName: 'Neat' }, { id: 6, name: 'Chuck', lastName: 'Jackson' }, { id: 7, name: 'Meg', lastName: 'Jansen' }, { id: 8, name: 'Rob', lastName: 'Norris' }, { id: 9, name: 'Sean', lastName: 'O\'Hara' }, { id: 10, name: 'Eve', lastName: 'Branson' }];
  };

  it('should validate an empty string (default behavior)', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', type: 'numeric' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(2, 0, '');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(true, '', 2, 'id', undefined, undefined);
      done();
    }, 100);
  });

  it('should not validate non numeric string', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', type: 'numeric' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(2, 0, 'test');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(false, 'test', 2, 'id', undefined, undefined);
      done();
    }, 100);
  });

  it('should validate numeric string', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', type: 'numeric' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(2, 0, '123');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(true, 123, 2, 'id', undefined, undefined);
      done();
    }, 100);
  });

  it('should validate signed numeric string', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'id', type: 'numeric' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(2, 0, '-123');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(true, -123, 2, 'id', undefined, undefined);
      done();
    }, 100);
  });

  describe('allowEmpty', function () {
    it('should not validate an empty string when allowEmpty is set as `false`', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'id', type: 'numeric', allowEmpty: false }, { data: 'name' }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(2, 0, '');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(false, '', 2, 'id', undefined, undefined);
        done();
      }, 100);
    });

    it('should not validate `null` when allowEmpty is set as `false`', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'id', type: 'numeric', allowEmpty: false }, { data: 'name' }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(2, 0, null);

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(false, null, 2, 'id', undefined, undefined);
        done();
      }, 100);
    });

    it('should not validate `undefined` when allowEmpty is set as `false`', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'id', type: 'numeric', allowEmpty: false }, { data: 'name' }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(2, 0, void 0);

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(false, void 0, 2, 'id', undefined, undefined);
        done();
      }, 100);
    });

    it('should validate 0 when allowEmpty is set as `false`', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'id', type: 'numeric', allowEmpty: false }, { data: 'name' }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(2, 0, 0);

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(true, 0, 2, 'id', undefined, undefined);
        done();
      }, 100);
    });

    it('should add / remove `htInvalid` class properly when validating non-numeric data', function (done) {
      var hot = handsontable({
        data: [{ id: 1, name: 'Ted', salary: 10000 }, { id: 2, name: 'Frank', salary: '5300' }, { id: 3, name: 'Joan', salary: 'non-numeric value' }],
        columns: [{ data: 'id' }, { data: 'name' }, { data: 'salary', type: 'numeric', allowInvalid: false }]
      });

      hot.validateCells();

      setTimeout(function () {
        expect($(getCell(1, 2)).hasClass(hot.getSettings().invalidCellClassName)).toBe(false);
        expect($(getCell(2, 2)).hasClass(hot.getSettings().invalidCellClassName)).toBe(true);

        setDataAtCell(2, 2, 8000);
      }, 200);

      setTimeout(function () {
        expect($(getCell(2, 2)).hasClass(hot.getSettings().invalidCellClassName)).toBe(false);
        done();
      }, 400);
    });
  });
});

/***/ }),
/* 244 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


describe('timeValidator', function () {
  var id = 'testContainer';

  beforeEach(function () {
    this.$container = $('<div id="' + id + '"></div>').appendTo('body');
  });

  afterEach(function () {
    if (this.$container) {
      destroy();
      this.$container.remove();
    }
  });

  var arrayOfObjects = function arrayOfObjects() {
    return [{ time: '4:10:05 am', name: 'Ted', lastName: 'Right' }, { time: '17:15:25', name: 'Frank', lastName: 'Honest' }, { time: '14:65:45 am', name: 'Joan', lastName: 'Well' }, { time: '33:25:05', name: 'Sid', lastName: 'Strong' }];
  };

  it('should validate an empty string (default behavior)', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'time', type: 'time' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(0, 0, '');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(true, '', 0, 'time', undefined, undefined);
      done();
    }, 100);
  });

  it('should not positively validate a non-date format', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'time', type: 'time' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(0, 0, 'nd');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(false, 'nd', 0, 'time', undefined, undefined);
      done();
    }, 100);
  });

  it('should not positively validate a incorrect time string', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'time', type: 'time' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(0, 0, '30:10:25');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(false, '30:10:25', 0, 'time', undefined, undefined);
      done();
    }, 100);
  });

  it('should not positively validate a time string in not default format', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'time', type: 'time' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(1, 0, '20:20:01');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(false, '20:20:01', 1, 'time', undefined, undefined);
      done();
    }, 100);
  });

  it('should not positively validate a time string in wrong format (if custom format is provided)', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'time', type: 'time', timeFormat: 'HH:mm:ss' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(1, 0, '5:10:15 am');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(false, '5:10:15 am', 1, 'time', undefined, undefined);
      done();
    }, 100);
  });

  it('should positively validate a date string in correct format (if custom format is provided)', function (done) {
    var onAfterValidate = jasmine.createSpy('onAfterValidate');

    handsontable({
      data: arrayOfObjects(),
      columns: [{ data: 'time', type: 'time', timeFormat: 'HH:mm:ss' }, { data: 'name' }, { data: 'lastName' }],
      afterValidate: onAfterValidate
    });

    setDataAtCell(1, 0, '16:32:03');

    setTimeout(function () {
      expect(onAfterValidate).toHaveBeenCalledWith(true, '16:32:03', 1, 'time', undefined, undefined);
      done();
    }, 100);
  });

  describe('allowEmpty', function () {
    it('should not validate an empty string when allowEmpty is set as `false`', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'time', type: 'time', dateFormat: 'HH:mm', allowEmpty: false }, { data: 'name' }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(1, 0, '');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(false, '', 1, 'time', undefined, undefined);
        done();
      }, 100);
    });

    it('should not validate `null` when allowEmpty is set as `false`', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'time', type: 'time', dateFormat: 'HH:mm', allowEmpty: false }, { data: 'name' }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(1, 0, null);

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(false, null, 1, 'time', undefined, undefined);
        done();
      }, 100);
    });

    it('should not validate `undefined` when allowEmpty is set as `false`', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'time', type: 'time', dateFormat: 'HH:mm', allowEmpty: false }, { data: 'name' }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(1, 0, void 0);

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(false, void 0, 1, 'time', undefined, undefined);
        done();
      }, 100);
    });
  });

  describe('correctFormat', function () {
    it('should not make any changes to entered string if correctFormat is not set', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'time', type: 'time', timeFormat: 'h:mm:ss a' }, { data: 'name' }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(1, 0, '13:00:00');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(false, '13:00:00', 1, 'time', undefined, undefined);
        done();
      }, 100);
    });

    it('should not make any changes to entered string if correctFormat is set to false', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'time', type: 'time', timeFormat: 'h:mm:ss a', correctFormat: false }, { data: 'name' }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(1, 0, '13:00:00');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(false, '13:00:00', 1, 'time', undefined, undefined);
        done();
      }, 100);
    });

    it('should rewrite the string to the correct format if a time-string in different format is provided', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'time', type: 'time', timeFormat: 'h:mm:ss a', correctFormat: true }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(1, 0, '16:35:01');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(true, '16:35:01', 1, 'time', undefined, undefined);
      }, 100);

      setTimeout(function () {
        expect(getDataAtCell(1, 0)).toEqual('4:35:01 pm');
        done();
      }, 130);
    });

    it('should rewrite the string to the correct format if a time in micro-timestamp format is provided', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'time', type: 'time', timeFormat: 'HH:mm:ss', correctFormat: true }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      var currentDateTime = new Date();

      setDataAtCell(1, 0, currentDateTime.getTime()); // timestamp in milliseconds

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(true, currentDateTime.getTime(), 1, 'time', undefined, undefined);
      }, 100);

      setTimeout(function () {
        var addLeadingZero = function addLeadingZero(number) {
          return number < 10 ? '0' + number : number;
        };
        expect(getDataAtCell(1, 0)).toEqual(addLeadingZero(currentDateTime.getHours()) + ':' + addLeadingZero(currentDateTime.getMinutes()) + ':' + addLeadingZero(currentDateTime.getSeconds()));
        done();
      }, 130);
    });

    it('should rewrite the string to the correct format if a time in ISO8601 format is provided', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'time', type: 'time', timeFormat: 'HH:mm:ss', correctFormat: true }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      var currentDateTime = new Date();

      setDataAtCell(1, 0, currentDateTime.toISOString()); // ISO-formatted datetime, sth like '2016-02-19T12:40:04.983Z'

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(true, currentDateTime.toISOString(), 1, 'time', undefined, undefined);
      }, 100);

      setTimeout(function () {
        var addLeadingZero = function addLeadingZero(number) {
          return number < 10 ? '0' + number : number;
        };

        expect(getDataAtCell(1, 0)).toEqual(addLeadingZero(currentDateTime.getHours()) + ':' + addLeadingZero(currentDateTime.getMinutes()) + ':' + addLeadingZero(currentDateTime.getSeconds()));
        done();
      }, 130);
    });

    it('should rewrite one and two-digit number to the correct format at hours', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'time', type: 'time', timeFormat: 'hh:mm:ss a', correctFormat: true }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(1, 0, '19');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(true, '19', 1, 'time', undefined, undefined);
      }, 100);

      setTimeout(function () {
        expect(getDataAtCell(1, 0)).toEqual('07:00:00 pm');
        done();
      }, 130);
    });

    it('should rewrite one and two-digit number to the correct format at minutes', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'time', type: 'time', timeFormat: 'mm:ss', correctFormat: true }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(1, 0, '57');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(true, '57', 1, 'time', undefined, undefined);
      }, 100);

      setTimeout(function () {
        expect(getDataAtCell(1, 0)).toEqual('57:00');
        done();
      }, 130);
    });

    it('should not try to correct format of non-date strings', function (done) {
      var onAfterValidate = jasmine.createSpy('onAfterValidate');

      handsontable({
        data: arrayOfObjects(),
        columns: [{ data: 'time', type: 'time', timeFormat: 'HH:mm:ss', correctFormat: true }, { data: 'name' }, { data: 'lastName' }],
        afterValidate: onAfterValidate
      });

      setDataAtCell(1, 0, 'test non-time string');

      setTimeout(function () {
        expect(onAfterValidate).toHaveBeenCalledWith(false, 'test non-time string', 1, 'time', undefined, undefined);
        done();
      }, 100);
    });
  });
});

/***/ }),
/* 245 */,
/* 246 */
/***/ (function(module, exports) {


/**
 * slice() reference.
 */

var slice = Array.prototype.slice;

/**
 * Expose `co`.
 */

module.exports = co['default'] = co.co = co;

/**
 * Wrap the given generator `fn` into a
 * function that returns a promise.
 * This is a separate function so that
 * every `co()` call doesn't create a new,
 * unnecessary closure.
 *
 * @param {GeneratorFunction} fn
 * @return {Function}
 * @api public
 */

co.wrap = function (fn) {
  createPromise.__generatorFunction__ = fn;
  return createPromise;
  function createPromise() {
    return co.call(this, fn.apply(this, arguments));
  }
};

/**
 * Execute the generator function or a generator
 * and return a promise.
 *
 * @param {Function} fn
 * @return {Promise}
 * @api public
 */

function co(gen) {
  var ctx = this;
  var args = slice.call(arguments, 1)

  // we wrap everything in a promise to avoid promise chaining,
  // which leads to memory leak errors.
  // see https://github.com/tj/co/issues/180
  return new Promise(function(resolve, reject) {
    if (typeof gen === 'function') gen = gen.apply(ctx, args);
    if (!gen || typeof gen.next !== 'function') return resolve(gen);

    onFulfilled();

    /**
     * @param {Mixed} res
     * @return {Promise}
     * @api private
     */

    function onFulfilled(res) {
      var ret;
      try {
        ret = gen.next(res);
      } catch (e) {
        return reject(e);
      }
      next(ret);
    }

    /**
     * @param {Error} err
     * @return {Promise}
     * @api private
     */

    function onRejected(err) {
      var ret;
      try {
        ret = gen.throw(err);
      } catch (e) {
        return reject(e);
      }
      next(ret);
    }

    /**
     * Get the next value in the generator,
     * return a promise.
     *
     * @param {Object} ret
     * @return {Promise}
     * @api private
     */

    function next(ret) {
      if (ret.done) return resolve(ret.value);
      var value = toPromise.call(ctx, ret.value);
      if (value && isPromise(value)) return value.then(onFulfilled, onRejected);
      return onRejected(new TypeError('You may only yield a function, promise, generator, array, or object, '
        + 'but the following object was passed: "' + String(ret.value) + '"'));
    }
  });
}

/**
 * Convert a `yield`ed value into a promise.
 *
 * @param {Mixed} obj
 * @return {Promise}
 * @api private
 */

function toPromise(obj) {
  if (!obj) return obj;
  if (isPromise(obj)) return obj;
  if (isGeneratorFunction(obj) || isGenerator(obj)) return co.call(this, obj);
  if ('function' == typeof obj) return thunkToPromise.call(this, obj);
  if (Array.isArray(obj)) return arrayToPromise.call(this, obj);
  if (isObject(obj)) return objectToPromise.call(this, obj);
  return obj;
}

/**
 * Convert a thunk to a promise.
 *
 * @param {Function}
 * @return {Promise}
 * @api private
 */

function thunkToPromise(fn) {
  var ctx = this;
  return new Promise(function (resolve, reject) {
    fn.call(ctx, function (err, res) {
      if (err) return reject(err);
      if (arguments.length > 2) res = slice.call(arguments, 1);
      resolve(res);
    });
  });
}

/**
 * Convert an array of "yieldables" to a promise.
 * Uses `Promise.all()` internally.
 *
 * @param {Array} obj
 * @return {Promise}
 * @api private
 */

function arrayToPromise(obj) {
  return Promise.all(obj.map(toPromise, this));
}

/**
 * Convert an object of "yieldables" to a promise.
 * Uses `Promise.all()` internally.
 *
 * @param {Object} obj
 * @return {Promise}
 * @api private
 */

function objectToPromise(obj){
  var results = new obj.constructor();
  var keys = Object.keys(obj);
  var promises = [];
  for (var i = 0; i < keys.length; i++) {
    var key = keys[i];
    var promise = toPromise.call(this, obj[key]);
    if (promise && isPromise(promise)) defer(promise, key);
    else results[key] = obj[key];
  }
  return Promise.all(promises).then(function () {
    return results;
  });

  function defer(promise, key) {
    // predefine the key in the result
    results[key] = undefined;
    promises.push(promise.then(function (res) {
      results[key] = res;
    }));
  }
}

/**
 * Check if `obj` is a promise.
 *
 * @param {Object} obj
 * @return {Boolean}
 * @api private
 */

function isPromise(obj) {
  return 'function' == typeof obj.then;
}

/**
 * Check if `obj` is a generator.
 *
 * @param {Mixed} obj
 * @return {Boolean}
 * @api private
 */

function isGenerator(obj) {
  return 'function' == typeof obj.next && 'function' == typeof obj.throw;
}

/**
 * Check if `obj` is a generator function.
 *
 * @param {Mixed} obj
 * @return {Boolean}
 * @api private
 */
function isGeneratorFunction(obj) {
  var constructor = obj.constructor;
  if (!constructor) return false;
  if ('GeneratorFunction' === constructor.name || 'GeneratorFunction' === constructor.displayName) return true;
  return isGenerator(constructor.prototype);
}

/**
 * Check for plain object.
 *
 * @param {Mixed} val
 * @return {Boolean}
 * @api private
 */

function isObject(val) {
  return Object == val.constructor;
}


/***/ }),
/* 247 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length)

var toObject = __webpack_require__(19)
  , toIndex  = __webpack_require__(34)
  , toLength = __webpack_require__(9);

module.exports = [].copyWithin || function copyWithin(target/*= 0*/, start/*= 0, end = @length*/){
  var O     = toObject(this)
    , len   = toLength(O.length)
    , to    = toIndex(target, len)
    , from  = toIndex(start, len)
    , end   = arguments.length > 2 ? arguments[2] : undefined
    , count = Math.min((end === undefined ? len : toIndex(end, len)) - from, len - to)
    , 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;
};

/***/ }),
/* 248 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length)

var toObject = __webpack_require__(19)
  , toIndex  = __webpack_require__(34)
  , toLength = __webpack_require__(9);
module.exports = function fill(value /*, start = 0, end = @length */){
  var O      = toObject(this)
    , length = toLength(O.length)
    , aLen   = arguments.length
    , index  = toIndex(aLen > 1 ? arguments[1] : undefined, length)
    , end    = aLen > 2 ? arguments[2] : undefined
    , endPos = end === undefined ? length : toIndex(end, length);
  while(endPos > index)O[index++] = value;
  return O;
};

/***/ }),
/* 249 */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(3)
  , isArray  = __webpack_require__(59)
  , SPECIES  = __webpack_require__(1)('species');

module.exports = function(original){
  var C;
  if(isArray(original)){
    C = original.constructor;
    // cross-realm fallback
    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;
};

/***/ }),
/* 250 */
/***/ (function(module, exports, __webpack_require__) {

// 9.4.2.3 ArraySpeciesCreate(originalArray, length)
var speciesConstructor = __webpack_require__(249);

module.exports = function(original, length){
  return new (speciesConstructor(original))(length);
};

/***/ }),
/* 251 */
/***/ (function(module, exports, __webpack_require__) {

// all enumerable object keys, includes symbols
var getKeys = __webpack_require__(17)
  , gOPS    = __webpack_require__(32)
  , pIE     = __webpack_require__(23);
module.exports = function(it){
  var result     = getKeys(it)
    , getSymbols = gOPS.f;
  if(getSymbols){
    var symbols = getSymbols(it)
      , isEnum  = pIE.f
      , i       = 0
      , key;
    while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))result.push(key);
  } return result;
};

/***/ }),
/* 252 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// 21.2.5.3 get RegExp.prototype.flags
var anObject = __webpack_require__(4);
module.exports = function(){
  var that   = anObject(this)
    , 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;
};

/***/ }),
/* 253 */
/***/ (function(module, exports, __webpack_require__) {

var isObject       = __webpack_require__(3)
  , setPrototypeOf = __webpack_require__(68).set;
module.exports = function(that, target, C){
  var P, S = target.constructor;
  if(S !== C && typeof S == 'function' && (P = S.prototype) !== C.prototype && isObject(P) && setPrototypeOf){
    setPrototypeOf(that, P);
  } return that;
};

/***/ }),
/* 254 */
/***/ (function(module, exports) {

// fast apply, http://jsperf.lnkit.com/fast-apply/5
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);
};

/***/ }),
/* 255 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var create         = __webpack_require__(43)
  , descriptor     = __webpack_require__(18)
  , setToStringTag = __webpack_require__(24)
  , IteratorPrototype = {};

// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
__webpack_require__(13)(IteratorPrototype, __webpack_require__(1)('iterator'), function(){ return this; });

module.exports = function(Constructor, NAME, next){
  Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)});
  setToStringTag(Constructor, NAME + ' Iterator');
};

/***/ }),
/* 256 */
/***/ (function(module, exports, __webpack_require__) {

var getKeys   = __webpack_require__(17)
  , toIObject = __webpack_require__(8);
module.exports = function(object, el){
  var O      = toIObject(object)
    , keys   = getKeys(O)
    , length = keys.length
    , index  = 0
    , key;
  while(length > index)if(O[key = keys[index++]] === el)return key;
};

/***/ }),
/* 257 */
/***/ (function(module, exports, __webpack_require__) {

var global    = __webpack_require__(2)
  , macrotask = __webpack_require__(49).set
  , Observer  = global.MutationObserver || global.WebKitMutationObserver
  , process   = global.process
  , Promise   = global.Promise
  , isNode    = __webpack_require__(16)(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();
  };

  // Node.js
  if(isNode){
    notify = function(){
      process.nextTick(flush);
    };
  // browsers with MutationObserver
  } else if(Observer){
    var toggle = true
      , node   = document.createTextNode('');
    new Observer(flush).observe(node, {characterData: true}); // eslint-disable-line no-new
    notify = function(){
      node.data = toggle = !toggle;
    };
  // environments with maybe non-completely correct, but existent Promise
  } else if(Promise && Promise.resolve){
    var promise = Promise.resolve();
    notify = function(){
      promise.then(flush);
    };
  // for other environments - macrotask based on:
  // - setImmediate
  // - MessageChannel
  // - window.postMessag
  // - onreadystatechange
  // - setTimeout
  } else {
    notify = function(){
      // strange IE + webpack dev server bug - use .call(global)
      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;
  };
};

/***/ }),
/* 258 */
/***/ (function(module, exports, __webpack_require__) {

var dP       = __webpack_require__(5)
  , anObject = __webpack_require__(4)
  , getKeys  = __webpack_require__(17);

module.exports = __webpack_require__(6) ? Object.defineProperties : function defineProperties(O, Properties){
  anObject(O);
  var keys   = getKeys(Properties)
    , length = keys.length
    , i = 0
    , P;
  while(length > i)dP.f(O, P = keys[i++], Properties[P]);
  return O;
};

/***/ }),
/* 259 */
/***/ (function(module, exports, __webpack_require__) {

// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
var toIObject = __webpack_require__(8)
  , gOPN      = __webpack_require__(45).f
  , 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));
};


/***/ }),
/* 260 */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
var has         = __webpack_require__(7)
  , toObject    = __webpack_require__(19)
  , IE_PROTO    = __webpack_require__(46)('IE_PROTO')
  , 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;
};

/***/ }),
/* 261 */
/***/ (function(module, exports, __webpack_require__) {

// all object keys, includes non-enumerable and symbols
var gOPN     = __webpack_require__(45)
  , gOPS     = __webpack_require__(32)
  , anObject = __webpack_require__(4)
  , Reflect  = __webpack_require__(2).Reflect;
module.exports = Reflect && Reflect.ownKeys || function ownKeys(it){
  var keys       = gOPN.f(anObject(it))
    , getSymbols = gOPS.f;
  return getSymbols ? keys.concat(getSymbols(it)) : keys;
};

/***/ }),
/* 262 */
/***/ (function(module, exports) {

// 7.2.9 SameValue(x, y)
module.exports = Object.is || function is(x, y){
  return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y;
};

/***/ }),
/* 263 */
/***/ (function(module, exports, __webpack_require__) {

// 7.3.20 SpeciesConstructor(O, defaultConstructor)
var anObject  = __webpack_require__(4)
  , aFunction = __webpack_require__(36)
  , SPECIES   = __webpack_require__(1)('species');
module.exports = function(O, D){
  var C = anObject(O).constructor, S;
  return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);
};

/***/ }),
/* 264 */
/***/ (function(module, exports, __webpack_require__) {

var toInteger = __webpack_require__(35)
  , defined   = __webpack_require__(11);
// true  -> String#at
// false -> String#codePointAt
module.exports = function(TO_STRING){
  return function(that, pos){
    var s = String(defined(that))
      , i = toInteger(pos)
      , l = s.length
      , 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;
  };
};

/***/ }),
/* 265 */
/***/ (function(module, exports, __webpack_require__) {

var global         = __webpack_require__(2)
  , core           = __webpack_require__(20)
  , LIBRARY        = __webpack_require__(31)
  , wksExt         = __webpack_require__(72)
  , defineProperty = __webpack_require__(5).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)});
};

/***/ }),
/* 266 */
/***/ (function(module, exports) {

/**
 * Export generator function checks.
 */
module.exports = isGenerator
module.exports.fn = isGeneratorFunction

/**
 * Check whether an object is a generator.
 *
 * @param  {Object}  obj
 * @return {Boolean}
 */
function isGenerator (obj) {
  return obj &&
    typeof obj.next === 'function' &&
    typeof obj.throw === 'function'
}

/**
 * Check whether a function is generator.
 *
 * @param  {Function} fn
 * @return {Boolean}
 */
function isGeneratorFunction (fn) {
  return typeof fn === 'function' &&
    fn.constructor &&
    fn.constructor.name === 'GeneratorFunction'
}


/***/ })
/******/ ]);
//# sourceMappingURL=e2e.entry.js.map